Livt packages
Livt.Net
Version 1.4.1
Ethernet, IPv4, TCP, UDP, ARP, TFTP, and Telnet networking components for Livt hardware.
Published files (163)
- ethernet
- services
- tftp
- ArpCompositionChecks.lvt
- ArpPacketParserTest.lvt
- ArpResponderTest.lvt
- ChecksumApiTest.lvt
- ChecksumWordSumTest.lvt
- CompactPacketFieldsTest.lvt
- CountingPacketData.lvt
- EthernetFrameBuilderTest.lvt
- EthernetFrameParserTest.lvt
- EthernetLiteDeviceFixture.lvt
- EthernetLiteDriverTest.lvt
- EthernetLiteReceiveWindowTest.lvt
- EthernetLiteResetScenario.lvt
- EthernetLiteResetTest.lvt
- FaultingFrameData.lvt
- FaultingPacketData.lvt
- FrameCapacityTest.lvt
- FrameCompositionTest.lvt
- FrameForwarder.lvt
- FrameLinkTest.lvt
- FrameMii10Link.lvt
- FrameMiiLink.lvt
- FrameMiiPins.lvt
- GenericPacketTest.lvt
- IcmpCapacityChecks.lvt
- IcmpEchoResponderTest.lvt
- IcmpStorageBackendTest.lvt
- InternetChecksumTest.lvt
- Ipv4HeaderBuilderTest.lvt
- Ipv4HeaderChecksumTest.lvt
- Ipv4PacketFieldsTest.lvt
- Ipv4PacketParserTest.lvt
- MiiFrame10Test.lvt
- MiiFrameTest.lvt
- PacketConvenienceTest.lvt
- PacketDataTest.lvt
- PacketMetadataStub.lvt
- PacketMetadataTest.lvt
- PacketParserFailureTest.lvt
- PacketStorageParityTest.lvt
- RamIpv4PacketParserTest.lvt
- ReceiveContractChecks.lvt
- ScheduledWordSumTest.lvt
- SynAckCompositionChecks.lvt
- TcpChecksumTest.lvt
- TcpConnectionRecognizerTest.lvt
- TcpHeaderParserTest.lvt
- TcpMultiSessionArrayStorageTest.lvt
- TcpMultiSessionAutoStorageTest.lvt
- TcpMultiSessionDistributedStorageTest.lvt
- TcpMultiSessionMixedStorageTest.lvt
- TcpMultiSessionStorageChecks.lvt
- TcpMultiSessionTest.lvt
- TcpRamPacketTest.lvt
- TcpRetryTimerTest.lvt
- TcpSegmentBuilderTest.lvt
- TcpSegmentTest.lvt
- TcpStreamServerArrayStorageTest.lvt
- TcpStreamServerAutoStorageTest.lvt
- TcpStreamServerDistributedStorageTest.lvt
- TcpStreamServerMixedStorageTest.lvt
- TcpStreamServerStorageChecks.lvt
- TcpStreamServerTest.lvt
- TelnetSessionTest.lvt
- TransmitContractChecks.lvt
- UdpPacketTest.lvt
tests/GenericPacketTest.lvt
namespace Livt.Net.Tests
using Livt.Net
/**
* Checks complete literal frame vectors for array/RAM graphs, including odd data and reuse. Each case initializes its graph.
*/
@Test
component GenericPacketTest
{
// Independent array/RAM packet graphs; each test initializes its own graph.
small: ArrayPacketData<32>
smallEcho: IcmpEchoReply<ArrayPacketData<32>>
smallIp: Ipv4Packet<IcmpEchoReply<ArrayPacketData<32>>>
smallFrame: EthernetFrame<Ipv4Packet<IcmpEchoReply<ArrayPacketData<32>>>>
large: ArrayPacketData<128>
largeEcho: IcmpEchoReply<ArrayPacketData<128>>
largeIp: Ipv4Packet<IcmpEchoReply<ArrayPacketData<128>>>
largeFrame: EthernetFrame<Ipv4Packet<IcmpEchoReply<ArrayPacketData<128>>>>
ram: RamPacketData<96>
ramEcho: IcmpEchoReply<RamPacketData<96>>
ramIp: Ipv4Packet<IcmpEchoReply<RamPacketData<96>>>
ramFrame: EthernetFrame<Ipv4Packet<IcmpEchoReply<RamPacketData<96>>>>
arp: ArpReply
arpFrame: EthernetFrame<ArpReply>
/**
* Constructs independent array/RAM echo graphs and an ARP graph without preparing them.
*/
new()
{
small = new ArrayPacketData<32>()
smallEcho = new IcmpEchoReply<ArrayPacketData<32>>(small)
smallIp = new Ipv4Packet<IcmpEchoReply<ArrayPacketData<32>>>(smallEcho)
smallFrame = new EthernetFrame<Ipv4Packet<IcmpEchoReply<ArrayPacketData<32>>>>(smallIp)
large = new ArrayPacketData<128>()
largeEcho = new IcmpEchoReply<ArrayPacketData<128>>(large)
largeIp = new Ipv4Packet<IcmpEchoReply<ArrayPacketData<128>>>(largeEcho)
largeFrame = new EthernetFrame<Ipv4Packet<IcmpEchoReply<ArrayPacketData<128>>>>(largeIp)
ram = new RamPacketData<96>()
ramEcho = new IcmpEchoReply<RamPacketData<96>>(ram)
ramIp = new Ipv4Packet<IcmpEchoReply<RamPacketData<96>>>(ramEcho)
ramFrame = new EthernetFrame<Ipv4Packet<IcmpEchoReply<RamPacketData<96>>>>(ramIp)
arp = new ArpReply()
arpFrame = new EthernetFrame<ArpReply>(arp)
}
/**
* Checks every frame byte, lengths and bounds across odd, even, empty and reused small-array payloads.
*/
@Test
fn EmitsExpectedFramesFromSmallArray()
{
smallFrame.Invalidate()
smallIp.Invalidate()
smallEcho.Invalidate()
if (small.IsReady()) {
small.TryRelease()
}
else {
small.TryClear()
}
var mac: byte[6] = [0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE]
var peer: byte[6] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE]
var localIp: byte[4] = [0xC0, 0xA8, 0x01, 0x80]
var remoteIp: byte[4] = [0xC0, 0xA8, 0x01, 0xFF]
var identification: byte[2] = [0x12, 0x34]
var identifier: byte[2] = [0xAB, 0xCD]
var sequence: byte[2] = [0x80, 0xFE]
var value: byte = 0x00
assert smallEcho.TryRead(0, value) == PacketDataResult.NotReady
assert smallIp.TryRead(0, value) == PacketDataResult.NotReady
assert smallFrame.TryRead(0, value) == PacketDataResult.NotReady
assert smallEcho.TryPrepare(identifier, sequence) == PacketDataResult.NotReady
// Independent complete frame vector; includes checksum and padding bytes.
var expected0: byte[74] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x3C, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0xBD, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xDA, 0x2A, 0xAB, 0xCD, 0x80, 0xFE, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F]
for (var i = 0; i < 32; i++) {
assert small.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert small.TryPublish() == PacketDataResult.Success
assert smallEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert smallIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert smallFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert smallEcho.GetAvailableLength() == 40
assert smallIp.GetAvailableLength() == 60
assert smallFrame.GetAvailableLength() == 74
assert small.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 74; i++) {
assert smallFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected0[i]
}
assert smallFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert smallFrame.TryRead(74, value) == PacketDataResult.Invalid
assert smallIp.TryRead(60, value) == PacketDataResult.Invalid
assert smallEcho.TryRead(40, value) == PacketDataResult.Invalid
smallFrame.Invalidate()
smallIp.Invalidate()
smallEcho.Invalidate()
assert small.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected1: byte[60] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x1F, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0xDA, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xD0, 0xB1, 0xAB, 0xCD, 0x80, 0xFE, 0x80, 0x81, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
for (var i = 0; i < 3; i++) {
assert small.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert small.TryPublish() == PacketDataResult.Success
assert smallEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert smallIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert smallFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert smallEcho.GetAvailableLength() == 11
assert smallIp.GetAvailableLength() == 31
assert smallFrame.GetAvailableLength() == 60
assert small.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 60; i++) {
assert smallFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected1[i]
}
assert smallFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert smallFrame.TryRead(60, value) == PacketDataResult.Invalid
assert smallIp.TryRead(31, value) == PacketDataResult.Invalid
assert smallEcho.TryRead(11, value) == PacketDataResult.Invalid
smallFrame.Invalidate()
smallIp.Invalidate()
smallEcho.Invalidate()
assert small.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected2: byte[60] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x20, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0xD9, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xD0, 0x2E, 0xAB, 0xCD, 0x80, 0xFE, 0x80, 0x81, 0x82, 0x83, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
for (var i = 0; i < 4; i++) {
assert small.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert small.TryPublish() == PacketDataResult.Success
assert smallEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert smallIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert smallFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert smallEcho.GetAvailableLength() == 12
assert smallIp.GetAvailableLength() == 32
assert smallFrame.GetAvailableLength() == 60
assert small.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 60; i++) {
assert smallFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected2[i]
}
assert smallFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert smallFrame.TryRead(60, value) == PacketDataResult.Invalid
assert smallIp.TryRead(32, value) == PacketDataResult.Invalid
assert smallEcho.TryRead(12, value) == PacketDataResult.Invalid
smallFrame.Invalidate()
smallIp.Invalidate()
smallEcho.Invalidate()
assert small.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected3: byte[60] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x1C, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0xDD, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xD3, 0x33, 0xAB, 0xCD, 0x80, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
for (var i = 0; i < 0; i++) {
assert small.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert small.TryPublish() == PacketDataResult.Success
assert smallEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert smallIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert smallFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert smallEcho.GetAvailableLength() == 8
assert smallIp.GetAvailableLength() == 28
assert smallFrame.GetAvailableLength() == 60
assert small.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 60; i++) {
assert smallFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected3[i]
}
assert smallFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert smallFrame.TryRead(60, value) == PacketDataResult.Invalid
assert smallIp.TryRead(28, value) == PacketDataResult.Invalid
assert smallEcho.TryRead(8, value) == PacketDataResult.Invalid
smallFrame.Invalidate()
smallIp.Invalidate()
smallEcho.Invalidate()
assert small.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected4: byte[74] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x3C, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0xBD, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xDA, 0x2A, 0xAB, 0xCD, 0x80, 0xFE, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F]
for (var i = 0; i < 32; i++) {
assert small.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert small.TryPublish() == PacketDataResult.Success
assert smallEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert smallIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert smallFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert smallEcho.GetAvailableLength() == 40
assert smallIp.GetAvailableLength() == 60
assert smallFrame.GetAvailableLength() == 74
assert small.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 74; i++) {
assert smallFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected4[i]
}
assert smallFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert smallFrame.TryRead(74, value) == PacketDataResult.Invalid
assert smallIp.TryRead(60, value) == PacketDataResult.Invalid
assert smallEcho.TryRead(40, value) == PacketDataResult.Invalid
smallFrame.Invalidate()
smallIp.Invalidate()
smallEcho.Invalidate()
assert small.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected5: byte[74] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x3C, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0xBD, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xCA, 0x1A, 0xAB, 0xCD, 0x80, 0xFE, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0]
for (var i = 0; i < 32; i++) {
assert small.TryWrite(i, (129 + i) as byte) == PacketDataResult.Success
}
assert small.TryPublish() == PacketDataResult.Success
assert smallEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert smallIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert smallFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert smallEcho.GetAvailableLength() == 40
assert smallIp.GetAvailableLength() == 60
assert smallFrame.GetAvailableLength() == 74
assert small.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 74; i++) {
assert smallFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected5[i]
}
assert smallFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert smallFrame.TryRead(74, value) == PacketDataResult.Invalid
assert smallIp.TryRead(60, value) == PacketDataResult.Invalid
assert smallEcho.TryRead(40, value) == PacketDataResult.Invalid
smallFrame.Invalidate()
smallIp.Invalidate()
smallEcho.Invalidate()
assert small.TryRelease() == PacketDataResult.Success
}
/**
* Checks complete frames from the larger array graph without sharing preparation state with other cases.
*/
@Test
fn EmitsExpectedFramesFromLargeArray()
{
largeFrame.Invalidate()
largeIp.Invalidate()
largeEcho.Invalidate()
if (large.IsReady()) {
large.TryRelease()
}
else {
large.TryClear()
}
var mac: byte[6] = [0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE]
var peer: byte[6] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE]
var localIp: byte[4] = [0xC0, 0xA8, 0x01, 0x80]
var remoteIp: byte[4] = [0xC0, 0xA8, 0x01, 0xFF]
var identification: byte[2] = [0x12, 0x34]
var identifier: byte[2] = [0xAB, 0xCD]
var sequence: byte[2] = [0x80, 0xFE]
var value: byte = 0x00
assert largeEcho.TryRead(0, value) == PacketDataResult.NotReady
assert largeIp.TryRead(0, value) == PacketDataResult.NotReady
assert largeFrame.TryRead(0, value) == PacketDataResult.NotReady
assert largeEcho.TryPrepare(identifier, sequence) == PacketDataResult.NotReady
// Independent complete frame vector; includes checksum and padding bytes.
var expected0: byte[74] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x3C, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0xBD, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xDA, 0x2A, 0xAB, 0xCD, 0x80, 0xFE, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F]
for (var i = 0; i < 32; i++) {
assert large.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert large.TryPublish() == PacketDataResult.Success
assert largeEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert largeIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert largeFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert largeEcho.GetAvailableLength() == 40
assert largeIp.GetAvailableLength() == 60
assert largeFrame.GetAvailableLength() == 74
assert large.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 74; i++) {
assert largeFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected0[i]
}
assert largeFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert largeFrame.TryRead(74, value) == PacketDataResult.Invalid
assert largeIp.TryRead(60, value) == PacketDataResult.Invalid
assert largeEcho.TryRead(40, value) == PacketDataResult.Invalid
largeFrame.Invalidate()
largeIp.Invalidate()
largeEcho.Invalidate()
assert large.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected1: byte[60] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x1F, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0xDA, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xD0, 0xB1, 0xAB, 0xCD, 0x80, 0xFE, 0x80, 0x81, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
for (var i = 0; i < 3; i++) {
assert large.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert large.TryPublish() == PacketDataResult.Success
assert largeEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert largeIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert largeFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert largeEcho.GetAvailableLength() == 11
assert largeIp.GetAvailableLength() == 31
assert largeFrame.GetAvailableLength() == 60
assert large.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 60; i++) {
assert largeFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected1[i]
}
assert largeFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert largeFrame.TryRead(60, value) == PacketDataResult.Invalid
assert largeIp.TryRead(31, value) == PacketDataResult.Invalid
assert largeEcho.TryRead(11, value) == PacketDataResult.Invalid
largeFrame.Invalidate()
largeIp.Invalidate()
largeEcho.Invalidate()
assert large.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected2: byte[60] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x20, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0xD9, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xD0, 0x2E, 0xAB, 0xCD, 0x80, 0xFE, 0x80, 0x81, 0x82, 0x83, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
for (var i = 0; i < 4; i++) {
assert large.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert large.TryPublish() == PacketDataResult.Success
assert largeEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert largeIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert largeFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert largeEcho.GetAvailableLength() == 12
assert largeIp.GetAvailableLength() == 32
assert largeFrame.GetAvailableLength() == 60
assert large.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 60; i++) {
assert largeFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected2[i]
}
assert largeFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert largeFrame.TryRead(60, value) == PacketDataResult.Invalid
assert largeIp.TryRead(32, value) == PacketDataResult.Invalid
assert largeEcho.TryRead(12, value) == PacketDataResult.Invalid
largeFrame.Invalidate()
largeIp.Invalidate()
largeEcho.Invalidate()
assert large.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected3: byte[60] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x1C, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0xDD, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xD3, 0x33, 0xAB, 0xCD, 0x80, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
for (var i = 0; i < 0; i++) {
assert large.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert large.TryPublish() == PacketDataResult.Success
assert largeEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert largeIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert largeFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert largeEcho.GetAvailableLength() == 8
assert largeIp.GetAvailableLength() == 28
assert largeFrame.GetAvailableLength() == 60
assert large.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 60; i++) {
assert largeFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected3[i]
}
assert largeFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert largeFrame.TryRead(60, value) == PacketDataResult.Invalid
assert largeIp.TryRead(28, value) == PacketDataResult.Invalid
assert largeEcho.TryRead(8, value) == PacketDataResult.Invalid
largeFrame.Invalidate()
largeIp.Invalidate()
largeEcho.Invalidate()
assert large.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected4: byte[107] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x5D, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0x9C, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0x1F, 0x1F, 0xAB, 0xCD, 0x80, 0xFE, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0]
for (var i = 0; i < 65; i++) {
assert large.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert large.TryPublish() == PacketDataResult.Success
assert largeEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert largeIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert largeFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert largeEcho.GetAvailableLength() == 73
assert largeIp.GetAvailableLength() == 93
assert largeFrame.GetAvailableLength() == 107
assert large.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 107; i++) {
assert largeFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected4[i]
}
assert largeFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert largeFrame.TryRead(107, value) == PacketDataResult.Invalid
assert largeIp.TryRead(93, value) == PacketDataResult.Invalid
assert largeEcho.TryRead(73, value) == PacketDataResult.Invalid
largeFrame.Invalidate()
largeIp.Invalidate()
largeEcho.Invalidate()
assert large.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected5: byte[107] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x5D, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0x9C, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xFD, 0xFE, 0xAB, 0xCD, 0x80, 0xFE, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1]
for (var i = 0; i < 65; i++) {
assert large.TryWrite(i, (129 + i) as byte) == PacketDataResult.Success
}
assert large.TryPublish() == PacketDataResult.Success
assert largeEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert largeIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert largeFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert largeEcho.GetAvailableLength() == 73
assert largeIp.GetAvailableLength() == 93
assert largeFrame.GetAvailableLength() == 107
assert large.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 107; i++) {
assert largeFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected5[i]
}
assert largeFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert largeFrame.TryRead(107, value) == PacketDataResult.Invalid
assert largeIp.TryRead(93, value) == PacketDataResult.Invalid
assert largeEcho.TryRead(73, value) == PacketDataResult.Invalid
largeFrame.Invalidate()
largeIp.Invalidate()
largeEcho.Invalidate()
assert large.TryRelease() == PacketDataResult.Success
}
/**
* Checks the same wire expectations with scheduled RAM reads and retained-storage reuse.
*/
@Test
fn EmitsExpectedFramesFromRam()
{
ramFrame.Invalidate()
ramIp.Invalidate()
ramEcho.Invalidate()
if (ram.IsReady()) {
ram.TryRelease()
}
else {
ram.TryClear()
}
var mac: byte[6] = [0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE]
var peer: byte[6] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE]
var localIp: byte[4] = [0xC0, 0xA8, 0x01, 0x80]
var remoteIp: byte[4] = [0xC0, 0xA8, 0x01, 0xFF]
var identification: byte[2] = [0x12, 0x34]
var identifier: byte[2] = [0xAB, 0xCD]
var sequence: byte[2] = [0x80, 0xFE]
var value: byte = 0x00
assert ramEcho.TryRead(0, value) == PacketDataResult.NotReady
assert ramIp.TryRead(0, value) == PacketDataResult.NotReady
assert ramFrame.TryRead(0, value) == PacketDataResult.NotReady
assert ramEcho.TryPrepare(identifier, sequence) == PacketDataResult.NotReady
// Independent complete frame vector; includes checksum and padding bytes.
var expected0: byte[74] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x3C, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0xBD, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xDA, 0x2A, 0xAB, 0xCD, 0x80, 0xFE, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F]
for (var i = 0; i < 32; i++) {
assert ram.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert ram.TryPublish() == PacketDataResult.Success
assert ramEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert ramIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert ramFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert ramEcho.GetAvailableLength() == 40
assert ramIp.GetAvailableLength() == 60
assert ramFrame.GetAvailableLength() == 74
assert ram.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 74; i++) {
assert ramFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected0[i]
}
assert ramFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert ramFrame.TryRead(74, value) == PacketDataResult.Invalid
assert ramIp.TryRead(60, value) == PacketDataResult.Invalid
assert ramEcho.TryRead(40, value) == PacketDataResult.Invalid
ramFrame.Invalidate()
ramIp.Invalidate()
ramEcho.Invalidate()
assert ram.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected1: byte[60] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x1F, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0xDA, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xD0, 0xB1, 0xAB, 0xCD, 0x80, 0xFE, 0x80, 0x81, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
for (var i = 0; i < 3; i++) {
assert ram.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert ram.TryPublish() == PacketDataResult.Success
assert ramEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert ramIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert ramFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert ramEcho.GetAvailableLength() == 11
assert ramIp.GetAvailableLength() == 31
assert ramFrame.GetAvailableLength() == 60
assert ram.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 60; i++) {
assert ramFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected1[i]
}
assert ramFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert ramFrame.TryRead(60, value) == PacketDataResult.Invalid
assert ramIp.TryRead(31, value) == PacketDataResult.Invalid
assert ramEcho.TryRead(11, value) == PacketDataResult.Invalid
ramFrame.Invalidate()
ramIp.Invalidate()
ramEcho.Invalidate()
assert ram.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected2: byte[60] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x20, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0xD9, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xD0, 0x2E, 0xAB, 0xCD, 0x80, 0xFE, 0x80, 0x81, 0x82, 0x83, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
for (var i = 0; i < 4; i++) {
assert ram.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert ram.TryPublish() == PacketDataResult.Success
assert ramEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert ramIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert ramFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert ramEcho.GetAvailableLength() == 12
assert ramIp.GetAvailableLength() == 32
assert ramFrame.GetAvailableLength() == 60
assert ram.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 60; i++) {
assert ramFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected2[i]
}
assert ramFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert ramFrame.TryRead(60, value) == PacketDataResult.Invalid
assert ramIp.TryRead(32, value) == PacketDataResult.Invalid
assert ramEcho.TryRead(12, value) == PacketDataResult.Invalid
ramFrame.Invalidate()
ramIp.Invalidate()
ramEcho.Invalidate()
assert ram.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected3: byte[60] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x1C, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0xDD, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xD3, 0x33, 0xAB, 0xCD, 0x80, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
for (var i = 0; i < 0; i++) {
assert ram.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert ram.TryPublish() == PacketDataResult.Success
assert ramEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert ramIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert ramFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert ramEcho.GetAvailableLength() == 8
assert ramIp.GetAvailableLength() == 28
assert ramFrame.GetAvailableLength() == 60
assert ram.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 60; i++) {
assert ramFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected3[i]
}
assert ramFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert ramFrame.TryRead(60, value) == PacketDataResult.Invalid
assert ramIp.TryRead(28, value) == PacketDataResult.Invalid
assert ramEcho.TryRead(8, value) == PacketDataResult.Invalid
ramFrame.Invalidate()
ramIp.Invalidate()
ramEcho.Invalidate()
assert ram.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected4: byte[107] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x5D, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0x9C, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0x1F, 0x1F, 0xAB, 0xCD, 0x80, 0xFE, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0]
for (var i = 0; i < 65; i++) {
assert ram.TryWrite(i, (128 + i) as byte) == PacketDataResult.Success
}
assert ram.TryPublish() == PacketDataResult.Success
assert ramEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert ramIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert ramFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert ramEcho.GetAvailableLength() == 73
assert ramIp.GetAvailableLength() == 93
assert ramFrame.GetAvailableLength() == 107
assert ram.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 107; i++) {
assert ramFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected4[i]
}
assert ramFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert ramFrame.TryRead(107, value) == PacketDataResult.Invalid
assert ramIp.TryRead(93, value) == PacketDataResult.Invalid
assert ramEcho.TryRead(73, value) == PacketDataResult.Invalid
ramFrame.Invalidate()
ramIp.Invalidate()
ramEcho.Invalidate()
assert ram.TryRelease() == PacketDataResult.Success
// Independent complete frame vector; includes checksum and padding bytes.
var expected5: byte[107] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x00, 0x45, 0x00, 0x00, 0x5D, 0x12, 0x34, 0x40, 0x00, 0x40, 0x01, 0xA3, 0x9C, 0xC0, 0xA8, 0x01, 0x80, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0xFD, 0xFE, 0xAB, 0xCD, 0x80, 0xFE, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1]
for (var i = 0; i < 65; i++) {
assert ram.TryWrite(i, (129 + i) as byte) == PacketDataResult.Success
}
assert ram.TryPublish() == PacketDataResult.Success
assert ramEcho.TryPrepare(identifier, sequence) == PacketDataResult.Success
assert ramIp.TryPrepare(localIp, remoteIp, identification) == PacketDataResult.Success
assert ramFrame.TryPrepare(mac, peer) == PacketDataResult.Success
assert ramEcho.GetAvailableLength() == 73
assert ramIp.GetAvailableLength() == 93
assert ramFrame.GetAvailableLength() == 107
assert ram.TryWrite(0, 0x00) == PacketDataResult.Busy
for (var i = 0; i < 107; i++) {
assert ramFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected5[i]
}
assert ramFrame.TryRead(-1, value) == PacketDataResult.Invalid
assert ramFrame.TryRead(107, value) == PacketDataResult.Invalid
assert ramIp.TryRead(93, value) == PacketDataResult.Invalid
assert ramEcho.TryRead(73, value) == PacketDataResult.Invalid
ramFrame.Invalidate()
ramIp.Invalidate()
ramEcho.Invalidate()
assert ram.TryRelease() == PacketDataResult.Success
}
/**
* Checks all ARP frame bytes and minimum padding, then reverses the endpoints for reuse.
*/
@Test
fn PadsArpRepliesAndRefreshesAddressesOnReuse()
{
arpFrame.Invalidate()
arp.Invalidate()
var mac: byte[6] = [0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE]
var peer: byte[6] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE]
var localIp: byte[4] = [0xC0, 0xA8, 0x01, 0x80]
var remoteIp: byte[4] = [0xC0, 0xA8, 0x01, 0xFF]
var identification: byte[2] = [0x12, 0x34]
var identifier: byte[2] = [0xAB, 0xCD]
var sequence: byte[2] = [0x80, 0xFE]
var value: byte = 0x00
assert arpFrame.TryPrepare(mac, peer) == PacketDataResult.NotReady
assert arp.TryRead(0, value) == PacketDataResult.NotReady
assert arp.TryPrepare(mac, localIp, peer, remoteIp) == PacketDataResult.Success
assert arpFrame.TryPrepare(mac, peer) == PacketDataResult.Success
var expected: byte[60] = [0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x08, 0x06, 0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x02, 0x02, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xC0, 0xA8, 0x01, 0x80, 0x82, 0x10, 0x20, 0x30, 0x40, 0xFE, 0xC0, 0xA8, 0x01, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
for (var i = 0; i < 60; i++) {
assert arpFrame.TryRead(i, value) == PacketDataResult.Success
assert value == expected[i]
}
assert arp.TryRead(28, value) == PacketDataResult.Invalid
assert arpFrame.TryRead(60, value) == PacketDataResult.Invalid
arpFrame.Invalidate()
arp.Invalidate()
assert arpFrame.TryPrepare(mac, peer) == PacketDataResult.NotReady
assert arp.TryPrepare(peer, remoteIp, mac, localIp) == PacketDataResult.Success
assert arpFrame.TryPrepare(peer, mac) == PacketDataResult.Success
for (var i = 0; i < 6; i++) {
assert arpFrame.TryRead(i, value) == PacketDataResult.Success
assert value == mac[i]
assert arpFrame.TryRead(6 + i, value) == PacketDataResult.Success
assert value == peer[i]
}
arpFrame.Invalidate()
arp.Invalidate()
}
}