Read static message from socket data on UScript UDK test side

templates/uscript_test_mutator.jinja

@@ -64,7 +64,8 @@ event Tick(float DeltaTime)
         SendMsg_{{ message.name }}();
         break;
     case ETS_WaitingFor_{{ message.name }}:
-        if (MessageReady_{{ message.name }}())
+        // TODO: This is kinda spaghetti-y. Consider refactoring.
+        if (MessageReady_{{ message.name }}() || bClientServerDone_{{ message.name }})
         {
             TotalFailures += CheckMessage_{{ message.name }}();
         }
@@ -143,13 +144,13 @@ final function int Test_{{ message.name }}()
 {
     local int Failures;
     local int X;
+    local array<byte> DynamicBytes;
     local {{ message.name }} {{ msg1 }};
     local {{ message.name }} {{ msg2 }};
 {% if message.has_static_size %}
     local byte StaticBytes[PACKET_SIZE];
     local byte StaticSize;
 {% endif %}
-    local array<byte> DynamicBytes;
 
     `ulog("running tests" @ "(" $ TimeStamp() $ ")" $ "...");
 
@@ -350,10 +351,10 @@ final function SendMsg_{{ message.name }}()
     TestState = ETS_WaitingFor_{{ message.name }};
 }
 
+{% set mt = "class'" + class_name + "'.const." + uscript_message_type_prefix + "_" + message.name %}
 final function bool MessageReady_{{ message.name }}()
 {
-    // TODO: check from Link.
-    return True;
+    return Link.MessageType == {{ mt }};
 }
 
 /*
@@ -383,27 +384,56 @@ ConsoleCommand("QUIT", True);
 
 final function int CheckMessage_{{ message.name }}()
 {
-    // TODO: read from link and compare.
-    ++TotalMessagesReceived;
+    local int Failures;
+    local {{ message.name }} Msg;
+
+    Failures = 0;
 
     if (bClientServerDone_{{ message.name }})
     {
+        Link.MessageType = class'{{ class_name }}'.const.EMT_None;
+        Link.Size = 0;
+        Link.Part = 0;
+
     {% if loop.is_last %}
         // Done with all message types, exit. TODO: move exit away from here.
         Link.Close();
         TestState = ETS_None;
         bDone = True;
     {% else %}
-        // Done with this type. Move to next type's queue.
+        // Done with this type. Move to the next type's queue.
         TestState = ETS_Sending_{{ at(messages, loop.index + 1).name }};
     {% endif %}
+
+        return Failures;
     }
     else
     {
         TestState = ETS_Sending_{{ message.name }};
     }
 
-    return 0;
+    // TODO: read from link and compare.
+
+    if (Link.MessageType != {{ mt }})
+    {
+        `ulog("##ERROR##: wrong MessageType, expected {{ mt }}, got" @ Link.MessageType);
+        ++Failures;
+    }
+
+    // TODO: do both, FromBytes and FromMultiBytes for static messages.
+    //   Only do FromMultiBytes for dynamic messages.
+{% if message.has_static_size %}
+    class'{{ class_name }}'.static.{{ message.name }}_FromBytes(Msg, Link.RecvMsgBufStatic);
+{% endif %}
+    // TODO: (also) read multi bytes.
+
+    Link.MessageType = class'{{ class_name }}'.const.EMT_None;
+    Link.Size = 0;
+    Link.Part = 0;
+
+    ++TotalMessagesReceived;
+
+    return Failures;
 }
 
 {% endfor -%}

tests/UDKTests/UMBTestsTcpLink.uc

@@ -18,6 +18,8 @@ class UMBTestsTcpLink extends TcpLink;
 
 `include(UMBTests\Classes\UMBTestsMacros.uci);
 
+const PACKET_SIZE = 255;
+
 var private int ClientPort;
 
 var string TargetHost;
@@ -26,7 +28,15 @@ var int TargetPort;
 var int Idx;
 var int NumSent;
 var int NumToSend;
-var byte OutBuf[255];
+var byte OutBuf[PACKET_SIZE];
+
+// Received message.
+var byte Size;
+var byte Part;
+var int MessageType;
+var bool bIsStatic;
+var byte RecvMsgBufStatic[PACKET_SIZE];
+var array<byte> RecvMsgBufMulti;
 
 final function ConnectToServer()
 {
@@ -41,7 +51,7 @@ final function SendBytes(
     const out array<byte> Bytes)
 {
     // The easy case.
-    if (Bytes.Length <= 255)
+    if (Bytes.Length <= PACKET_SIZE)
     {
         for (Idx = 0; Idx < Bytes.Length; ++Idx)
         {
@@ -53,6 +63,15 @@ final function SendBytes(
         `ulog("Sent" @ NumSent @ "bytes");
         return;
     }
+
+    // TODO: sending multipart messages.
+    NumToSend = Min(PACKET_SIZE, Bytes.Length);
+    for (Idx = 0; Idx < NumToSend; ++Idx)
+    {
+        OutBuf[Idx] = Bytes[Idx];
+    }
+    NumSent = SendBinary(NumToSend, OutBuf);
+    `ulog("Sent" @ NumSent @ "bytes");
 }
 
 event Resolved(IpAddr Addr)
@@ -87,12 +106,10 @@ event Closed()
     `ulog("closed");
 }
 
-event ReceivedBinary(int Count, byte B[255])
+event ReceivedBinary(int Count, byte B[PACKET_SIZE])
 {
-    local byte Size;
-    local byte Part;
-    local int MessageType;
     local int I;
+    local int J;
 
     `ulog("Count       :" @ Count);
 
@@ -104,6 +121,28 @@ event ReceivedBinary(int Count, byte B[255])
     `ulog("Part        :" @ Part);
     `ulog("MessageType :" @ MessageType);
 
+    // TODO: generate reflection helpers for UScript.
+    // E.g.: function bool IsStaticMsg(int MessageType)
+
+    bIsStatic = class'TestMessages'.static.IsStaticMessage(MessageType);
+    if (bIsStatic)
+    {
+        // The easy case.
+        if (Size <= PACKET_SIZE)
+        {
+            for (J = 0; J < Size; ++J)
+            {
+                RecvMsgBufStatic[J] = B[J];
+            }
+        }
+        else
+        {
+            `ulog("##ERROR##: message too large to be static!");
+        }
+
+        return;
+    }
+
     I = 4;
 }