Leonid Pershin
9e429d0cd7
Corridor waiters need a summon-phase byte on presence (v11); EventDef DirectorSummoned is info-only so clocks keep running.
580 lines
23 KiB
C#
580 lines
23 KiB
C#
namespace HSchool.Protocol.Tests;
|
||
|
||
/// <summary>
|
||
/// The wire format is a contract with the browser client. Round-trips prove the C# side is
|
||
/// self-consistent; the explicit byte-layout tests are what keeps
|
||
/// <c>src/HSchool.Client/src/net/protocol.ts</c> honest.
|
||
/// </summary>
|
||
public class ProtocolCodecTests
|
||
{
|
||
[Fact]
|
||
public void Hello_RoundTripsAndIsThreeBytes()
|
||
{
|
||
var message = new ClientHelloMessage(ProtocolConstants.Version, ProtocolConstants.LocaleEnglish);
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
|
||
var length = ProtocolCodec.WriteHello(buffer, message);
|
||
|
||
Assert.Equal(3, length);
|
||
Assert.Equal((byte)MessageType.ClientHello, buffer[0]);
|
||
Assert.Equal(ProtocolConstants.Version, buffer[1]);
|
||
Assert.Equal(ProtocolConstants.LocaleEnglish, buffer[2]);
|
||
Assert.Equal(message, ProtocolCodec.ReadHello(buffer[..length]));
|
||
}
|
||
|
||
[Fact]
|
||
public void Ping_RoundTripsAndIsNineBytes()
|
||
{
|
||
var message = new ClientPingMessage(1_700_000_000_123);
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
|
||
var length = ProtocolCodec.WritePing(buffer, message);
|
||
|
||
Assert.Equal(9, length);
|
||
Assert.Equal(message, ProtocolCodec.ReadPing(buffer[..length]));
|
||
}
|
||
|
||
[Fact]
|
||
public void OpenSchool_RoundTripsAndIsFiveBytes()
|
||
{
|
||
var message = new ClientOpenSchoolMessage(0x01020304);
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
|
||
var length = ProtocolCodec.WriteOpenSchool(buffer, message);
|
||
|
||
Assert.Equal(5, length);
|
||
Assert.Equal(message, ProtocolCodec.ReadOpenSchool(buffer[..length]));
|
||
}
|
||
|
||
[Fact]
|
||
public void CloseSchool_IsASingleByte()
|
||
{
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
|
||
var length = ProtocolCodec.WriteCloseSchool(buffer);
|
||
|
||
Assert.Equal(1, length);
|
||
Assert.Equal(MessageType.ClientCloseSchool, ProtocolCodec.PeekMessageType(buffer[..length]));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData(true)]
|
||
[InlineData(false)]
|
||
public void SetRunning_RoundTripsAndIsTwoBytes(bool running)
|
||
{
|
||
var message = new ClientSetRunningMessage(running);
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
|
||
var length = ProtocolCodec.WriteSetRunning(buffer, message);
|
||
|
||
Assert.Equal(2, length);
|
||
Assert.Equal(message, ProtocolCodec.ReadSetRunning(buffer[..length]));
|
||
}
|
||
|
||
[Theory]
|
||
[InlineData(0)]
|
||
[InlineData(4)]
|
||
public void SetSpeed_RoundTripsAndIsTwoBytes(byte speedIndex)
|
||
{
|
||
var message = new ClientSetSpeedMessage(speedIndex);
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
|
||
var length = ProtocolCodec.WriteSetSpeed(buffer, message);
|
||
|
||
Assert.Equal(2, length);
|
||
Assert.Equal(message, ProtocolCodec.ReadSetSpeed(buffer[..length]));
|
||
}
|
||
|
||
[Fact]
|
||
public void SkipEmpty_IsASingleByte()
|
||
{
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
|
||
var length = ProtocolCodec.WriteSkipEmpty(buffer);
|
||
|
||
Assert.Equal(1, length);
|
||
Assert.Equal(MessageType.ClientSkipEmpty, ProtocolCodec.PeekMessageType(buffer[..length]));
|
||
}
|
||
|
||
[Fact]
|
||
public void DismissNotice_RoundTripsAndIsFiveBytes()
|
||
{
|
||
var message = new ClientDismissNoticeMessage(0x01020304);
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
|
||
var length = ProtocolCodec.WriteDismissNotice(buffer, message);
|
||
|
||
Assert.Equal(5, length);
|
||
Assert.Equal((byte)MessageType.ClientDismissNotice, buffer[0]);
|
||
Assert.Equal(new byte[] { 0x04, 0x03, 0x02, 0x01 }, buffer[1..5].ToArray());
|
||
Assert.Equal(message, ProtocolCodec.ReadDismissNotice(buffer[..length]));
|
||
}
|
||
|
||
[Fact]
|
||
public void Notice_RoundTripsAndMatchesByteLayout()
|
||
{
|
||
var message = new ServerNoticeMessage(0x0A0B0C0D, "DayStarted", NoticeSeverity.Info, Pause: false, TtlMs: 8000, PersonId: 0, Action: NoticeAction.None);
|
||
var size = ProtocolCodec.NoticeSize(message);
|
||
Span<byte> buffer = stackalloc byte[size];
|
||
|
||
var length = ProtocolCodec.WriteNotice(buffer, message);
|
||
|
||
Assert.Equal(size, length);
|
||
Assert.Equal((byte)MessageType.ServerNotice, buffer[0]);
|
||
Assert.Equal(new byte[] { 0x0D, 0x0C, 0x0B, 0x0A }, buffer[1..5].ToArray());
|
||
Assert.Equal((ushort)10, System.Buffers.Binary.BinaryPrimitives.ReadUInt16LittleEndian(buffer[5..7]));
|
||
Assert.Equal("DayStarted"u8.ToArray(), buffer[7..17].ToArray());
|
||
Assert.Equal(NoticeSeverity.Info, buffer[17]);
|
||
Assert.Equal(0, buffer[18]);
|
||
Assert.Equal(8000u, System.Buffers.Binary.BinaryPrimitives.ReadUInt32LittleEndian(buffer[19..23]));
|
||
Assert.Equal(0u, System.Buffers.Binary.BinaryPrimitives.ReadUInt32LittleEndian(buffer[23..27]));
|
||
Assert.Equal((ushort)4, System.Buffers.Binary.BinaryPrimitives.ReadUInt16LittleEndian(buffer[27..29]));
|
||
Assert.Equal("none"u8.ToArray(), buffer[29..33].ToArray());
|
||
Assert.Equal(message, ProtocolCodec.ReadNotice(buffer[..length]));
|
||
}
|
||
|
||
[Fact]
|
||
public void Welcome_RoundTripsAndIsFourBytes()
|
||
{
|
||
var message = new ServerWelcomeMessage(ProtocolConstants.Version, 20, 6);
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
|
||
var length = ProtocolCodec.WriteWelcome(buffer, message);
|
||
|
||
Assert.Equal(4, length);
|
||
Assert.Equal(message, ProtocolCodec.ReadWelcome(buffer[..length]));
|
||
}
|
||
|
||
[Fact]
|
||
public void Pong_RoundTripsAndIsThirteenBytes()
|
||
{
|
||
var message = new ServerPongMessage(5, 99);
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
|
||
var length = ProtocolCodec.WritePong(buffer, message);
|
||
|
||
Assert.Equal(13, length);
|
||
Assert.Equal(message, ProtocolCodec.ReadPong(buffer[..length]));
|
||
}
|
||
|
||
[Fact]
|
||
public void Clock_RoundTripsAndIsTwentySevenBytes()
|
||
{
|
||
var message = new ServerClockMessage(
|
||
7,
|
||
1_333_432_800_000,
|
||
Running: true,
|
||
SpeedIndex: 2,
|
||
SkipAllowed: true,
|
||
SkipTargetUnixMs: 1_333_516_800_000,
|
||
TemperatureTenths: -50,
|
||
Precipitation: 2);
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
|
||
var length = ProtocolCodec.WriteClock(buffer, message);
|
||
|
||
Assert.Equal(27, length);
|
||
Assert.Equal((byte)MessageType.ServerClock, buffer[0]);
|
||
Assert.Equal(7, BitConverter.ToInt32(buffer[1..5]));
|
||
Assert.Equal(1_333_432_800_000, BitConverter.ToInt64(buffer[5..13]));
|
||
Assert.Equal(1, buffer[13]);
|
||
Assert.Equal(2, buffer[14]);
|
||
Assert.Equal(1, buffer[15]);
|
||
Assert.Equal(1_333_516_800_000, BitConverter.ToInt64(buffer[16..24]));
|
||
Assert.Equal(-50, BitConverter.ToInt16(buffer[24..26]));
|
||
Assert.Equal(2, buffer[26]);
|
||
Assert.Equal(message, ProtocolCodec.ReadClock(buffer[..length]));
|
||
}
|
||
|
||
[Fact]
|
||
public void Clock_WithoutSkip_WritesZeroTarget()
|
||
{
|
||
var message = new ServerClockMessage(1, 0, Running: false, SpeedIndex: 1);
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
|
||
var length = ProtocolCodec.WriteClock(buffer, message);
|
||
var read = ProtocolCodec.ReadClock(buffer[..length]);
|
||
|
||
Assert.Equal(27, length);
|
||
Assert.False(read.SkipAllowed);
|
||
Assert.Equal(0, read.SkipTargetUnixMs);
|
||
Assert.Equal(0, read.TemperatureTenths);
|
||
Assert.Equal(PrecipitationKind.None, read.Precipitation);
|
||
}
|
||
|
||
[Fact]
|
||
public void SchoolGone_RoundTripsAndIsFiveBytes()
|
||
{
|
||
var message = new ServerSchoolGoneMessage(3);
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
|
||
var length = ProtocolCodec.WriteSchoolGone(buffer, message);
|
||
|
||
Assert.Equal(5, length);
|
||
Assert.Equal(message, ProtocolCodec.ReadSchoolGone(buffer[..length]));
|
||
}
|
||
|
||
[Fact]
|
||
public void MapSnapshot_RoundTripsAndWritesHeaderOffsets()
|
||
{
|
||
var message = new ServerMapSnapshotMessage(7, [
|
||
new MapSnapshotNode(0, "yard", "", "Двор", 0, [], []),
|
||
new MapSnapshotNode(
|
||
3,
|
||
"office",
|
||
"floor-1",
|
||
"Кабинет директора",
|
||
0,
|
||
[new MapSnapshotItem("Стул", 2)],
|
||
["Директор"]),
|
||
]);
|
||
var buffer = new byte[ProtocolConstants.MaxMessageSize];
|
||
|
||
var length = ProtocolCodec.WriteMapSnapshot(buffer, message);
|
||
|
||
Assert.Equal((byte)MessageType.ServerMapSnapshot, buffer[0]);
|
||
Assert.Equal(7, BitConverter.ToInt32(buffer.AsSpan(1, 4)));
|
||
Assert.Equal((ushort)2, BitConverter.ToUInt16(buffer.AsSpan(5, 2)));
|
||
|
||
var read = ProtocolCodec.ReadMapSnapshot(buffer.AsSpan(0, length));
|
||
Assert.Equal(message.SchoolId, read.SchoolId);
|
||
Assert.Equal(2, read.Nodes.Count);
|
||
Assert.Equal("yard", read.Nodes[0].Id);
|
||
Assert.Equal("", read.Nodes[0].ParentId);
|
||
Assert.Equal("Двор", read.Nodes[0].Name);
|
||
Assert.Equal(0, read.Nodes[0].PupilSlots);
|
||
Assert.Equal([new MapSnapshotItem("Стул", 2)], read.Nodes[1].Items);
|
||
Assert.Equal(["Директор"], read.Nodes[1].Positions);
|
||
}
|
||
|
||
[Fact]
|
||
public void Presence_RoundTripsAndWritesHeaderOffsets()
|
||
{
|
||
var message = new ServerPresenceMessage(
|
||
7,
|
||
[
|
||
new PresenceNode("classroom-101", 18, "Математика", "5А"),
|
||
new PresenceNode("corridor-1", 4),
|
||
],
|
||
[
|
||
new PresencePerson("f0.c0", "classroom-101", PresenceState.Here),
|
||
new PresencePerson("f3.p1", "corridor-1", PresenceState.Walking),
|
||
]);
|
||
var buffer = new byte[ProtocolCodec.PresenceSize(message)];
|
||
|
||
var length = ProtocolCodec.WritePresence(buffer, message);
|
||
|
||
Assert.Equal((byte)MessageType.ServerPresence, buffer[0]);
|
||
Assert.Equal(7, BitConverter.ToInt32(buffer.AsSpan(1, 4)));
|
||
Assert.Equal((ushort)2, BitConverter.ToUInt16(buffer.AsSpan(5, 2)));
|
||
Assert.Equal(length, ProtocolCodec.PresenceSize(message));
|
||
|
||
var read = ProtocolCodec.ReadPresence(buffer.AsSpan(0, length));
|
||
Assert.Equal(message.SchoolId, read.SchoolId);
|
||
Assert.Equal(2, read.Nodes.Count);
|
||
Assert.Equal("classroom-101", read.Nodes[0].Id);
|
||
Assert.Equal(18, read.Nodes[0].Count);
|
||
Assert.Equal("Математика", read.Nodes[0].ActivitySubject);
|
||
Assert.Equal("5А", read.Nodes[0].ActivityClass);
|
||
Assert.Equal("corridor-1", read.Nodes[1].Id);
|
||
Assert.Equal(4, read.Nodes[1].Count);
|
||
Assert.Equal("", read.Nodes[1].ActivitySubject);
|
||
Assert.Equal(2, read.People.Count);
|
||
Assert.Equal("f0.c0", read.People[0].Id);
|
||
Assert.Equal("classroom-101", read.People[0].NodeId);
|
||
Assert.Equal(PresenceState.Here, read.People[0].State);
|
||
Assert.Empty(read.People[0].TalkMemberIds);
|
||
Assert.Equal("", read.People[0].TalkTopicId);
|
||
Assert.Equal(PresenceSummonPhase.None, read.People[0].SummonPhase);
|
||
Assert.Equal(PresenceState.Walking, read.People[1].State);
|
||
Assert.Empty(read.People[1].TalkMemberIds);
|
||
Assert.Equal(PresenceSummonPhase.None, read.People[1].SummonPhase);
|
||
}
|
||
|
||
[Fact]
|
||
public void Presence_PersonWithoutCircle_WritesEmptyMemberListAndEmptyTopic()
|
||
{
|
||
var message = new ServerPresenceMessage(
|
||
1,
|
||
[],
|
||
[new PresencePerson("f0.c0", "corridor-1", PresenceState.Here)]);
|
||
var buffer = new byte[ProtocolCodec.PresenceSize(message)];
|
||
|
||
var length = ProtocolCodec.WritePresence(buffer, message);
|
||
|
||
Assert.Equal((byte)MessageType.ServerPresence, buffer[0]);
|
||
Assert.Equal(1, BitConverter.ToInt32(buffer.AsSpan(1, 4)));
|
||
Assert.Equal((ushort)0, BitConverter.ToUInt16(buffer.AsSpan(5, 2)));
|
||
Assert.Equal((ushort)1, BitConverter.ToUInt16(buffer.AsSpan(7, 2)));
|
||
|
||
var offset = 9;
|
||
offset = AssertWireString(buffer, offset, "f0.c0");
|
||
offset = AssertWireString(buffer, offset, "corridor-1");
|
||
Assert.Equal(PresenceState.Here, buffer[offset]);
|
||
offset += 1;
|
||
Assert.Equal(0, buffer[offset]);
|
||
offset += 1;
|
||
offset = AssertWireString(buffer, offset, "");
|
||
Assert.Equal(PresenceSummonPhase.None, buffer[offset]);
|
||
offset += 1;
|
||
Assert.Equal(length, offset);
|
||
Assert.Equal(length, ProtocolCodec.PresenceSize(message));
|
||
|
||
var read = ProtocolCodec.ReadPresence(buffer.AsSpan(0, length));
|
||
Assert.Empty(read.People[0].TalkMemberIds);
|
||
Assert.Equal("", read.People[0].TalkTopicId);
|
||
Assert.Equal(PresenceSummonPhase.None, read.People[0].SummonPhase);
|
||
Assert.Equal(message.People[0].Id, read.People[0].Id);
|
||
Assert.Equal(message.People[0].NodeId, read.People[0].NodeId);
|
||
Assert.Equal(message.People[0].State, read.People[0].State);
|
||
}
|
||
|
||
[Fact]
|
||
public void Presence_PersonWithCircle_RoundTripsMemberIdsAndTopic()
|
||
{
|
||
var members = new[] { "f0.c0", "f0.c1" };
|
||
var message = new ServerPresenceMessage(
|
||
1,
|
||
[new PresenceNode("corridor-1", 2)],
|
||
[new PresencePerson("f0.c0", "corridor-1", PresenceState.Here, members, "TopicSport")]);
|
||
var buffer = new byte[ProtocolCodec.PresenceSize(message)];
|
||
|
||
var length = ProtocolCodec.WritePresence(buffer, message);
|
||
|
||
Assert.Equal((byte)MessageType.ServerPresence, buffer[0]);
|
||
Assert.Equal(1, BitConverter.ToInt32(buffer.AsSpan(1, 4)));
|
||
Assert.Equal((ushort)1, BitConverter.ToUInt16(buffer.AsSpan(5, 2)));
|
||
|
||
var offset = 7;
|
||
offset = AssertWireString(buffer, offset, "corridor-1");
|
||
Assert.Equal((ushort)2, BitConverter.ToUInt16(buffer.AsSpan(offset, 2)));
|
||
offset += 2;
|
||
Assert.Equal(0, buffer[offset]);
|
||
offset += 1;
|
||
Assert.Equal((ushort)1, BitConverter.ToUInt16(buffer.AsSpan(offset, 2)));
|
||
offset += 2;
|
||
offset = AssertWireString(buffer, offset, "f0.c0");
|
||
offset = AssertWireString(buffer, offset, "corridor-1");
|
||
Assert.Equal(PresenceState.Here, buffer[offset]);
|
||
offset += 1;
|
||
Assert.Equal(2, buffer[offset]);
|
||
offset += 1;
|
||
offset = AssertWireString(buffer, offset, "f0.c0");
|
||
offset = AssertWireString(buffer, offset, "f0.c1");
|
||
offset = AssertWireString(buffer, offset, "TopicSport");
|
||
Assert.Equal(PresenceSummonPhase.None, buffer[offset]);
|
||
offset += 1;
|
||
Assert.Equal(length, offset);
|
||
Assert.Equal(length, ProtocolCodec.PresenceSize(message));
|
||
|
||
var read = ProtocolCodec.ReadPresence(buffer.AsSpan(0, length));
|
||
Assert.Equal(["f0.c0", "f0.c1"], read.People[0].TalkMemberIds);
|
||
Assert.Equal("TopicSport", read.People[0].TalkTopicId);
|
||
Assert.Equal(PresenceSummonPhase.None, read.People[0].SummonPhase);
|
||
Assert.Equal(message.SchoolId, read.SchoolId);
|
||
Assert.Equal(message.People[0].Id, read.People[0].Id);
|
||
}
|
||
|
||
[Fact]
|
||
public void Presence_SummonPhase_RoundTripsAndMatchesByteLayout()
|
||
{
|
||
var message = new ServerPresenceMessage(
|
||
1,
|
||
[],
|
||
[new PresencePerson(
|
||
"f0.c0",
|
||
"corridor-1",
|
||
PresenceState.Here,
|
||
[],
|
||
"",
|
||
PresenceSummonPhase.Waiting)]);
|
||
var buffer = new byte[ProtocolCodec.PresenceSize(message)];
|
||
|
||
var length = ProtocolCodec.WritePresence(buffer, message);
|
||
|
||
var offset = 9;
|
||
offset = AssertWireString(buffer, offset, "f0.c0");
|
||
offset = AssertWireString(buffer, offset, "corridor-1");
|
||
Assert.Equal(PresenceState.Here, buffer[offset]);
|
||
offset += 1;
|
||
Assert.Equal(0, buffer[offset]);
|
||
offset += 1;
|
||
offset = AssertWireString(buffer, offset, "");
|
||
Assert.Equal(PresenceSummonPhase.Waiting, buffer[offset]);
|
||
offset += 1;
|
||
Assert.Equal(length, offset);
|
||
|
||
var read = ProtocolCodec.ReadPresence(buffer.AsSpan(0, length));
|
||
Assert.Equal(PresenceSummonPhase.Waiting, Assert.Single(read.People).SummonPhase);
|
||
}
|
||
|
||
[Fact]
|
||
public void Presence_DoesNotContainPersonDisplayName()
|
||
{
|
||
var message = new ServerPresenceMessage(
|
||
1,
|
||
[],
|
||
[new PresencePerson(
|
||
"f0.c0",
|
||
"corridor-1",
|
||
PresenceState.Here,
|
||
["f0.c0", "f0.c1"],
|
||
"TopicSport")]);
|
||
var buffer = new byte[ProtocolCodec.PresenceSize(message)];
|
||
|
||
ProtocolCodec.WritePresence(buffer, message);
|
||
var text = System.Text.Encoding.UTF8.GetString(buffer);
|
||
|
||
Assert.DoesNotContain("Мария", text);
|
||
Assert.DoesNotContain("Иванова", text);
|
||
Assert.DoesNotContain("Маша", text);
|
||
Assert.Contains("f0.c0", text);
|
||
Assert.Contains("TopicSport", text);
|
||
}
|
||
|
||
private static int AssertWireString(byte[] buffer, int offset, string expected)
|
||
{
|
||
var bytes = System.Text.Encoding.UTF8.GetBytes(expected);
|
||
Assert.Equal((ushort)bytes.Length, BitConverter.ToUInt16(buffer.AsSpan(offset, 2)));
|
||
Assert.Equal(bytes, buffer.AsSpan(offset + 2, bytes.Length).ToArray());
|
||
return offset + 2 + bytes.Length;
|
||
}
|
||
|
||
[Fact]
|
||
public void MapSnapshot_WritesPupilSlotsAndStackedItemCount()
|
||
{
|
||
var message = new ServerMapSnapshotMessage(1, [
|
||
new MapSnapshotNode(
|
||
3,
|
||
"classroom-1a",
|
||
"floor-1",
|
||
"Класс 1A",
|
||
16,
|
||
[new MapSnapshotItem("Парта", 16)],
|
||
[]),
|
||
]);
|
||
var buffer = new byte[ProtocolCodec.MapSnapshotSize(message)];
|
||
|
||
var length = ProtocolCodec.WriteMapSnapshot(buffer, message);
|
||
var read = ProtocolCodec.ReadMapSnapshot(buffer.AsSpan(0, length));
|
||
|
||
Assert.Equal(16, read.Nodes[0].PupilSlots);
|
||
Assert.Equal([new MapSnapshotItem("Парта", 16)], read.Nodes[0].Items);
|
||
}
|
||
|
||
[Fact]
|
||
public void MapSnapshotSize_IsExactlyWhatTheWriterProduces()
|
||
{
|
||
var message = new ServerMapSnapshotMessage(7, [
|
||
new MapSnapshotNode(0, "yard", "", "Двор", 0, [], []),
|
||
new MapSnapshotNode(2, "floor-1", "main", "Этаж 1", 0, [], []),
|
||
new MapSnapshotNode(
|
||
3,
|
||
"office",
|
||
"floor-1",
|
||
"Кабинет директора",
|
||
0,
|
||
[new MapSnapshotItem("Стол", 1), new MapSnapshotItem("Стул", 2)],
|
||
["Директор"]),
|
||
]);
|
||
|
||
var size = ProtocolCodec.MapSnapshotSize(message);
|
||
var buffer = new byte[size];
|
||
|
||
Assert.Equal(size, ProtocolCodec.WriteMapSnapshot(buffer, message));
|
||
}
|
||
|
||
[Fact]
|
||
public void MapSnapshot_OfALargeSchoolSurvivesTheEightKilobyteLimit()
|
||
{
|
||
// A player who keeps clicking "Add room" in the create editor gets past 8 KiB somewhere
|
||
// around sixty furnished rooms. Sizing the buffer from the message is what keeps that
|
||
// school openable instead of killing its worker thread on the first snapshot.
|
||
var nodes = new List<MapSnapshotNode> { new(0, "yard", "", "Двор", 0, [], []) };
|
||
for (var i = 1; i <= 200; i++)
|
||
{
|
||
nodes.Add(new MapSnapshotNode(
|
||
3,
|
||
$"principals-office-{i}",
|
||
"floor-1",
|
||
"Кабинет директора",
|
||
0,
|
||
[new MapSnapshotItem("Кресло директора", 1), new MapSnapshotItem("Стол", 1), new MapSnapshotItem("Стул", 2)],
|
||
["Директор"]));
|
||
}
|
||
|
||
var message = new ServerMapSnapshotMessage(1, nodes);
|
||
var buffer = new byte[ProtocolCodec.MapSnapshotSize(message)];
|
||
|
||
Assert.True(buffer.Length > ProtocolConstants.MaxMessageSize);
|
||
|
||
var length = ProtocolCodec.WriteMapSnapshot(buffer, message);
|
||
var read = ProtocolCodec.ReadMapSnapshot(buffer.AsSpan(0, length));
|
||
|
||
Assert.Equal(nodes.Count, read.Nodes.Count);
|
||
Assert.Equal("principals-office-200", read.Nodes[^1].Id);
|
||
Assert.Equal(
|
||
[new MapSnapshotItem("Кресло директора", 1), new MapSnapshotItem("Стол", 1), new MapSnapshotItem("Стул", 2)],
|
||
read.Nodes[^1].Items);
|
||
}
|
||
|
||
[Fact]
|
||
public void Numbers_AreLittleEndian()
|
||
{
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
ProtocolCodec.WriteOpenSchool(buffer, new ClientOpenSchoolMessage(0x01020304));
|
||
|
||
Assert.Equal((byte)MessageType.ClientOpenSchool, buffer[0]);
|
||
Assert.Equal(new byte[] { 0x04, 0x03, 0x02, 0x01 }, buffer[1..5].ToArray());
|
||
}
|
||
|
||
[Fact]
|
||
public void MaxFrameSize_FitsEveryFixedSizeMessage()
|
||
{
|
||
// Handlers size clock/welcome/pong buffers from this constant; map snapshots use MaxMessageSize.
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
var clock = ProtocolCodec.WriteClock(
|
||
buffer,
|
||
new ServerClockMessage(1, long.MaxValue, true, 4, SkipAllowed: true, SkipTargetUnixMs: long.MaxValue));
|
||
|
||
Assert.True(clock <= ProtocolCodec.MaxFrameSize);
|
||
}
|
||
|
||
[Fact]
|
||
public void PeekMessageType_ReadsTheFirstByte()
|
||
{
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
ProtocolCodec.WritePing(buffer, new ClientPingMessage(1));
|
||
|
||
Assert.Equal(MessageType.ClientPing, ProtocolCodec.PeekMessageType(buffer));
|
||
Assert.Equal(MessageType.None, ProtocolCodec.PeekMessageType([]));
|
||
}
|
||
|
||
[Fact]
|
||
public void TruncatedFrame_Throws()
|
||
{
|
||
byte[] frame = [(byte)MessageType.ServerClock, 1, 2];
|
||
|
||
Assert.Throws<ProtocolException>(() => ProtocolCodec.ReadClock(frame));
|
||
}
|
||
|
||
[Fact]
|
||
public void WrongMessageId_Throws()
|
||
{
|
||
Span<byte> buffer = stackalloc byte[ProtocolCodec.MaxFrameSize];
|
||
var length = ProtocolCodec.WritePing(buffer, new ClientPingMessage(1));
|
||
var frame = buffer[..length].ToArray();
|
||
|
||
Assert.Throws<ProtocolException>(() => ProtocolCodec.ReadOpenSchool(frame));
|
||
}
|
||
|
||
[Fact]
|
||
public void UndersizedBuffer_Throws()
|
||
{
|
||
var buffer = new byte[2];
|
||
|
||
Assert.Throws<ProtocolException>(() =>
|
||
ProtocolCodec.WriteClock(buffer, new ServerClockMessage(1, 0, false, 1)));
|
||
}
|
||
}
|