Added property to return total message data size excluding headers.

GUI Tests will now report the total data transferred and speed of the upload and download streams.

src/DtronixMessageQueue.Tests.Gui/MainWindow.xaml

@@ -55,13 +55,22 @@
             <Button Padding="4" Margin="5,0" VerticalAlignment="Center" Click="NewClient" IsEnabled="{Binding IsServer}">New Client</Button>
         </StackPanel>
         <StatusBar Grid.Row="4">
-            <TextBlock Text="{Binding Path=CurrentStatus, FallbackValue=Idle}" Width="100" />
+            <TextBlock Text="{Binding Path=CurrentStatus, FallbackValue=Idle}" Width="80" />
             <TextBlock Text="{Binding Path=CurrentMode, FallbackValue=Setup}" Width="50" />
 
             <TextBlock Width="120">
                 <TextBlock Text="Memory: " />
                 <TextBlock Text="{Binding Path=MemoryUsage, FallbackValue=0.0 MB}" />
             </TextBlock>
+
+            <TextBlock>
+                <TextBlock Text="Transfer:" />
+                <TextBlock Text="{Binding Path=TotalTransferred, FallbackValue=N/A}" />
+                <TextBlock Text="; U:" />
+                <TextBlock Text="{Binding Path=TransferUp, FallbackValue=N/A}" />
+                <TextBlock Text="; D:" />
+                <TextBlock Text="{Binding Path=TransferDown, FallbackValue=N/A}" />
+            </TextBlock>
         </StatusBar>
     </Grid>
 </Window>

src/DtronixMessageQueue.Tests.Gui/MainWindow.xaml.cs

@@ -86,6 +86,34 @@ public string ClientConnections {
             set { SetValue(ClientConnectionsProperty, value); }
         }
 
+        public static readonly DependencyProperty TotalTransferredProperty = DependencyProperty.Register(
+            "TotalTransferred", typeof(string), typeof(MainWindow), new PropertyMetadata(default(string)));
+
+        public string TotalTransferred
+        {
+            get { return (string) GetValue(TotalTransferredProperty); }
+            set { SetValue(TotalTransferredProperty, value); }
+        }
+
+
+        public static readonly DependencyProperty TransferDownProperty = DependencyProperty.Register(
+            "TransferDown", typeof(string), typeof(MainWindow), new PropertyMetadata(default(string)));
+
+        public string TransferDown
+        {
+            get { return (string) GetValue(TransferDownProperty); }
+            set { SetValue(TransferDownProperty, value); }
+        }
+
+        public static readonly DependencyProperty TransferUpProperty = DependencyProperty.Register(
+            "TransferUp", typeof(string), typeof(MainWindow), new PropertyMetadata(default(string)));
+
+        public string TransferUp
+        {
+            get { return (string) GetValue(TransferUpProperty); }
+            set { SetValue(TransferUpProperty, value); }
+        }
+
         public static readonly DependencyProperty IpAddressProperty = DependencyProperty.Register(
             "IpAddress", typeof(string), typeof(MainWindow), new PropertyMetadata(default(string)));
 
@@ -99,6 +127,9 @@ public string IpAddress
 
         private Process _currentProcess;
         private Timer _processMemoryTimer;
+        private Stopwatch _totalTransferStopwatch;
+        private long _lastTotalSent = 0;
+        private long _lastTotalReceived = 0;
 
         public MainWindow(string[] args)
         {
@@ -126,10 +157,10 @@ public MainWindow(string[] args)
             }
 
             _processMemoryTimer = new Timer(MemoryTimer);
-
             _processMemoryTimer.Change(100, 1000);
+            _totalTransferStopwatch = Stopwatch.StartNew();
 
-            ClientConnections = "50";
+            ClientConnections = "100";
 
             IpAddress = Dns.GetHostEntry(Dns.GetHostName())
                 .AddressList.First(
@@ -140,26 +171,48 @@ public MainWindow(string[] args)
 
         }
 
+
         private void MemoryTimer(object state)
         {
+            Dispatcher.Invoke(() =>
+            {
+                using (Process currentProcess = Process.GetCurrentProcess())
+                    MemoryUsage = FormatSize(currentProcess.WorkingSet64);
+
+                TotalTransferred =
+                    FormatSize(ConnectionPerformanceTestSession.TotalReceieved + ConnectionPerformanceTestSession.TotalSent);
+
+                TransferDown =
+                    FormatSize((double) (ConnectionPerformanceTestSession.TotalReceieved - _lastTotalReceived) /
+                               _totalTransferStopwatch.ElapsedMilliseconds) + "ps";
+
+                TransferUp =
+                    FormatSize((double)(ConnectionPerformanceTestSession.TotalSent - _lastTotalSent) /
+                               _totalTransferStopwatch.ElapsedMilliseconds) + "ps";
+
+                _lastTotalReceived = ConnectionPerformanceTestSession.TotalReceieved;
+                _lastTotalSent = ConnectionPerformanceTestSession.TotalSent;
 
-            using (Process currentProcess = Process.GetCurrentProcess())
+                _totalTransferStopwatch.Restart();
+            });
+
+        }
+
+        private string FormatSize(double length)
+        {
+            double size = length;
+
+            string[] sizes = { "B", "KB", "MB", "GB", "TB" };
+            int order = 0;
+            while (size >= 1024 && order < sizes.Length - 1)
             {
-                double size = currentProcess.WorkingSet64;
-
-                string[] sizes = {"B", "KB", "MB", "GB", "TB"};
-                int order = 0;
-                while (size >= 1024 && order < sizes.Length - 1)
-                {
-                    order++;
-                    size = size / 1024;
-                }
-
-                Dispatcher.Invoke(() =>
-                {
-                    MemoryUsage = $"{size:0.##} {sizes[order]}";
-                });
+                order++;
+                size = size / 1024;
             }
+
+
+            return $"{size:0.0} {sizes[order]}";
+
         }
 
         private void Stop(object sender, RoutedEventArgs e)

src/DtronixMessageQueue.Tests.Gui/Tests/ConnectionPerformanceTest.cs

@@ -62,7 +62,7 @@ public override void StartServer(int clientConnections)
                 Ip = "0.0.0.0",
                 Port = 2121,
                 PingTimeout = 1000,
-                MaxConnections = 100
+                MaxConnections = 1000
 
             });
 
@@ -92,7 +92,7 @@ public override void StartServer(int clientConnections)
             _server.Ready += (sender, args) =>
             {
                 Log("Client Connected");
-                args.Session.GetProxy<IControllerService>().StartConnectionTest(clientConnections, 128, 3000);
+                args.Session.GetProxy<IControllerService>().StartConnectionTest(clientConnections, 1024, 3000);
             };
 
             _server.SessionSetup += OnServerSessionSetup;

src/DtronixMessageQueue.Tests.Gui/Tests/ConnectionPerformanceTestSession.cs

@@ -35,14 +35,6 @@ public override void StartTest()
             }
         }
 
-        protected override void ServerMessage(Queue<MqMessage> messageQueue)
-        {
-
-        }
-
-        protected override void ClientMessage(Queue<MqMessage> messageQueue)
-        {
-        }
 
         private void RandomByteMessage(object state)
         {

src/DtronixMessageQueue.Tests.Gui/Tests/MqBaseTestSession.cs

@@ -8,6 +8,10 @@ namespace DtronixMessageQueue.Tests.Gui.Tests
     public abstract class MqBaseTestSession<T> : MqSession<T, MqConfig> 
         where T : MqSession<T, MqConfig>, new()
     {
+
+        public static long TotalReceieved;
+        public static long TotalSent;
+
         protected MqMessageReader Reader;
         protected MqMessageWriter Writer;
         protected readonly Stopwatch Stopwatch = new Stopwatch();
@@ -49,10 +53,32 @@ protected byte[] RandomBytes(int len)
             return val;
         }
 
+        protected override void Send(byte[] buffer, int offset, int length)
+        {
+            base.Send(buffer, offset, length);
+            Interlocked.Add(ref TotalSent, length);
+        }
 
 
         public abstract void StartTest();
-        protected abstract void ClientMessage(Queue<MqMessage> messageQueue);
-        protected abstract void ServerMessage(Queue<MqMessage> messageQueue);
+
+
+        protected virtual void ServerMessage(Queue<MqMessage> messageQueue)
+        {
+            for (int i = 0; i < messageQueue.Count; i++)
+            {
+                var message = messageQueue.Dequeue();
+                Interlocked.Add(ref TotalReceieved, message.Size);
+            }
+        }
+
+        protected virtual void ClientMessage(Queue<MqMessage> messageQueue)
+        {
+            for (int i = 0; i < messageQueue.Count; i++)
+            {
+                var message = messageQueue.Dequeue();
+                Interlocked.Add(ref TotalReceieved, message.Size);
+            }
+        }
     }
 }

src/DtronixMessageQueue.Tests.Gui/Tests/PerformanceTest.cs

@@ -7,6 +7,7 @@ public abstract class PerformanceTest
         public string Name { get; }
         public MainWindow MainWindow { get; }
 
+        public long ServerThroughput { get; set; }
 
         protected PerformanceTest(string name, MainWindow mainWindow)
         {

src/DtronixMessageQueue/MqMessage.cs

@@ -43,6 +43,11 @@ public MqFrame this[int index]
         /// </summary>
         public int Size => _frames.Sum(frame => frame.FrameSize);
 
+        /// <summary>
+        /// The total size of the raw frames minus the headers contained in this message.
+        /// </summary>
+        public int DataLength => _frames.Sum(frame => frame.DataLength);
+
         public MqMessage()
         {
         }

src/DtronixMessageQueue/Socket/SocketSession.cs

@@ -260,7 +260,7 @@ protected virtual void IoCompleted(object sender, SocketAsyncEventArgs e)
         /// <param name="buffer">Buffer bytes to send.</param>
         /// <param name="offset">Offset in the buffer.</param>
         /// <param name="length">Total bytes to send.</param>
-        protected void Send(byte[] buffer, int offset, int length)
+        protected virtual void Send(byte[] buffer, int offset, int length)
         {
             if (Socket == null || Socket.Connected == false)
             {