Joseph Doherty
e07a4fbf52
Re-review at 7286d320. -013 (Medium, testing): the managed FOCAS/2 wire-decode layer
(BuildPdu/ParseResponseBlocks, incl. cnc_getfigure stride) had zero byte-level tests; added
15 (no decode bug found). -014 (spindle-load truncation heuristic) deferred bench-gated.
Note: runtime read path is now pure-managed TCP (no P/Invoke except the probe handshake).
263 lines
10 KiB
C#
263 lines
10 KiB
C#
using System.Buffers.Binary;
|
|
using System.Net.Sockets;
|
|
using Shouldly;
|
|
using Xunit;
|
|
using ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Wire;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Tests;
|
|
|
|
/// <summary>
|
|
/// Offline byte-level coverage for the managed FOCAS/2 wire-protocol decode layer
|
|
/// (<see cref="FocasWireProtocol"/>) — the big-endian framing + block-envelope decode that
|
|
/// is this driver's analogue of P/Invoke struct marshalling. Before this suite the entire
|
|
/// wire decode surface (including the <c>cnc_getfigure</c> figure stride) ran without a
|
|
/// single byte-level test; every other test drives the <c>IFocasClient</c> seam through the
|
|
/// Fake, which bypasses all framing. Recorded as Driver.FOCAS-013.
|
|
/// </summary>
|
|
[Trait("Category", "Unit")]
|
|
public sealed class FocasWireProtocolTests
|
|
{
|
|
// ---- BuildPdu header layout ----
|
|
|
|
[Fact]
|
|
public void BuildPdu_writes_magic_version_type_direction_and_length()
|
|
{
|
|
var body = new byte[] { 0xde, 0xad, 0xbe, 0xef };
|
|
var pdu = FocasWireProtocol.BuildPdu(
|
|
FocasWireProtocol.TypeData, FocasWireProtocol.DirectionRequest, body);
|
|
|
|
pdu.Length.ShouldBe(10 + body.Length);
|
|
pdu[0].ShouldBe((byte)0xa0);
|
|
pdu[1].ShouldBe((byte)0xa0);
|
|
pdu[2].ShouldBe((byte)0xa0);
|
|
pdu[3].ShouldBe((byte)0xa0);
|
|
BinaryPrimitives.ReadUInt16BigEndian(pdu.AsSpan(4, 2)).ShouldBe(FocasWireProtocol.Version);
|
|
pdu[6].ShouldBe(FocasWireProtocol.TypeData);
|
|
pdu[7].ShouldBe(FocasWireProtocol.DirectionRequest);
|
|
BinaryPrimitives.ReadUInt16BigEndian(pdu.AsSpan(8, 2)).ShouldBe((ushort)body.Length);
|
|
pdu.AsSpan(10).ToArray().ShouldBe(body);
|
|
}
|
|
|
|
[Fact]
|
|
public void BuildPdu_rejects_a_body_larger_than_ushort_max()
|
|
{
|
|
var tooBig = new byte[ushort.MaxValue + 1];
|
|
Should.Throw<ArgumentOutOfRangeException>(() =>
|
|
FocasWireProtocol.BuildPdu(FocasWireProtocol.TypeData, FocasWireProtocol.DirectionRequest, tooBig));
|
|
}
|
|
|
|
[Fact]
|
|
public void BuildInitiateBody_writes_the_socket_index_big_endian()
|
|
{
|
|
var body = FocasWireProtocol.BuildInitiateBody(2);
|
|
body.Length.ShouldBe(2);
|
|
BinaryPrimitives.ReadUInt16BigEndian(body).ShouldBe((ushort)2);
|
|
}
|
|
|
|
// ---- BuildPdu -> ReadPduAsync round-trip over a real socket pair ----
|
|
|
|
[Fact]
|
|
public async Task BuildPdu_round_trips_through_ReadPduAsync()
|
|
{
|
|
var body = new byte[] { 1, 2, 3, 4, 5 };
|
|
var pdu = FocasWireProtocol.BuildPdu(
|
|
FocasWireProtocol.TypeData, FocasWireProtocol.DirectionResponse, body);
|
|
|
|
var (client, server) = await ConnectedPairAsync();
|
|
try
|
|
{
|
|
await server.GetStream().WriteAsync(pdu);
|
|
var read = await FocasWireProtocol.ReadPduAsync(client.GetStream(), CancellationToken.None);
|
|
|
|
read.Type.ShouldBe(FocasWireProtocol.TypeData);
|
|
read.Direction.ShouldBe(FocasWireProtocol.DirectionResponse);
|
|
read.Body.ShouldBe(body);
|
|
}
|
|
finally { client.Dispose(); server.Dispose(); }
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ReadPduAsync_rejects_bad_magic()
|
|
{
|
|
var bad = new byte[10];
|
|
bad[0] = 0x00; // not 0xa0
|
|
var (client, server) = await ConnectedPairAsync();
|
|
try
|
|
{
|
|
await server.GetStream().WriteAsync(bad);
|
|
await Should.ThrowAsync<FocasWireException>(async () =>
|
|
await FocasWireProtocol.ReadPduAsync(client.GetStream(), CancellationToken.None));
|
|
}
|
|
finally { client.Dispose(); server.Dispose(); }
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ReadPduAsync_rejects_unsupported_version()
|
|
{
|
|
var header = new byte[10];
|
|
new byte[] { 0xa0, 0xa0, 0xa0, 0xa0 }.CopyTo(header, 0);
|
|
BinaryPrimitives.WriteUInt16BigEndian(header.AsSpan(4, 2), 99); // unsupported version
|
|
var (client, server) = await ConnectedPairAsync();
|
|
try
|
|
{
|
|
await server.GetStream().WriteAsync(header);
|
|
await Should.ThrowAsync<FocasWireException>(async () =>
|
|
await FocasWireProtocol.ReadPduAsync(client.GetStream(), CancellationToken.None));
|
|
}
|
|
finally { client.Dispose(); server.Dispose(); }
|
|
}
|
|
|
|
// ---- BuildRequestBody framing ----
|
|
|
|
[Fact]
|
|
public void BuildRequestBody_prefixes_the_block_count_and_concatenates_blocks()
|
|
{
|
|
var blocks = new[]
|
|
{
|
|
new RequestBlock(0x0018, PathId: 1),
|
|
new RequestBlock(0x0019, Arg1: 7, PathId: 1),
|
|
};
|
|
var body = FocasWireProtocol.BuildRequestBody(blocks);
|
|
|
|
BinaryPrimitives.ReadUInt16BigEndian(body.AsSpan(0, 2)).ShouldBe((ushort)2);
|
|
// First block sits right after the 2-byte count; its declared block length is at +0.
|
|
var firstLen = BinaryPrimitives.ReadUInt16BigEndian(body.AsSpan(2, 2));
|
|
firstLen.ShouldBe((ushort)0x1c); // no extra payload → header-only block
|
|
BinaryPrimitives.ReadUInt16BigEndian(body.AsSpan(2 + 6, 2)).ShouldBe((ushort)0x0018); // command @ +6
|
|
}
|
|
|
|
// ---- ParseResponseBlocks: command / RC / payload extraction ----
|
|
|
|
[Fact]
|
|
public void ParseResponseBlocks_decodes_command_rc_and_payload()
|
|
{
|
|
var payload = new byte[] { 0xAA, 0xBB, 0xCC, 0xDD };
|
|
var body = BuildResponseBody(
|
|
(command: (ushort)0x0018, rc: (short)0, payload: payload),
|
|
(command: (ushort)0x0019, rc: (short)6 /* EW_NOOPT */, payload: Array.Empty<byte>()));
|
|
|
|
var blocks = FocasWireProtocol.ParseResponseBlocks(body);
|
|
|
|
blocks.Count.ShouldBe(2);
|
|
blocks[0].Command.ShouldBe((ushort)0x0018);
|
|
blocks[0].Rc.ShouldBe((short)0);
|
|
blocks[0].Payload.ShouldBe(payload);
|
|
blocks[1].Command.ShouldBe((ushort)0x0019);
|
|
blocks[1].Rc.ShouldBe((short)6);
|
|
blocks[1].Payload.ShouldBeEmpty();
|
|
}
|
|
|
|
[Fact]
|
|
public void ParseResponseBlocks_returns_empty_for_a_body_shorter_than_the_count_field()
|
|
{
|
|
FocasWireProtocol.ParseResponseBlocks(new byte[] { 0x00 }).ShouldBeEmpty();
|
|
}
|
|
|
|
[Fact]
|
|
public void ParseResponseBlocks_throws_on_a_truncated_block_length_field()
|
|
{
|
|
// count says 1 block, but only one stray byte follows the count.
|
|
var body = new byte[] { 0x00, 0x01, 0x00 };
|
|
Should.Throw<FocasWireException>(() => FocasWireProtocol.ParseResponseBlocks(body));
|
|
}
|
|
|
|
[Fact]
|
|
public void ParseResponseBlocks_throws_when_the_declared_block_length_is_below_the_header()
|
|
{
|
|
var body = new byte[4];
|
|
BinaryPrimitives.WriteUInt16BigEndian(body.AsSpan(0, 2), 1); // 1 block
|
|
BinaryPrimitives.WriteUInt16BigEndian(body.AsSpan(2, 2), 0x08); // block length < 0x10
|
|
Should.Throw<FocasWireException>(() => FocasWireProtocol.ParseResponseBlocks(body));
|
|
}
|
|
|
|
// ---- The cnc_getfigure figure stride: decode a response block into shorts ----
|
|
|
|
[Fact]
|
|
public void ParseResponseBlocks_yields_a_payload_that_decodes_as_a_sequence_of_figure_shorts()
|
|
{
|
|
// cnc_getfigure (command 0x00d3) returns one big-endian short per axis. Build the
|
|
// response block and assert the payload decodes to the [3, 1, 0] figure sequence the
|
|
// driver's auto-scale path reads.
|
|
var figurePayload = new byte[6];
|
|
BinaryPrimitives.WriteInt16BigEndian(figurePayload.AsSpan(0, 2), 3);
|
|
BinaryPrimitives.WriteInt16BigEndian(figurePayload.AsSpan(2, 2), 1);
|
|
BinaryPrimitives.WriteInt16BigEndian(figurePayload.AsSpan(4, 2), 0);
|
|
|
|
var body = BuildResponseBody((command: (ushort)0x00d3, rc: (short)0, payload: figurePayload));
|
|
var block = FocasWireProtocol.ParseResponseBlocks(body).Single();
|
|
|
|
var figures = new List<int>();
|
|
for (var offset = 0; offset + 2 <= block.Payload.Length; offset += 2)
|
|
figures.Add(BinaryPrimitives.ReadInt16BigEndian(block.Payload.AsSpan(offset, 2)));
|
|
|
|
figures.ShouldBe(new[] { 3, 1, 0 });
|
|
}
|
|
|
|
// ---- ReadAscii / ReadNameRecord ----
|
|
|
|
[Fact]
|
|
public void ReadAscii_stops_at_the_first_NUL_and_trims_trailing_space()
|
|
{
|
|
var bytes = "30i \0junkafternul"u8.ToArray();
|
|
FocasWireProtocol.ReadAscii(bytes).ShouldBe("30i");
|
|
}
|
|
|
|
[Fact]
|
|
public void ReadAscii_trims_trailing_spaces_without_a_NUL()
|
|
{
|
|
FocasWireProtocol.ReadAscii("A1.0 "u8.ToArray()).ShouldBe("A1.0");
|
|
}
|
|
|
|
[Fact]
|
|
public void ReadNameRecord_reads_two_bytes_and_strips_padding()
|
|
{
|
|
FocasWireProtocol.ReadNameRecord("X \0\0"u8.ToArray()).ShouldBe("X");
|
|
FocasWireProtocol.ReadNameRecord("XY"u8.ToArray()).ShouldBe("XY");
|
|
FocasWireProtocol.ReadNameRecord(new byte[] { 0x58 }).ShouldBe(string.Empty); // < 2 bytes
|
|
}
|
|
|
|
// ---- helpers ----
|
|
|
|
/// <summary>Build a response body in the 0x21 response-block shape ParseResponseBlocks expects.</summary>
|
|
private static byte[] BuildResponseBody(params (ushort command, short rc, byte[] payload)[] blocks)
|
|
{
|
|
var encoded = blocks.Select(b =>
|
|
{
|
|
var blockLen = 0x10 + b.payload.Length;
|
|
var block = new byte[blockLen];
|
|
BinaryPrimitives.WriteUInt16BigEndian(block.AsSpan(0, 2), (ushort)blockLen);
|
|
BinaryPrimitives.WriteUInt16BigEndian(block.AsSpan(6, 2), b.command);
|
|
BinaryPrimitives.WriteInt16BigEndian(block.AsSpan(8, 2), b.rc);
|
|
BinaryPrimitives.WriteUInt16BigEndian(block.AsSpan(14, 2), (ushort)b.payload.Length);
|
|
b.payload.CopyTo(block.AsSpan(16));
|
|
return block;
|
|
}).ToArray();
|
|
|
|
var body = new byte[2 + encoded.Sum(b => b.Length)];
|
|
BinaryPrimitives.WriteUInt16BigEndian(body.AsSpan(0, 2), (ushort)encoded.Length);
|
|
var offset = 2;
|
|
foreach (var block in encoded)
|
|
{
|
|
block.CopyTo(body.AsSpan(offset));
|
|
offset += block.Length;
|
|
}
|
|
return body;
|
|
}
|
|
|
|
private static async Task<(TcpClient client, TcpClient server)> ConnectedPairAsync()
|
|
{
|
|
var listener = new TcpListener(System.Net.IPAddress.Loopback, 0);
|
|
listener.Start();
|
|
try
|
|
{
|
|
var port = ((System.Net.IPEndPoint)listener.LocalEndpoint).Port;
|
|
var client = new TcpClient();
|
|
var connect = client.ConnectAsync(System.Net.IPAddress.Loopback, port);
|
|
var server = await listener.AcceptTcpClientAsync();
|
|
await connect;
|
|
return (client, server);
|
|
}
|
|
finally { listener.Stop(); }
|
|
}
|
|
}
|