Started simplification of tests to work across processes/terminals.

src/DtronixMessageQueue.Tests.Performance/DtronixMessageQueue.Tests.Performance.csproj

@@ -57,11 +57,13 @@
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="RpcPerformanceTest.cs" />
+    <Compile Include="ServerMqPerformanceTests.cs" />
     <Compile Include="Services\Server\CalculatorService.cs" />
     <Compile Include="Services\Server\ICalculatorService.cs" />
     <Compile Include="Services\Server\TestService.cs" />
     <Compile Include="SimpleMqSession.cs" />
     <Compile Include="SimpleRpcSession.cs" />
+    <Compile Include="TestStartArgs.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />

src/DtronixMessageQueue.Tests.Performance/MqPerformanceTest.cs

@@ -286,7 +286,7 @@ private static void MqInProcessPerformanceTests(int runs, int loops, MqMessage m
                     var mode = "Release";
 
 #if DEBUG
-					mode = "Debug";
+                    mode = "Debug";
 #endif
 
                     var messagesPerSecond = (int) ((double) runs / sw.ElapsedMilliseconds * 1000);

src/DtronixMessageQueue.Tests.Performance/ServerMqPerformanceTests.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DtronixMessageQueue.Tests.Performance
+{
+    public class ServerMqPerformanceTests
+    {
+        private MqServer<SimpleMqSession, MqConfig> _server;
+
+        public ServerMqPerformanceTests(string[] args)
+        {
+            _server = new MqServer<SimpleMqSession, MqConfig>(new MqConfig
+            {
+                Ip = "127.0.0.1",
+                Port = 2828
+            });
+
+            _server.SessionSetup += (sender, eventArgs) =>
+            {
+                eventArgs.Session.IsServer = true;
+            };
+
+
+        }
+
+        public void Start()
+        {
+            _server.Start();
+        }
+    }
+}

src/DtronixMessageQueue.Tests.Performance/SimpleMqSession.cs

@@ -1,6 +1,131 @@
-namespace DtronixMessageQueue.Tests.Performance
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using DtronixMessageQueue.Socket;
+
+namespace DtronixMessageQueue.Tests.Performance
 {
     public class SimpleMqSession : MqSession<SimpleMqSession, MqConfig>
     {
+        private MqMessageReader reader;
+        private MqMessageWriter writer;
+
+        public bool IsServer { get; set; }
+
+        public TestMode Mode { get; set; }
+
+        private Stopwatch stopwatch = new Stopwatch();
+
+        private Timer _responseTimer;
+        private int _totalThroughBytes;
+        private int _totalThroughFrames;
+        private int _totalThroughMessages;
+
+        protected override void OnSetup()
+        {
+            base.OnSetup();
+
+            reader = new MqMessageReader();
+            writer = new MqMessageWriter(Config);
+        }
+
+        protected override void OnIncomingMessage(object sender, IncomingMessageEventArgs<SimpleMqSession, MqConfig> e)
+        {
+            if (IsServer)
+            {
+                ServerMessage(e.Messages);
+            }
+            else
+            {
+                ClientMessage(e.Messages);
+            }
+        }
+
+        private void ClientMessage(Queue<MqMessage> message_queue)
+        {
+
+        }
+
+        public override void Close(SocketCloseReason reason)
+        {
+            if (_responseTimer != null)
+            {
+                _responseTimer.Change(-1, -1);
+                _responseTimer.Dispose();
+            }
+            base.Close(reason);
+
+        }
+
+        private void ServerMessage(Queue<MqMessage> message_queue)
+        {
+
+            if (Mode == TestMode.Unset)
+            {
+                reader.Message = message_queue.Dequeue();
+
+                Mode = (TestMode)reader.ReadByte(); // Mode
+
+                if (Mode == TestMode.Throughput)
+                {
+                    _responseTimer = new Timer(ThroughputResponse);
+                    writer.Write((byte)ServerMessageType.Ready);
+                    Send(writer.ToMessage(true));
+
+                    _responseTimer.Change(1000, 1000);
+                }
+
+            }
+
+            while (message_queue.Count > 0)
+            {
+                var message = message_queue.Dequeue();
+                if (Mode == TestMode.Throughput)
+                {
+                    Interlocked.Add(ref _totalThroughBytes, message.Size);
+                    _totalThroughMessages++;
+                    Interlocked.Add(ref _totalThroughFrames, message.Count);
+                }
+
+            }
+
+        }
+
+        private void ThroughputResponse(object state)
+        {
+            using (var writer = new MqMessageWriter(Config))
+            {
+                var throughBytes = _totalThroughBytes;
+                var throughMessages = _totalThroughMessages;
+                var throughFrames = _totalThroughFrames;
+
+                _totalThroughBytes = 0;
+                _totalThroughMessages = 0;
+                _totalThroughFrames = 0;
+
+                writer.Write((byte)ServerMessageType.ThroughputTransfer);
+                writer.Write(throughBytes);
+                writer.Write(throughMessages);
+                writer.Write(throughFrames);
+                writer.Write(stopwatch.ElapsedMilliseconds);
+            }
+        }
+
+
+    }
+
+    public enum TestMode
+    {
+        Unset = 0,
+        Throughput = 1,
+        Repeat = 2
+    }
+
+    public enum ServerMessageType : byte
+    {
+        Unset = 0,
+        Ready = 1,
+        Complete = 2,
+        ThroughputTransfer = 3
     }
 }

src/DtronixMessageQueue.Tests.Performance/TestStartArgs.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DtronixMessageQueue.Tests.Performance
+{
+    public class TestStartArgs
+    {
+        public StartMode Mode { get; set; }
+
+
+
+        public enum StartMode 
+        {
+            ServerRepeat,
+            ServerRespond,
+            Client
+        }
+    }
+}