Added NightAlert project for travel kit

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ClientTests/BinaryPollingTest.cs

@@ -0,0 +1,180 @@
+using Quobject.EngineIoClientDotNet.Client;
+using Quobject.EngineIoClientDotNet.Client.Transports;
+using System.Collections.Concurrent;
+using System.Collections.Immutable;
+using System.Threading;
+using Xunit;
+
+namespace Quobject.EngineIoClientDotNet_Tests.ClientTests
+{
+    public class BinaryPollingTest : Connection
+    {
+        //[Fact]
+        //public void PingTest()
+        //{
+        //    var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
+        //    log.Info("Start");
+
+        //    var binaryData = new byte[5];
+        //    for (int i = 0; i < binaryData.Length; i++)
+        //    {
+        //        binaryData[i] = (byte)i;
+        //    }
+
+        //    var events = new ConcurrentQueue<object>();
+
+        //    var options = CreateOptions();
+        //    options.Transports = ImmutableList.Create<string>(Polling.NAME);
+
+        //    var socket = new Socket(options);
+
+        //    socket.On(Socket.EVENT_OPEN, () =>
+        //    {
+        //        log.Info("EVENT_OPEN");
+
+        //        socket.Send(binaryData);
+        //        socket.Send("cash money €€€");
+        //    });
+
+        //    socket.On(Socket.EVENT_MESSAGE, (d) =>
+        //    {
+        //        var data = d as string;
+        //        log.Info(string.Format("EVENT_MESSAGE data ={0} d = {1} ", data, d));
+
+        //        if (data == "hi")
+        //        {
+        //            return;
+        //        }
+        //        events.Enqueue(d);
+        //        //socket.Close();
+        //    });
+
+        //    socket.Open();
+        //    Task.Delay(20000).Wait();
+        //    socket.Close();
+        //    log.Info("ReceiveBinaryData end");
+
+        //    var binaryData2 = new byte[5];
+        //    for (int i = 0; i < binaryData2.Length; i++)
+        //    {
+        //        binaryData2[i] = (byte)(i + 1);
+        //    }
+
+        //    object result;
+        //    events.TryDequeue(out result);
+        //    Assert.Equal("1", "1");
+        //}
+
+        private ManualResetEvent _manualResetEvent = null;
+
+        [Fact]
+        public void ReceiveBinaryData()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var events = new ConcurrentQueue<object>();
+
+            var binaryData = new byte[5];
+            for (int i = 0; i < binaryData.Length; i++)
+            {
+                binaryData[i] = (byte)i;
+            }
+
+            var options = CreateOptions();
+            options.Transports = ImmutableList.Create<string>(Polling.NAME);
+
+            var socket = new Socket(options);
+
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+                socket.Send(binaryData);
+                //socket.Send("cash money €€€");
+            });
+
+            socket.On(Socket.EVENT_MESSAGE, (d) =>
+            {
+                var data = d as string;
+                //log.Info(string.Format("EVENT_MESSAGE data ={0} d = {1} ", data, d));
+
+                if (data == "hi")
+                {
+                    return;
+                }
+                events.Enqueue(d);
+                _manualResetEvent.Set();
+            });
+
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+            //log.Info("ReceiveBinaryData end");
+
+            var binaryData2 = new byte[5];
+            for (int i = 0; i < binaryData2.Length; i++)
+            {
+                binaryData2[i] = (byte)(i + 1);
+            }
+
+            object result;
+            events.TryDequeue(out result);
+            Assert.Equal(binaryData, result);
+        }
+
+        [Fact]
+        public void ReceiveBinaryDataAndMultibyteUTF8String()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var events = new ConcurrentQueue<object>();
+
+            var binaryData = new byte[5];
+            for (int i = 0; i < binaryData.Length; i++)
+            {
+                binaryData[i] = (byte)i;
+            }
+            const string stringData = "cash money €€€";
+
+            var options = CreateOptions();
+            options.Transports = ImmutableList.Create<string>(Polling.NAME);
+
+            var socket = new Socket(options);
+
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+                socket.On(Socket.EVENT_MESSAGE, (d) =>
+                {
+                    var data = d as string;
+                    //log.Info(string.Format("EVENT_MESSAGE data ={0} d = {1} ", data, d));
+
+                    if (data == "hi")
+                    {
+                        return;
+                    }
+                    events.Enqueue(d);
+                    if (events.Count > 1)
+                    {
+                        _manualResetEvent.Set();
+                    }
+                });
+                socket.Send(binaryData);
+                socket.Send(stringData);
+            });
+
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+            var binaryData2 = new byte[5];
+            for (int i = 0; i < binaryData2.Length; i++)
+            {
+                binaryData2[i] = (byte)(i + 1);
+            }
+
+            object result;
+            events.TryDequeue(out result);
+            Assert.Equal(binaryData, result);
+            events.TryDequeue(out result);
+            Assert.Equal(stringData, (string)result);
+            socket.Close();
+        }
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ClientTests/BinaryWebSocketTest.cs

@@ -0,0 +1,132 @@
+using Quobject.EngineIoClientDotNet.Client;
+using System.Collections.Concurrent;
+using System.Threading;
+using Xunit;
+
+namespace Quobject.EngineIoClientDotNet_Tests.ClientTests
+{
+    public class BinaryWebSocketTest : Connection
+    {
+        private ManualResetEvent _manualResetEvent = null;
+
+        [Fact]
+        public void ReceiveBinaryData()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var events = new ConcurrentQueue<object>();
+
+            var binaryData = new byte[5];
+            for (int i = 0; i < binaryData.Length; i++)
+            {
+                binaryData[i] = (byte)(i + 0);
+            }
+
+            var options = CreateOptions();
+
+            var socket = new Socket(options);
+
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+              //log.Info(Socket.EVENT_OPEN);
+            });
+
+            socket.On(Socket.EVENT_UPGRADE, () =>
+            {
+              //log.Info(Socket.EVENT_UPGRADE);
+                socket.Send(binaryData);
+            });
+
+            socket.On(Socket.EVENT_MESSAGE, (d) =>
+            {
+                var data = d as string;
+              //log.Info(string.Format("EVENT_MESSAGE data ={0} d = {1} ", data, d));
+
+                if (data == "hi")
+                {
+                    return;
+                }
+                events.Enqueue(d);
+                _manualResetEvent.Set();
+            });
+
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+          //log.Info("ReceiveBinaryData end");
+
+            var binaryData2 = new byte[5];
+            for (int i = 0; i < binaryData2.Length; i++)
+            {
+                binaryData2[i] = (byte)(i + 1);
+            }
+
+            object result;
+            events.TryDequeue(out result);
+            Assert.Equal(binaryData, result);
+        }
+
+        [Fact]
+        public void ReceiveBinaryDataAndMultibyteUTF8String()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var events = new ConcurrentQueue<object>();
+
+            var binaryData = new byte[5];
+            for (int i = 0; i < binaryData.Length; i++)
+            {
+                binaryData[i] = (byte)i;
+            }
+            const string stringData = "Ä ä Ü ü ß";
+
+            var options = CreateOptions();
+
+            var socket = new Socket(options);
+
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+            });
+
+            socket.On(Socket.EVENT_UPGRADE, () =>
+            {
+              //log.Info(Socket.EVENT_UPGRADE);
+                socket.Send(binaryData);
+                socket.Send(stringData);
+            });
+
+            socket.On(Socket.EVENT_MESSAGE, (d) =>
+            {
+                var data = d as string;
+              //log.Info(string.Format("EVENT_MESSAGE data ={0} d = {1} ", data, d));
+
+                if (data == "hi")
+                {
+                    return;
+                }
+                events.Enqueue(d);
+                if (events.Count > 1)
+                {
+                    _manualResetEvent.Set();
+                }
+            });
+
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+
+            var binaryData2 = new byte[5];
+            for (int i = 0; i < binaryData2.Length; i++)
+            {
+                binaryData2[i] = (byte)(i + 1);
+            }
+
+            object result;
+            events.TryDequeue(out result);
+            Assert.Equal(binaryData, result);
+            events.TryDequeue(out result);
+            Assert.Equal(stringData, (string)result);
+          //log.Info("ReceiveBinaryDataAndMultibyteUTF8String end");
+        }
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ClientTests/Connection.cs

@@ -0,0 +1,38 @@
+using Quobject.EngineIoClientDotNet.Client;
+using Quobject.EngineIoClientDotNet.Modules;
+
+namespace Quobject.EngineIoClientDotNet_Tests.ClientTests
+{
+    public class Connection
+    {
+        static Connection()
+        {
+            LogManager.SetupLogManager();
+        }
+
+        protected static Socket.Options CreateOptions()
+        {
+            var options = new Socket.Options
+            {
+                Port = ConnectionConstants.PORT,
+                Hostname = ConnectionConstants.HOSTNAME
+            };
+            //log.Info("Please add to your hosts file: 127.0.0.1 " + options.Hostname);
+
+            return options;
+        }
+
+        protected static Socket.Options CreateOptionsSecure()
+        {
+            var options = new Socket.Options
+            {
+                Port = ConnectionConstants.SSL_PORT,
+                Hostname = ConnectionConstants.HOSTNAME,
+                //log.Info("Please add to your hosts file: 127.0.0.1 " + options.Hostname);
+                Secure = true,
+                IgnoreServerCertificateValidation = true
+            };
+            return options;
+        }
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ClientTests/ConnectionConstants.cs

@@ -0,0 +1,10 @@
+namespace Quobject.EngineIoClientDotNet_Tests.ClientTests
+{
+    public static class ConnectionConstants
+    {
+        public static int PORT = 80;
+        public static string HOSTNAME = "testme.quobject.com";
+        public static int SSL_PORT = 443;
+        public static readonly int TIMEOUT = 300000;
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ClientTests/ConnectionTest.cs

@@ -0,0 +1,211 @@
+using Quobject.EngineIoClientDotNet.Client;
+using Quobject.EngineIoClientDotNet.Client.Transports;
+using Quobject.EngineIoClientDotNet.ComponentEmitter;
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Quobject.EngineIoClientDotNet_Tests.ClientTests
+{
+    public class ConnectionTest : Connection
+    {
+        private ManualResetEvent _manualResetEvent = null;
+        private Socket socket;
+        public string Message;
+
+        [Fact]
+        public void ConnectToLocalhost()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            socket = new Socket(CreateOptions());
+            socket.On(Socket.EVENT_OPEN, new TestListener());
+            socket.On(Socket.EVENT_MESSAGE, new MessageListener(socket, this));
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+            Assert.Equal("hi", this.Message);
+        }
+
+        public class TestListener : IListener
+        {
+            public void Call(params object[] args)
+            {
+                //log.Info("open");
+            }
+
+            public int CompareTo(IListener other)
+            {
+                return this.GetId().CompareTo(other.GetId());
+            }
+
+            public int GetId()
+            {
+                return 0;
+            }
+        }
+
+        public class MessageListener : IListener
+        {
+            private Socket socket;
+            private ConnectionTest connectionTest;
+
+            public MessageListener(Socket socket)
+            {
+                this.socket = socket;
+            }
+
+            public MessageListener(Socket socket, ConnectionTest connectionTest)
+            {
+                this.socket = socket;
+                this.connectionTest = connectionTest;
+            }
+
+            public void Call(params object[] args)
+            {
+                //log.Info("message = " + args[0]);
+                connectionTest.Message = (string)args[0];
+                connectionTest._manualResetEvent.Set();
+            }
+
+            public int CompareTo(IListener other)
+            {
+                return this.GetId().CompareTo(other.GetId());
+            }
+
+            public int GetId()
+            {
+                return 0;
+            }
+        }
+
+        [Fact]
+        public void ConnectToLocalhost2()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+            this.Message = "";
+
+            var options = CreateOptions();
+            options.Transports = ImmutableList.Create<string>(Polling.NAME);
+            socket = new Socket(options);
+
+            //socket = new Socket(CreateOptions());
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+                //log.Info("open");
+                //socket.Send("test send");
+            });
+            socket.On(Socket.EVENT_MESSAGE, (d) =>
+            {
+                var data = (string)d;
+
+                //log.Info("message2 = " + data);
+                this.Message = data;
+                _manualResetEvent.Set();
+            });
+
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+            Assert.Equal("hi", this.Message);
+        }
+
+        [Fact]
+        public void TestmultibyteUtf8StringsWithPolling()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            const string SendMessage = "cash money €€€";
+
+            socket = new Socket(CreateOptions());
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+                //log.Info("open");
+
+                socket.Send(SendMessage);
+            });
+            socket.On(Socket.EVENT_MESSAGE, (d) =>
+            {
+                var data = (string)d;
+
+                //log.Info("TestMessage data = " + data);
+
+                if (data == "hi")
+                {
+                    return;
+                }
+
+                this.Message = data;
+                _manualResetEvent.Set();
+            });
+
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+            //log.Info("TestmultibyteUtf8StringsWithPolling this.Message = " + this.Message);
+            Assert.Equal(SendMessage, this.Message);
+        }
+
+        [Fact]
+        public void Testemoji()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+            const string SendMessage = "\uD800-\uDB7F\uDB80-\uDBFF\uDC00-\uDFFF\uE000-\uF8FF";
+
+            var options = CreateOptions();
+            socket = new Socket(options);
+
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+                //log.Info("open");
+
+                socket.Send(SendMessage);
+            });
+
+            socket.On(Socket.EVENT_MESSAGE, (d) =>
+            {
+                var data = (string)d;
+
+                //log.Info(Socket.EVENT_MESSAGE);
+
+                if (data == "hi")
+                {
+                    return;
+                }
+
+                this.Message = data;
+                _manualResetEvent.Set();
+            });
+
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+
+            Assert.True(SendMessage == this.Message);
+        }
+
+        [Fact]
+        public async Task NotSendPacketsIfSocketCloses()
+        {
+            var noPacket = true;
+
+            socket = new Socket(CreateOptions());
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+                noPacket = true;
+            });
+
+            socket.Open();
+            socket.On(Socket.EVENT_PACKET_CREATE, () =>
+            {
+                noPacket = false;
+                //log.Info("NotSendPacketsIfSocketCloses EVENT_PACKET_CREATE noPacket = " + noPacket);
+            });
+            socket.Close();
+            await Task.Delay(1000);
+            //log.Info("NotSendPacketsIfSocketCloses end noPacket = " + noPacket);
+            Assert.True(noPacket);
+        }
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ClientTests/Connection_device.cs

@@ -0,0 +1,69 @@
+using Newtonsoft.Json;
+using Quobject.EngineIoClientDotNet.Client;
+using Quobject.EngineIoClientDotNet.Modules;
+using System.IO;
+
+
+namespace Quobject.EngineIoClientDotNet_Tests.ClientTests
+{
+    public class Connection
+    {
+        public static readonly int TIMEOUT = 300000;
+
+        static Connection()
+        {
+            LogManager.SetupLogManager();
+        }
+
+        protected Socket.Options CreateOptions()
+        {            
+
+
+
+            var config = ConfigBase.Load();
+            var options = new Socket.Options();
+            options.Port = config.server.port;
+            options.Hostname = config.server.hostname;
+            //log.Info("Please add to your hosts file: 127.0.0.1 " + options.Hostname);
+
+            return options;
+        }
+
+
+        protected Socket.Options CreateOptionsSecure()
+        {            
+
+
+            var config = ConfigBase.Load();
+            var options = new Socket.Options();
+            options.Port = config.server.ssl_port;
+            options.Hostname = config.server.hostname;
+            //log.Info("Please add to your hosts file: 127.0.0.1 " + options.Hostname);
+            options.Secure = true;
+            options.IgnoreServerCertificateValidation = true;
+            return options;
+        }
+    }
+
+    public class ConfigBase
+    {
+        public string version { get; set; }
+        public ConfigServer server { get; set; }
+
+        public static ConfigBase Load()
+        {
+            //var configString = File.ReadAllText("./../../../../grunt/config.json");
+			var configString = @"{""version"":""0.1.0.0"",""server"":{""port"":80,""ssl_port"":443,""hostname"":""192.168.178.59""},""win"":{""powershell"":""C:/WINDOWS/System32/WindowsPowerShell/v1.0/powershell.exe"",""msbuild"":""C:/Windows/Microsoft.NET/Framework/v4.0.30319/msbuild.exe"",""xunit_path"":""C:/vendors/xunit"",""nuget"":""C:/vendors/nuget/nuget.exe""},""linux"":{""msbuild"":""xbuild"",""xunit_path"":""/home/apollo/vendors/xunit""}}";
+
+            var config = JsonConvert.DeserializeObject<ConfigBase>(configString);
+            return config;
+        }
+    }
+
+    public class ConfigServer
+    {
+        public string hostname { get; set; }
+        public int port { get; set; }
+        public int ssl_port { get; set; }        
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ClientTests/HandshakeDataTests.cs

@@ -0,0 +1,26 @@
+using Quobject.EngineIoClientDotNet.Client;
+using Xunit;
+
+namespace Quobject.EngineIoClientDotNet_Tests.ClientTests
+{
+    public class HandshakeDataTests
+    {
+        [Fact]
+        public void Test()
+        {
+            var json = @"{
+                sid: 'nne323',
+                upgrades: ['u1','u2'],
+                pingInterval: 12,
+                pingTimeout: 23
+            }";
+
+            var handshakeData = new HandshakeData(json);
+            Assert.Equal("u1", handshakeData.Upgrades[0]);
+            Assert.Equal("u2", handshakeData.Upgrades[1]);
+
+            Assert.Equal(12, handshakeData.PingInterval);
+            Assert.Equal(23, handshakeData.PingTimeout);
+        }
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ClientTests/SSLServerConnectionTest.cs

@@ -0,0 +1,267 @@
+using Quobject.EngineIoClientDotNet.Client;
+using Quobject.EngineIoClientDotNet.Client.Transports;
+using Quobject.EngineIoClientDotNet.ComponentEmitter;
+using System;
+using System.Collections.Concurrent;
+using System.IO;
+using System.Threading;
+using Xunit;
+
+namespace Quobject.EngineIoClientDotNet_Tests.ClientTests
+{
+    public class SSLServerConnectionTest : Connection
+    {
+        private ManualResetEvent _manualResetEvent = null;
+
+        [Fact]
+        public void OpenAndClose()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var events = new ConcurrentQueue<string>();
+
+            var socket = new Socket(CreateOptionsSecure());
+            Console.WriteLine(Directory.GetCurrentDirectory());
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+                Console.WriteLine("EVENT_OPEN");
+                events.Enqueue(Socket.EVENT_OPEN);
+                socket.Close();
+            });
+            socket.On(Socket.EVENT_CLOSE, () =>
+            {
+                Console.WriteLine("EVENT_CLOSE");
+                events.Enqueue(Socket.EVENT_CLOSE);
+                _manualResetEvent.Set();
+            });
+
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+            string result;
+            events.TryDequeue(out result);
+            Assert.Equal(Socket.EVENT_OPEN, result);
+            events.TryDequeue(out result);
+            Assert.Equal(Socket.EVENT_CLOSE, result);
+        }
+
+        [Fact]
+        public void Messages()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var events = new ConcurrentQueue<string>();
+
+            var socket = new Socket(CreateOptionsSecure());
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+                socket.Send("hello");
+            });
+            socket.On(Socket.EVENT_MESSAGE, (d) =>
+            {
+                var data = (string)d;
+              //log.Info("EVENT_MESSAGE data = " + data);
+                events.Enqueue(data);
+                if (events.Count > 1)
+                {
+                    _manualResetEvent.Set();
+                }
+            });
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+
+            string result;
+            events.TryDequeue(out result);
+            Assert.Equal("hi", result);
+            events.TryDequeue(out result);
+            Assert.Equal("hello", result);
+        }
+
+        [Fact]
+        public void Handshake()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            HandshakeData handshake_data = null;
+
+            var socket = new Socket(CreateOptionsSecure());
+
+            socket.On(Socket.EVENT_HANDSHAKE, (data) =>
+            {
+              //log.Info(Socket.EVENT_HANDSHAKE + string.Format(" data = {0}", data));
+                handshake_data = data as HandshakeData;
+                _manualResetEvent.Set();
+            });
+
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+
+            Assert.NotNull(handshake_data);
+            Assert.NotNull(handshake_data.Upgrades);
+            Assert.True(handshake_data.Upgrades.Count > 0);
+            Assert.True(handshake_data.PingInterval > 0);
+            Assert.True(handshake_data.PingTimeout > 0);
+        }
+
+        public class TestHandshakeListener : IListener
+        {
+            public HandshakeData HandshakeData;
+            private SSLServerConnectionTest serverConnectionTest;
+
+            public TestHandshakeListener(SSLServerConnectionTest serverConnectionTest)
+            {
+                this.serverConnectionTest = serverConnectionTest;
+            }
+
+            public void Call(params object[] args)
+            {
+              //log.Info(string.Format("open args[0]={0} args.Length={1}", args[0], args.Length));
+                HandshakeData = args[0] as HandshakeData;
+                serverConnectionTest._manualResetEvent.Set();
+            }
+
+            public int CompareTo(IListener other)
+            {
+                return this.GetId().CompareTo(other.GetId());
+            }
+
+            public int GetId()
+            {
+                return 0;
+            }
+        }
+
+        [Fact]
+        public void Handshake2()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var socket = new Socket(CreateOptionsSecure());
+            var testListener = new TestHandshakeListener(this);
+            socket.On(Socket.EVENT_HANDSHAKE, testListener);
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+
+            Assert.NotNull(testListener.HandshakeData);
+            Assert.NotNull(testListener.HandshakeData.Upgrades);
+            Assert.True(testListener.HandshakeData.Upgrades.Count > 0);
+            Assert.True(testListener.HandshakeData.PingInterval > 0);
+            Assert.True(testListener.HandshakeData.PingTimeout > 0);
+        }
+
+        [Fact]
+        public void Upgrade()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var events = new ConcurrentQueue<object>();
+
+            var socket = new Socket(CreateOptionsSecure());
+
+            socket.On(Socket.EVENT_UPGRADING, (data) =>
+            {
+              //log.Info(Socket.EVENT_UPGRADING + string.Format(" data = {0}", data));
+                events.Enqueue(data);
+            });
+            socket.On(Socket.EVENT_UPGRADE, (data) =>
+            {
+              //log.Info(Socket.EVENT_UPGRADE + string.Format(" data = {0}", data));
+                events.Enqueue(data);
+                _manualResetEvent.Set();
+            });
+
+            socket.Open();
+            _manualResetEvent.WaitOne();
+
+            object test = null;
+            events.TryDequeue(out test);
+            Assert.NotNull(test);
+            Assert.IsAssignableFrom<Transport>(test);
+
+            events.TryDequeue(out test);
+            Assert.NotNull(test);
+            Assert.IsAssignableFrom<Transport>(test);
+        }
+
+        [Fact]
+        public void RememberWebsocket()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var socket1 = new Socket(CreateOptionsSecure());
+            string socket1TransportName = null;
+            string socket2TransportName = null;
+
+            socket1.On(Socket.EVENT_OPEN, () =>
+            {
+                socket1TransportName = socket1.Transport.Name;
+            });
+
+            socket1.On(Socket.EVENT_UPGRADE, (data) =>
+            {
+              //log.Info(Socket.EVENT_UPGRADE + string.Format(" data = {0}", data));
+                var transport = (Transport)data;
+                socket1.Close();
+                if (WebSocket.NAME == transport.Name)
+                {
+                    var options = CreateOptionsSecure();
+                    options.RememberUpgrade = true;
+                    var socket2 = new Socket(options);
+                    socket2.Open();
+                    socket2TransportName = socket2.Transport.Name;
+                    socket2.Close();
+                    _manualResetEvent.Set();
+                }
+            });
+
+            socket1.Open();
+            _manualResetEvent.WaitOne();
+            Assert.Equal(Polling.NAME, socket1TransportName);
+            Assert.Equal(WebSocket.NAME, socket2TransportName);
+        }
+
+        [Fact]
+        public void NotRememberWebsocket()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var socket1 = new Socket(CreateOptionsSecure());
+            string socket1TransportName = null;
+            string socket2TransportName = null;
+
+            socket1.On(Socket.EVENT_OPEN, () =>
+            {
+                socket1TransportName = socket1.Transport.Name;
+            });
+
+            socket1.On(Socket.EVENT_UPGRADE, (data) =>
+            {
+              //log.Info(Socket.EVENT_UPGRADE + string.Format(" data = {0}", data));
+                var transport = (Transport)data;
+                if (WebSocket.NAME == transport.Name)
+                {
+                    socket1.Close();
+                    var options = CreateOptionsSecure();
+                    options.RememberUpgrade = false;
+                    var socket2 = new Socket(options);
+                    socket2.On(Socket.EVENT_OPEN, () =>
+                    {
+                      //log.Info("EVENT_OPEN socket 2");
+                        socket2TransportName = socket2.Transport.Name;
+                        socket2.Close();
+                        _manualResetEvent.Set();
+                    });
+                    socket2.Open();
+                }
+            });
+
+            socket1.Open();
+            _manualResetEvent.WaitOne();
+            Assert.Equal(Polling.NAME, socket1TransportName);
+            Assert.Equal(Polling.NAME, socket2TransportName);
+        }
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ClientTests/ServerConnectionTest.cs

@@ -0,0 +1,451 @@
+using Quobject.EngineIoClientDotNet.Client;
+using Quobject.EngineIoClientDotNet.Client.Transports;
+using Quobject.EngineIoClientDotNet.ComponentEmitter;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading;
+using Xunit;
+
+namespace Quobject.EngineIoClientDotNet_Tests.ClientTests
+{
+    public class ServerConnectionTest : Connection
+    {
+        private ManualResetEvent _manualResetEvent = null;
+
+        [Fact]
+        public void OpenAndClose()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var events = new ConcurrentQueue<string>();
+
+            var options = CreateOptions();
+            options.Query = new Dictionary<string, string>
+            {
+                {
+                    "access_token", "akaka"
+                }
+            };
+            options.QueryString = "akka=ekek";
+            var socket = new Socket(options);
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+                events.Enqueue(Socket.EVENT_OPEN);
+                socket.Close();
+            });
+            socket.On(Socket.EVENT_CLOSE, () =>
+            {
+              //log.Info("EVENT_CLOSE");
+                events.Enqueue(Socket.EVENT_CLOSE);
+                _manualResetEvent.Set();
+            });
+
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+            string result;
+            events.TryDequeue(out result);
+            Assert.Equal(Socket.EVENT_OPEN, result);
+            events.TryDequeue(out result);
+            Assert.Equal(Socket.EVENT_CLOSE, result);
+        }
+
+        [Fact]
+        public void Messages()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var events = new ConcurrentQueue<string>();
+
+            var socket = new Socket(CreateOptions());
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+                socket.Send("hello");
+            });
+            socket.On(Socket.EVENT_MESSAGE, (d) =>
+            {
+                var data = (string)d;
+              //log.Info("EVENT_MESSAGE data = " + data);
+                events.Enqueue(data);
+                if (events.Count > 1)
+                {
+                    _manualResetEvent.Set();
+                }
+            });
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+
+            string result;
+            events.TryDequeue(out result);
+            Assert.Equal("hi", result);
+            events.TryDequeue(out result);
+            Assert.Equal("hello", result);
+        }
+
+        [Fact]
+        public void Handshake()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            HandshakeData handshake_data = null;
+
+            var socket = new Socket(CreateOptions());
+
+            socket.On(Socket.EVENT_HANDSHAKE, (data) =>
+            {
+              //log.Info(Socket.EVENT_HANDSHAKE + string.Format(" data = {0}", data));
+                handshake_data = data as HandshakeData;
+                _manualResetEvent.Set();
+            });
+
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+
+            Assert.NotNull(handshake_data);
+            Assert.NotNull(handshake_data.Upgrades);
+            Assert.True(handshake_data.Upgrades.Count > 0);
+            Assert.True(handshake_data.PingInterval > 0);
+            Assert.True(handshake_data.PingTimeout > 0);
+        }
+
+        public class TestHandshakeListener : IListener
+        {
+            public HandshakeData HandshakeData;
+            private ServerConnectionTest serverConnectionTest;
+
+            public TestHandshakeListener(ServerConnectionTest serverConnectionTest)
+            {
+                this.serverConnectionTest = serverConnectionTest;
+            }
+
+            public void Call(params object[] args)
+            {
+              //log.Info(string.Format("open args[0]={0} args.Length={1}", args[0], args.Length));
+                HandshakeData = args[0] as HandshakeData;
+                serverConnectionTest._manualResetEvent.Set();
+            }
+
+            public int CompareTo(IListener other)
+            {
+                return this.GetId().CompareTo(other.GetId());
+            }
+
+            public int GetId()
+            {
+                return 0;
+            }
+        }
+
+        [Fact]
+        public void Handshake2()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var socket = new Socket(CreateOptions());
+            var testListener = new TestHandshakeListener(this);
+            socket.On(Socket.EVENT_HANDSHAKE, testListener);
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+
+            Assert.NotNull(testListener.HandshakeData);
+            Assert.NotNull(testListener.HandshakeData.Upgrades);
+            Assert.True(testListener.HandshakeData.Upgrades.Count > 0);
+            Assert.True(testListener.HandshakeData.PingInterval > 0);
+            Assert.True(testListener.HandshakeData.PingTimeout > 0);
+        }
+
+        [Fact]
+        public void Upgrade()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var events = new ConcurrentQueue<object>();
+
+            var socket = new Socket(CreateOptions());
+
+            socket.On(Socket.EVENT_UPGRADING, (data) =>
+            {
+              //log.Info(Socket.EVENT_UPGRADING + string.Format(" data = {0}", data));
+                events.Enqueue(data);
+            });
+            socket.On(Socket.EVENT_UPGRADE, (data) =>
+            {
+              //log.Info(Socket.EVENT_UPGRADE + string.Format(" data = {0}", data));
+                events.Enqueue(data);
+                _manualResetEvent.Set();
+            });
+
+            socket.Open();
+            _manualResetEvent.WaitOne();
+
+            object test = null;
+            events.TryDequeue(out test);
+            Assert.NotNull(test);
+            Assert.IsAssignableFrom<Transport>(test);
+
+            events.TryDequeue(out test);
+            Assert.NotNull(test);
+            Assert.IsAssignableFrom<Transport>(test);
+        }
+
+        [Fact]
+        public void RememberWebsocket()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var socket1 = new Socket(CreateOptions());
+            string socket1TransportName = null;
+            string socket2TransportName = null;
+
+            socket1.On(Socket.EVENT_OPEN, () =>
+            {
+                socket1TransportName = socket1.Transport.Name;
+            });
+
+            socket1.On(Socket.EVENT_UPGRADE, (data) =>
+            {
+              //log.Info(Socket.EVENT_UPGRADE + string.Format(" data = {0}", data));
+                var transport = (Transport)data;
+                socket1.Close();
+                if (WebSocket.NAME == transport.Name)
+                {
+                    var options = CreateOptions();
+                    options.RememberUpgrade = true;
+                    var socket2 = new Socket(options);
+                    socket2.Open();
+                    socket2TransportName = socket2.Transport.Name;
+                    socket2.Close();
+                    _manualResetEvent.Set();
+                }
+            });
+
+            socket1.Open();
+            _manualResetEvent.WaitOne();
+            Assert.Equal(Polling.NAME, socket1TransportName);
+            Assert.Equal(WebSocket.NAME, socket2TransportName);
+        }
+
+        [Fact]
+        public void NotRememberWebsocket()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var socket1 = new Socket(CreateOptions());
+            string socket1TransportName = null;
+            string socket2TransportName = null;
+
+            socket1.On(Socket.EVENT_OPEN, () =>
+            {
+                socket1TransportName = socket1.Transport.Name;
+            });
+
+            socket1.On(Socket.EVENT_UPGRADE, (data) =>
+            {
+              //log.Info(Socket.EVENT_UPGRADE + string.Format(" data = {0}", data));
+                var transport = (Transport)data;
+                if (WebSocket.NAME == transport.Name)
+                {
+                    socket1.Close();
+                    var options = CreateOptions();
+                    options.RememberUpgrade = false;
+                    var socket2 = new Socket(options);
+                    socket2.On(Socket.EVENT_OPEN, () =>
+                    {
+                      //log.Info("EVENT_OPEN socket 2");
+                        socket2TransportName = socket2.Transport.Name;
+                        socket2.Close();
+                        _manualResetEvent.Set();
+                    });
+                    socket2.Open();
+                }
+            });
+
+            socket1.Open();
+            _manualResetEvent.WaitOne();
+            Assert.Equal(Polling.NAME, socket1TransportName);
+            Assert.Equal(Polling.NAME, socket2TransportName);
+        }
+
+
+        //Fails in .netstandard1.3 for EngineIoClientDotNet 1.0.4
+        [Fact]
+        public void Cookie()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var events = new Queue<string>();
+
+            var options = CreateOptions();
+            options.Cookies.Add("foo", "bar");
+            var socket = new Socket(options);
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+                socket.Send("cookie");
+            });
+            socket.On(Socket.EVENT_MESSAGE, (d) =>
+            {
+                var data = (string)d;
+              //log.Info("EVENT_MESSAGE data = " + data);
+                events.Enqueue(data);
+                if (events.Count > 1)
+                {
+                    _manualResetEvent.Set();
+                }
+            });
+            socket.Open();
+            _manualResetEvent.WaitOne();
+            socket.Close();
+
+            string result;
+            result = events.Dequeue();
+            Assert.Equal("hi", result);
+            result = events.Dequeue();
+            Assert.Equal("got cookie", result);
+        }
+
+        //Fails in .netstandard1.3 for EngineIoClientDotNet 1.0.4
+        [Fact]
+        public void UpgradeCookie()
+        {
+            _manualResetEvent = new ManualResetEvent(false);
+
+            var events = new Queue<object>();
+
+            var options = CreateOptions();
+            options.Cookies.Add("foo", "bar");
+            var socket = new Socket(options);
+
+            socket.On(Socket.EVENT_UPGRADING, (data) =>
+            {
+              //log.Info(Socket.EVENT_UPGRADING + string.Format(" data = {0}", data));
+                events.Enqueue(data);
+            });
+
+            socket.On(Socket.EVENT_UPGRADE, (data) =>
+            {
+              //log.Info(Socket.EVENT_UPGRADE + string.Format(" data = {0}", data));
+                events.Enqueue(data);
+                socket.Send("cookie");
+            });
+
+            socket.On(Socket.EVENT_MESSAGE, (d) =>
+            {
+                if (events.Count > 1)
+                {
+                    var data = (string)d;
+                  //log.Info("EVENT_MESSAGE data = " + data);
+                    events.Enqueue(data);
+                    _manualResetEvent.Set();
+                }
+            });
+
+            socket.Open();
+            _manualResetEvent.WaitOne();
+
+            object test = null;
+            test = events.Dequeue();
+            Assert.NotNull(test);
+            Assert.IsAssignableFrom<Transport>(test);
+
+            test = events.Dequeue();
+            Assert.NotNull(test);
+            Assert.IsAssignableFrom<Transport>(test);
+            test = events.Dequeue();
+            Assert.Equal("got cookie", test);
+        }
+
+        //[Fact]
+        //public void PrimusEndpoint()
+        //{
+        //    var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
+        //  //log.Info("Start");
+        //    _manualResetEvent = new ManualResetEvent(false);
+
+        //    var events = new Queue<string>();
+
+        //    var options = CreateOptions();
+        //    options.Cookies.Add("foo", "bar");
+        //    options.Hostname = "testme.quobject.com/";
+        //    options.Path = "primus";
+        //    var socket = new Socket(options);
+        //    //var socket = new Socket("testme.quobject.com");
+        //    socket.On(Socket.EVENT_OPEN, () =>
+        //    {
+        //      //log.Info("EVENT_OPEN");
+        //        socket.Send("cookie");
+        //    });
+        //    socket.On(Socket.EVENT_MESSAGE, (d) =>
+        //    {
+        //        var data = (string)d;
+        //      //log.Info("EVENT_MESSAGE data = " + data);
+        //        events.Enqueue(data);
+        //        if (events.Count > 1)
+        //        {
+        //            _manualResetEvent.Set();
+        //        }
+        //    });
+        //    socket.Open();
+        //    _manualResetEvent.WaitOne();
+        //    socket.Close();
+
+        //    string result;
+        //    result = events.Dequeue();
+        //    Assert.Equal("hi", result);
+        //    result = events.Dequeue();
+        //    Assert.Equal("got cookie", result);
+        //}
+
+        // [Fact]
+        //public void  MessagesMulti()
+        //{
+        //  //logManager.Enabled = true;
+
+        //    var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
+        //  //log.Info("Start");
+        //    _manualResetEvent = new ManualResetEvent(false);
+
+        //    var events = new ConcurrentQueue<string>();
+
+        //    int count = 200;
+
+        //    var socket = new Socket(CreateOptions());
+        //    socket.On(Socket.EVENT_OPEN, () =>
+        //    {
+        //      //log.Info("EVENT_OPEN");
+
+        //        Task.Run(() =>
+        //        {
+        //            for (int i = 0; i < count; i++)
+        //            {
+        //                socket.Send("multi");
+        //                Task.Delay(TimeSpan.FromSeconds(1)).Wait();
+        //            }
+
+        //        });
+
+        //    });
+        //    socket.On(Socket.EVENT_MESSAGE, (d) =>
+        //    {
+        //        var data = (string)d;
+        //      //log.Info("EVENT_MESSAGE data = " + data);
+        //        events.Enqueue(data);
+        //        if (events.Count > count)
+        //        {
+        //            _manualResetEvent.Set();
+        //        }
+        //    });
+        //    socket.Open();
+        //    _manualResetEvent.WaitOne();
+        //    socket.Close();
+
+        //    string result;
+        //    events.TryDequeue(out result);
+        //    Assert.Equal("hi", result);
+        //    events.TryDequeue(out result);
+        //    Assert.Equal("multi", result);
+        //}
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ClientTests/SocketTest.cs

@@ -0,0 +1,76 @@
+using Quobject.EngineIoClientDotNet.Client;
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Quobject.EngineIoClientDotNet_Tests.ClientTests
+{
+    public class SocketTest : Connection
+    {
+        private Socket socket;
+        public string Message;
+
+        [Fact]
+        public void FilterUpgrades()
+        {
+            var options = CreateOptions();
+            options.Transports = ImmutableList<string>.Empty.Add("polling");
+
+            socket = new Socket(options);
+
+            var immutablelist = socket.FilterUpgrades(ImmutableList<string>.Empty.Add("polling").Add("websocket"));
+
+            Assert.Equal("polling", immutablelist[0]);
+            Assert.Equal(1, immutablelist.Count);
+        }
+
+        [Fact]
+        public async Task SocketClosing()
+        {
+            var closed = false;
+            var error = false;
+
+            var options = CreateOptions();
+
+            socket = new Socket("ws://0.0.0.0:8080", options);
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+                //socket.Send("test send");
+            });
+            socket.On(Socket.EVENT_CLOSE, () =>
+            {
+                //log.Info("EVENT_CLOSE = ");
+                closed = true;
+            });
+
+            socket.Once(Socket.EVENT_ERROR, () =>
+            {
+                //log.Info("EVENT_ERROR = ");
+                error = true;
+            });
+
+            socket.Open();
+            //System.Threading.Thread.Sleep(TimeSpan.FromSeconds(1));
+            await Task.Delay(1000);
+            Assert.True(closed);
+            Assert.True(error);
+        }
+
+        [Fact]
+        public void SocketOptionCookies()
+        {
+            var options = new Socket.Options();
+            options.Cookies.Add("foo", "bar");
+            Assert.Equal("foo=bar", options.GetCookiesAsString());
+            options.Cookies.Add("name2", "value2");
+            Assert.Equal("foo=bar; name2=value2", options.GetCookiesAsString());
+        }
+
+        [Fact]
+        public void DefaultProtocol()
+        {
+            var socket = new Socket("testme.quobject.com");
+            Assert.NotNull(socket);
+        }
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ClientTests/TransportTest.cs

@@ -0,0 +1,170 @@
+using Quobject.EngineIoClientDotNet.Client;
+using Quobject.EngineIoClientDotNet.Client.Transports;
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using Xunit;
+
+namespace Quobject.EngineIoClientDotNet_Tests.ClientTests
+{
+    // NOTE: tests for the rememberUpgrade option are on ServerConnectionTest.
+
+    public class TransportTest : Connection
+    {
+        [Fact]
+        public void Constructors()
+        {
+            var socket = new Socket(CreateOptions());
+
+            socket.Open();
+            System.Threading.Thread.Sleep(TimeSpan.FromSeconds(3));
+            Assert.NotNull(socket.Transport);
+
+            socket.Close();
+        }
+
+        [Fact]
+        public void Uri()
+        {
+            var options = new Transport.Options
+            {
+                Path = "/engine.io",
+                Hostname = Connection.CreateOptions().Hostname,
+                Secure = false,
+                Query = new Dictionary<string, string> { { "sid", "test" } },
+                TimestampRequests = false
+            };
+            var polling = new Polling(options);
+            var expected = string.Format("http://{0}/engine.io?sid=test&b64=1", options.Hostname);
+            Assert.Contains(expected, polling.Uri());
+        }
+
+        [Fact]
+        public void UriWithDefaultPort()
+        {
+            var options = new Transport.Options
+            {
+                Path = "/engine.io",
+                Hostname = Connection.CreateOptions().Hostname,
+                Secure = false,
+                Query = new Dictionary<string, string> { { "sid", "test" } },
+                TimestampRequests = false,
+                Port = 80
+            };
+            var polling = new Polling(options);
+            //Assert.Contains("http://localhost/engine.io?sid=test&b64=1", polling.Uri());
+            var expected = string.Format("http://{0}/engine.io?sid=test&b64=1", options.Hostname);
+            Assert.Contains(expected, polling.Uri());
+        }
+
+        [Fact]
+        public void UriWithPort()
+        {
+            var options = new Transport.Options
+            {
+                Path = "/engine.io",
+                Hostname = Connection.CreateOptions().Hostname,
+                Secure = false,
+                Query = new Dictionary<string, string> { { "sid", "test" } },
+                TimestampRequests = false,
+                Port = 3000
+            };
+            var polling = new Polling(options);
+            //Assert.Contains("http://localhost:3000/engine.io?sid=test&b64=1", polling.Uri());
+            var expected = string.Format("http://{0}:{1}/engine.io?sid=test&b64=1", options.Hostname, options.Port);
+            Assert.Contains(expected, polling.Uri());
+        }
+
+        [Fact]
+        public void HttpsUriWithDefaultPort()
+        {
+            var options = new Transport.Options
+            {
+                Path = "/engine.io",
+                Hostname = Connection.CreateOptions().Hostname,
+                Secure = true,
+                Query = new Dictionary<string, string> { { "sid", "test" } },
+                TimestampRequests = false,
+                Port = 443
+            };
+            var polling = new Polling(options);
+            //Assert.Contains("https://localhost/engine.io?sid=test&b64=1", polling.Uri());
+            var expected = string.Format("https://{0}/engine.io?sid=test&b64=1", options.Hostname);
+            Assert.Contains(expected, polling.Uri());
+        }
+
+        [Fact]
+        public void TimestampedUri()
+        {
+            var options = new Transport.Options
+            {
+                Path = "/engine.io",
+                Hostname = "test",
+                Secure = false,
+                Query = new Dictionary<string, string> { { "sid", "test" } },
+                TimestampRequests = true,
+                TimestampParam = "t"
+            };
+            var polling = new Polling(options);
+
+            var pat = @"http://test/engine.io\?sid=test&(t=[0-9]+-[0-9]+)";
+            var r = new Regex(pat, RegexOptions.IgnoreCase);
+            var test = polling.Uri();
+            //log.Info(test);
+            var m = r.Match(test);
+            Assert.True(m.Success);
+        }
+
+        [Fact]
+        public void WsUri()
+        {
+            var options = new Transport.Options
+            {
+                Path = "/engine.io",
+                Hostname = "test",
+                Secure = false,
+                Query = new Dictionary<string, string> { { "transport", "websocket" } },
+                TimestampRequests = false
+            };
+            var ws = new WebSocket(options);
+            Assert.Contains("ws://test/engine.io?transport=websocket", ws.Uri());
+        }
+
+        [Fact]
+        public void WssUri()
+        {
+            var options = new Transport.Options
+            {
+                Path = "/engine.io",
+                Hostname = "test",
+                Secure = true,
+                Query = new Dictionary<string, string> { { "transport", "websocket" } },
+                TimestampRequests = false
+            };
+            var ws = new WebSocket(options);
+            Assert.Contains("wss://test/engine.io?transport=websocket", ws.Uri());
+        }
+
+        [Fact]
+        public void WsTimestampedUri()
+        {
+            var options = new Transport.Options
+            {
+                Path = "/engine.io",
+                Hostname = "test",
+                Secure = false,
+                Query = new Dictionary<string, string> { { "sid", "test" } },
+                TimestampRequests = true,
+                TimestampParam = "woot"
+            };
+            var ws = new WebSocket(options);
+
+            var pat = @"ws://test/engine.io\?sid=test&(woot=[0-9]+-[0-9]+)";
+            var r = new Regex(pat, RegexOptions.IgnoreCase);
+            var test = ws.Uri();
+            //log.Info(test);
+            var m = r.Match(test);
+            Assert.True(m.Success);
+        }
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ClientTests/UsageTest.cs

@@ -0,0 +1,45 @@
+using Quobject.EngineIoClientDotNet.Client;
+using System;
+using Xunit;
+
+namespace Quobject.EngineIoClientDotNet_Tests.ClientTests
+{
+    public class UsageTest : Connection
+    {
+        [Fact]
+        public void Usage1()
+        {
+            var options = CreateOptions();
+            var socket = new Socket(options);
+
+            //You can use `Socket` to connect:
+            //var socket = new Socket("ws://localhost");
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+                socket.Send("hi");
+                socket.Close();
+            });
+            socket.Open();
+
+            //System.Threading.Thread.Sleep(TimeSpan.FromSeconds(2));
+        }
+
+        [Fact]
+        public void Usage2()
+        {
+            var options = CreateOptions();
+            var socket = new Socket(options);
+
+            //Receiving data
+            //var socket = new Socket("ws://localhost:3000");
+            socket.On(Socket.EVENT_OPEN, () =>
+            {
+                socket.On(Socket.EVENT_MESSAGE, (data) => Console.WriteLine((string)data));
+            });
+            socket.Open();
+
+            System.Threading.Thread.Sleep(TimeSpan.FromSeconds(2));
+            socket.Close();
+        }
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ComponentEmitterTests/EmitterTests.cs

@@ -0,0 +1,399 @@
+using Quobject.EngineIoClientDotNet.ComponentEmitter;
+using Quobject.EngineIoClientDotNet.Modules;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace Quobject.EngineIoClientDotNet_Tests.ComponentEmitterTests
+{
+    public class EmitterTests
+    {
+        public class TestListener1 : IListener
+        {
+            private readonly List<object> _calls;
+
+            public TestListener1(List<object> calls)
+            {
+                this._calls = calls;
+            }
+
+            public void Call(params object[] args)
+            {
+                _calls.Add("one");
+                _calls.Add(args[0]);
+            }
+
+            public int CompareTo(IListener other)
+            {
+                return this.GetId().CompareTo(other.GetId());
+            }
+
+            public int GetId()
+            {
+                return 0;
+            }
+        }
+
+        public class TestListener2 : IListener
+        {
+            private readonly List<object> _calls;
+
+            public TestListener2(List<object> calls)
+            {
+                this._calls = calls;
+            }
+
+            public void Call(params object[] args)
+            {
+                _calls.Add("two");
+                _calls.Add(args[0]);
+            }
+
+            public int CompareTo(IListener other)
+            {
+                return this.GetId().CompareTo(other.GetId());
+            }
+
+            public int GetId()
+            {
+                return 0;
+            }
+
+        }
+
+
+        [Fact]
+        public void On()
+        {
+
+
+
+
+            var emitter = new Emitter();
+            var calls = new List<object>();
+
+            var listener1 = new TestListener1(calls);
+            emitter.On("foo", listener1);
+
+            var listener2 = new TestListener2(calls);
+            emitter.On("foo", listener2);
+
+            emitter.Emit("foo", 1);
+            emitter.Emit("bar", 1);
+            emitter.Emit("foo", 2);
+
+            var expected = new Object[] {"one", 1, "two", 1, "one", 2, "two", 2};
+            Assert.Equal(expected, calls.ToArray());
+        }
+
+        [Fact]
+        public void Once()
+        {
+
+
+
+
+            var emitter = new Emitter();
+            var calls = new List<object>();
+
+            var listener1 = new TestListener1(calls);
+            emitter.Once("foo", listener1);
+
+            emitter.Emit("foo", 1);
+            emitter.Emit("foo", 2);
+            emitter.Emit("foo", 3);
+            emitter.Emit("bar", 1);
+
+            var expected = new Object[] {"one", 1};
+            Assert.Equal(expected, calls.ToArray());
+        }
+
+
+        public class TestListener3 : IListener
+        {
+            private readonly List<object> _calls;
+
+            public TestListener3(List<object> calls)
+            {
+                this._calls = calls;
+            }
+
+            public void Call(params object[] args)
+            {
+                _calls.Add("one");
+            }
+
+            public int CompareTo(IListener other)
+            {
+                return this.GetId().CompareTo(other.GetId());
+            }
+
+            public int GetId()
+            {
+                return 0;
+            }
+
+        }
+
+        public class TestListener4 : IListener
+        {
+            private readonly List<object> _calls;
+
+            public TestListener4(List<object> calls)
+            {
+                this._calls = calls;
+            }
+
+            public void Call(params object[] args)
+            {
+                _calls.Add("two");
+            }
+
+            public int CompareTo(IListener other)
+            {
+                return this.GetId().CompareTo(other.GetId());
+            }
+
+            public int GetId()
+            {
+                return 0;
+            }
+
+        }
+
+        [Fact]
+        public void Off()
+        {
+
+
+
+
+            var emitter = new Emitter();
+            var calls = new List<object>();
+
+            var listener3 = new TestListener3(calls);
+            emitter.On("foo", listener3);
+
+            var listener4 = new TestListener4(calls);
+            emitter.On("foo", listener4);
+            emitter.Off("foo", listener4);
+
+            emitter.Emit("foo");
+
+            var expected = new Object[] {"one"};
+            Assert.Equal(expected, calls.ToArray());
+        }
+
+        [Fact]
+        public void OffWithOnce()
+        {
+
+
+
+
+            var emitter = new Emitter();
+            var calls = new List<object>();
+
+            var listener3 = new TestListener3(calls);
+
+            emitter.Once("foo", listener3);
+            emitter.Off("foo", listener3);
+
+            emitter.Emit("foo");
+
+            var expected = new Object[] {};
+            Assert.Equal(expected, calls.ToArray());
+        }
+
+
+        public class TestListener5 : IListener
+        {
+            private readonly List<bool> _called;
+
+            public TestListener5(List<bool> called)
+            {
+                this._called = called;
+            }
+
+            public void Call(params object[] args)
+            {
+                this._called[0] = true;
+            }
+
+            public int CompareTo(IListener other)
+            {
+                return this.GetId().CompareTo(other.GetId());
+            }
+
+            public int GetId()
+            {
+                return 0;
+            }
+
+        }
+
+        public class TestListener6 : IListener
+        {
+            private readonly Emitter _emitter;
+            private readonly IListener _bListener;
+
+            public TestListener6(Emitter emitter, IListener bListener)
+            {
+                this._emitter = emitter;
+                this._bListener = bListener;
+            }
+
+            public void Call(params object[] args)
+            {
+                _emitter.Off("tobi", _bListener);
+            }
+
+            public int CompareTo(IListener other)
+            {
+                return this.GetId().CompareTo(other.GetId());
+            }
+
+            public int GetId()
+            {
+                return 0;
+            }
+
+        }
+
+        [Fact]
+        public void OffWhenCalledfromEvent()
+        {
+
+
+
+
+            var emitter = new Emitter();
+            var called = new List<bool> {false};
+
+
+            var listener5 = new TestListener5(called);
+            var listener6 = new TestListener6(emitter, listener5);
+            emitter.On("tobi", listener6);
+
+            emitter.Once("tobi", listener5);
+            emitter.Emit("tobi");
+            Assert.True(called[0]);
+            called[0] = false;
+            emitter.Emit("tobi");
+            Assert.False(called[0]);
+        }
+
+        [Fact]
+        public void OffEvent()
+        {
+
+
+
+
+            var emitter = new Emitter();
+            var calls = new List<object>();
+
+            var listener3 = new TestListener3(calls);
+            emitter.On("foo", listener3);
+
+            var listener4 = new TestListener4(calls);
+
+            emitter.On("foo", listener3);
+            emitter.On("foo", listener4);
+            emitter.Off("foo");
+
+            emitter.Emit("foo");
+            emitter.Emit("foo");
+
+            var expected = new Object[] {};
+            Assert.Equal(expected, calls.ToArray());
+        }
+
+
+        [Fact]
+        public void OffAll()
+        {
+
+
+
+
+            var emitter = new Emitter();
+            var calls = new List<object>();
+
+            var listener3 = new TestListener3(calls);
+
+            var listener4 = new TestListener4(calls);
+
+
+
+            emitter.On("foo", listener3);
+            emitter.On("bar", listener4);
+
+            emitter.Emit("foo");
+            emitter.Emit("bar");
+
+            emitter.Off();
+
+            emitter.Emit("foo");
+            emitter.Emit("bar");
+
+
+            var expected = new Object[] {"one", "two"};
+            Assert.Equal(expected, calls.ToArray());
+        }
+
+        [Fact]
+        public void Listeners()
+        {
+
+
+
+
+            var emitter = new Emitter();
+            var calls = new List<object>();
+
+            var listener3 = new TestListener3(calls);
+            emitter.On("foo", listener3);
+            var expected = new IListener[] {listener3};
+            Assert.Equal(expected, emitter.Listeners("foo").ToArray());
+        }
+
+        [Fact]
+        public void ListenersWithoutHandlers()
+        {
+
+            var emitter = new Emitter();
+            var expected = new IListener[] {};
+            Assert.Equal(expected, emitter.Listeners("foo").ToArray());
+        }
+
+        [Fact]
+        public void HasListeners()
+        {
+
+
+
+
+            var emitter = new Emitter();
+            var calls = new List<object>();
+            Assert.False(emitter.HasListeners("foo"));
+
+            var listener3 = new TestListener3(calls);
+            emitter.On("foo", listener3);
+            Assert.True(emitter.HasListeners("foo"));
+        }
+
+        [Fact]
+        public void HasListenersWithoutHandlers()
+        {
+
+
+
+
+            var emitter = new Emitter();
+            Assert.False(emitter.HasListeners("foo"));
+        }
+
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/EngineIoClientDotNet.Tests.mono.csproj

@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{382C2A10-8043-49C6-9DE5-39CA25C2418C}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>EngineIoClientDotNet.Tests</RootNamespace>
+    <AssemblyName>EngineIoClientDotNet.Tests.mono</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Newtonsoft.Json, Version=10.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>..\EngineIoClientDotNet.mono\packages\Newtonsoft.Json.10.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="SuperSocket.ClientEngine, Version=0.8.0.8, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\EngineIoClientDotNet.mono\packages\SuperSocket.ClientEngine.Core.0.8.0.8\lib\net45\SuperSocket.ClientEngine.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.ComponentModel.Composition" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.IO.Compression" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Numerics" />
+    <Reference Include="System.Runtime.InteropServices.RuntimeInformation, Version=4.0.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\EngineIoClientDotNet.mono\packages\System.Runtime.InteropServices.RuntimeInformation.4.3.0\lib\net45\System.Runtime.InteropServices.RuntimeInformation.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System.Web.Extensions" />
+    <Reference Include="System.Xml" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="WebSocket4Net, Version=0.15.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\EngineIoClientDotNet.mono\packages\WebSocket4Net.0.15.0-beta6\lib\net45\WebSocket4Net.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
+      <HintPath>..\EngineIoClientDotNet.mono\packages\xunit.abstractions.2.0.1\lib\net35\xunit.abstractions.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="xunit.assert, Version=2.2.0.3545, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
+      <HintPath>..\EngineIoClientDotNet.mono\packages\xunit.assert.2.2.0\lib\netstandard1.1\xunit.assert.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="xunit.core, Version=2.2.0.3545, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
+      <HintPath>..\EngineIoClientDotNet.mono\packages\xunit.extensibility.core.2.2.0\lib\netstandard1.1\xunit.core.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="xunit.execution.dotnet, Version=2.2.0.3545, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
+      <HintPath>..\EngineIoClientDotNet.mono\packages\xunit.extensibility.execution.2.2.0\lib\netstandard1.1\xunit.execution.dotnet.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ClientTests\BinaryPollingTest.cs" />
+    <Compile Include="ClientTests\BinaryWebSocketTest.cs" />
+    <Compile Include="ClientTests\Connection.cs" />
+    <Compile Include="ClientTests\ConnectionTest.cs" />
+    <Compile Include="ClientTests\HandshakeDataTests.cs" />
+    <Compile Include="ClientTests\ServerConnectionTest.cs" />
+    <Compile Include="ClientTests\SocketTest.cs" />
+    <Compile Include="ClientTests\SSLServerConnectionTest.cs" />
+    <Compile Include="ClientTests\TransportTest.cs" />
+    <Compile Include="ClientTests\UsageTest.cs" />
+    <Compile Include="ComponentEmitterTests\EmitterTests.cs" />
+    <Compile Include="ModulesTests\ParseQSTests.cs" />
+    <Compile Include="ModulesTests\UTF8Tests.cs" />
+    <Compile Include="ParserTests\DecodeTests.cs" />
+    <Compile Include="ParserTests\TestsParser.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="ThreadTests\" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\EngineIoClientDotNet.mono\EngineIoClientDotNet.mono.csproj">
+      <Project>{b6731266-b247-4a63-b10b-f938288248b6}</Project>
+      <Name>EngineIoClientDotNet.mono</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ModulesTests/ParseQSTests.cs

@@ -0,0 +1,52 @@
+using System.Collections.Immutable;
+using Quobject.EngineIoClientDotNet.Modules;
+using System.Collections.Generic;
+using Xunit;
+
+
+namespace Quobject.EngineIoClientDotNet_Tests.ModulesTests
+{
+    public class ParseQsTests
+    {
+        //should parse a querystring and return an object
+        [Fact]
+        public void Decode()
+        {
+            // Single assignment
+            var queryObj = ParseQS.Decode("foo=bar");
+            Assert.Equal("bar", queryObj["foo"]);
+
+            // Multiple assignments
+            queryObj = ParseQS.Decode("france=grenoble&germany=mannheim");
+            Assert.Equal("grenoble", queryObj["france"]);
+            Assert.Equal("mannheim", queryObj["germany"]);
+
+            // Assignments containing non-alphanumeric characters
+            queryObj = ParseQS.Decode("india=new%20delhi");
+            Assert.Equal("new delhi", queryObj["india"]);
+        }
+
+        //should construct a query string from an object'
+        [Fact]
+        public void Encode()
+        {
+
+            Dictionary<string, string> obj;
+
+            obj = new Dictionary<string, string> {{"a", "b"}};
+            var imObj = ImmutableDictionary.Create<string, string>().AddRange(obj);
+            Assert.Equal("a=b", ParseQS.Encode(imObj));
+
+            obj = new Dictionary<string, string> {{"a", "b"}, {"c", "d"}};
+            imObj = ImmutableDictionary.Create<string, string>().AddRange(obj);
+            Assert.Equal("a=b&c=d", ParseQS.Encode(imObj));
+
+            obj = new Dictionary<string, string> {{"a", "b"}, {"c", "tobi rocks"}};
+            imObj = ImmutableDictionary.Create<string, string>().AddRange(obj);
+            Assert.Equal("a=b&c=tobi%20rocks", ParseQS.Encode(imObj));
+
+        }
+
+
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ModulesTests/UTF8Tests.cs

@@ -0,0 +1,140 @@
+using Quobject.EngineIoClientDotNet.Modules;
+using System;
+using Xunit;
+
+
+namespace Quobject.EngineIoClientDotNet_Tests.ModulesTests
+{
+    public class Utf8Tests
+    {
+        private static readonly Data[] DATA = new Data[]
+        {
+            // 1-byte
+            new Data(0x0000, "\x00", "\x00"),
+            new Data(0x005c, "\u005C\u005C", "\u005C\u005C"), // = backslash
+            new Data(0x007f, "\u007F", "\u007F"),
+            // 2-byte
+            new Data(0x0080, "\u0080", "\u00C2\u0080"),
+            new Data(0x05CA, "\u05CA", "\u00D7\u008A"),
+            new Data(0x07FF, "\u07FF", "\u00DF\u00BF"),
+            // 3-byte
+            new Data(0x0800, "\u0800", "\u00E0\u00A0\u0080"),
+            new Data(0x2C3C, "\u2C3C", "\u00E2\u00B0\u00BC"),
+            new Data(0x07FF, "\uFFFF", "\u00EF\u00BF\u00BF"),
+            // unmatched surrogate halves
+            // high surrogates: 0xD800 to 0xDBFF
+            new Data(0xD800, "\uD800", "\u00ED\u00A0\u0080"),
+            new Data("High surrogate followed by another high surrogate",
+                "\uD800\uD800", "\u00ED\u00A0\u0080\u00ED\u00A0\u0080"),
+            new Data("High surrogate followed by a symbol that is not a surrogate",
+                "\uD800A", "\u00ED\u00A0\u0080A"),
+            new Data(
+                "Unmatched high surrogate, followed by a surrogate pair, followed by an unmatched high surrogate",
+                "\uD800\uD834\uDF06\uD800", "\u00ED\u00A0\u0080\u00F0\u009D\u008C\u0086\u00ED\u00A0\u0080"),
+            new Data(0xD9AF, "\uD9AF", "\u00ED\u00A6\u00AF"),
+            new Data(0xDBFF, "\uDBFF", "\u00ED\u00AF\u00BF"),
+            // low surrogates: 0xDC00 to 0xDFFF
+            new Data(0xDC00, "\uDC00", "\u00ED\u00B0\u0080"),
+            new Data("Low surrogate followed by another low surrogate",
+                "\uDC00\uDC00", "\u00ED\u00B0\u0080\u00ED\u00B0\u0080"),
+            new Data("Low surrogate followed by a symbol that is not a surrogate",
+                "\uDC00A", "\u00ED\u00B0\u0080A"),
+            new Data(
+                "Unmatched low surrogate, followed by a surrogate pair, followed by an unmatched low surrogate",
+                "\uDC00\uD834\uDF06\uDC00", "\u00ED\u00B0\u0080\u00F0\u009D\u008C\u0086\u00ED\u00B0\u0080"),
+            new Data(0xDEEE, "\uDEEE", "\u00ED\u00BB\u00AE"),
+            new Data(0xDFFF, "\uDFFF", "\u00ED\u00BF\u00BF"),
+            // 4-byte
+            new Data(0x010000, "\uD800\uDC00", "\u00F0\u0090\u0080\u0080"),
+            new Data(0x01D306, "\uD834\uDF06", "\u00F0\u009D\u008C\u0086"),
+            new Data(0x010FFF, "\uDBFF\uDFFF", "\u00F4\u008F\u00BF\u00BF"),
+        };
+
+        //
+        [Fact]
+        public void EncodeAndDecode()
+        {
+            foreach (var data in DATA)
+            {
+                data.Test();
+            }
+        }
+
+
+
+        private class Data
+        {
+            private readonly int _codePoint = -1;
+            private String Description { get; set; }
+            private String Decoded { get; set; }
+            private String Encoded { get; set; }
+
+            public Data(int codePoint, String decoded, String encoded)
+            {
+                this._codePoint = codePoint;
+                this.Decoded = decoded;
+                this.Encoded = encoded;
+            }
+
+            public Data(String description, String decoded, String encoded)
+            {
+                this.Description = description;
+                this.Decoded = decoded;
+                this.Encoded = encoded;
+            }
+
+            public void Test()
+            {
+                EncodingTest();
+                DecodingTest();
+                ExceptionTest();
+            }
+
+            private void EncodingTest()
+            {
+                var value = UTF8.Encode(Decoded);
+                Assert.Equal(Encoded, value);
+            }
+
+            private void DecodingTest()
+            {
+                Assert.Equal(Decoded, UTF8.Decode(Encoded));
+            }
+
+            private void ExceptionTest()
+            {
+                Assert.Throws<UTF8Exception>(
+                    delegate
+                    {
+                        UTF8.Decode("\uFFFF");
+                    });
+
+                Assert.Throws<UTF8Exception>(
+                    delegate
+                    {
+                        UTF8.Decode("\xE9\x00\x00");
+                    });
+
+                Assert.Throws<UTF8Exception>(
+                    delegate
+                    {
+                        UTF8.Decode("\xC2\uFFFF");
+                    });
+
+                Assert.Throws<UTF8Exception>(
+                    delegate
+                    {
+                        UTF8.Decode("\xF0\x9D");
+                    });
+
+            }
+
+
+            private string Reason
+            {
+                get { return Description ?? "U+" + _codePoint.ToString("X4").ToUpper(); }
+            }
+        }
+
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ParserTests/DecodeTests.cs

@@ -0,0 +1,82 @@
+using Quobject.EngineIoClientDotNet.Modules;
+using Quobject.EngineIoClientDotNet.Parser;
+using Xunit;
+
+namespace Quobject.EngineIoClientDotNet_Tests.ParserTests
+{
+    public class DecodeTests
+    {
+        private const string PARSER_ERROR = "parser error";
+
+        [Fact]
+        public void DecodeBadFormat()
+        {
+            LogManager.SetupLogManager();
+            var log = LogManager.GetLogger("DecodeTests DecodeBadFormat");
+
+
+            Packet p = Parser.DecodePacket(":::");
+            Assert.Equal(Packet.ERROR, p.Type);
+            Assert.Equal(PARSER_ERROR, p.Data);
+        }
+
+        [Fact]
+        public void DecodeInexistingTypes()
+        {
+
+            Packet p = Parser.DecodePacket("94103");
+            Assert.Equal(Packet.ERROR, p.Type);
+            Assert.Equal(PARSER_ERROR, p.Data);
+        }
+
+        [Fact]
+        public void DecodeInvalidUTF8()
+        {
+
+            Packet p = Parser.DecodePacket("4\uffff", true);
+            Assert.Equal(Packet.ERROR, p.Type);
+            Assert.Equal(PARSER_ERROR, p.Data);
+        }
+
+
+        public class DecodePayloadBadFormat_DecodeCallback : IDecodePayloadCallback
+        {
+
+            public bool Call(Packet packet, int index, int total)
+            {
+                var isLast = index + 1 == total;
+                Assert.True(isLast);
+                Assert.Equal(Packet.ERROR, packet.Type);
+                Assert.Equal(PARSER_ERROR, packet.Data);
+                return true;
+            }
+        }
+
+        [Fact]
+        public void EncodeAndDecodeEmptyPayloads()
+        {
+
+            Packet.DecodePayload("1!", new DecodePayloadBadFormat_DecodeCallback());
+            Packet.DecodePayload("", new DecodePayloadBadFormat_DecodeCallback());
+            Packet.DecodePayload("))", new DecodePayloadBadFormat_DecodeCallback());
+        }
+
+        [Fact]
+        public void DecodePayloadBadPacketFormat()
+        {
+
+            Packet.DecodePayload("3:99", new DecodePayloadBadFormat_DecodeCallback());
+            Packet.DecodePayload("1:aa", new DecodePayloadBadFormat_DecodeCallback());
+            Packet.DecodePayload("1:a2:b", new DecodePayloadBadFormat_DecodeCallback());
+        }
+
+        [Fact]
+        public void DecodePayloadInvalidUTF8()
+        {
+            Packet.DecodePayload("2:4\uffff", new DecodePayloadBadFormat_DecodeCallback());
+        }
+
+
+
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/ParserTests/TestsParser.cs

@@ -0,0 +1,449 @@
+using Quobject.EngineIoClientDotNet.Modules;
+using Quobject.EngineIoClientDotNet.Parser;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using Xunit;
+
+namespace Quobject.EngineIoClientDotNet_Tests.ParserTests
+{
+    public class TestsParser
+    {
+
+        public interface IPacketTest
+        {
+            Packet GetPacket();
+
+        }
+
+        [Fact]
+        public void EncodeTests()
+        {
+            var testList = new List<IPacketTest>()
+            {
+                new EncodeAsStringCallback(),
+                new DecodeAsPacketCallback(),
+                new NoDataCallback(),
+                new EncodeOpenPacket(),
+                new EncodeClosePacket(),
+                new EncodePingPacket(),
+                new EncodePongPacket(),
+                new EncodeMessagePacket(),
+                new EncodeUTF8SpecialCharsPacket(),
+                new EncodeUpgradePacket(),
+                new EncodeFormat1(),
+                new EncodeFormat2(),
+
+
+            };
+
+            foreach (var test in testList)
+            {
+                Parser.EncodePacket(test.GetPacket(), (IEncodeCallback) test);
+            }
+        }
+
+
+        public class EncodeAsStringCallback : IEncodeCallback, IPacketTest
+        {
+            public void Call(object data)
+            {
+                Assert.IsType<string>(data);
+            }
+
+            public Packet GetPacket()
+            {
+                return new Packet(Packet.MESSAGE, "test");
+            }
+        }
+
+
+        public class DecodeAsPacketCallback : IEncodeCallback, IPacketTest
+        {
+            public void Call(object data)
+            {
+                Assert.IsType<Packet>(Parser.DecodePacket((string) data));
+            }
+
+            public Packet GetPacket()
+            {
+                return new Packet(Packet.MESSAGE, "test");
+            }
+        }
+
+
+        public class NoDataCallback : IEncodeCallback, IPacketTest
+        {
+            public void Call(object data)
+            {
+                Packet p = Parser.DecodePacket((string) data);
+                Assert.Equal(Packet.MESSAGE, p.Type);
+                Assert.Null(p.Data);
+            }
+
+            public Packet GetPacket()
+            {
+                return new Packet(Packet.MESSAGE);
+            }
+        }
+
+        public class EncodeOpenPacket : IEncodeCallback, IPacketTest
+        {
+            private static string Json = "{\"some\":\"json\"}";
+
+            public void Call(object data)
+            {
+                Packet p = Parser.DecodePacket((string) data);
+                Assert.Equal(Packet.OPEN, p.Type);
+                Assert.Equal(Json, p.Data);
+            }
+
+            public Packet GetPacket()
+            {
+                return new Packet(Packet.OPEN, Json);
+            }
+        }
+
+        public class EncodeClosePacket : IEncodeCallback, IPacketTest
+        {
+            public void Call(object data)
+            {
+                Packet p = Parser.DecodePacket((string) data);
+                Assert.Equal(Packet.CLOSE, p.Type);
+            }
+
+            public Packet GetPacket()
+            {
+                return new Packet(Packet.CLOSE);
+            }
+        }
+
+        public class EncodePingPacket : IEncodeCallback, IPacketTest
+        {
+            public void Call(object data)
+            {
+                Packet p = Parser.DecodePacket((string) data);
+                Assert.Equal(Packet.PING, p.Type);
+                Assert.Equal("1", p.Data);
+            }
+
+            public Packet GetPacket()
+            {
+                return new Packet(Packet.PING, "1");
+            }
+        }
+
+        public class EncodePongPacket : IEncodeCallback, IPacketTest
+        {
+            public void Call(object data)
+            {
+                Packet p = Parser.DecodePacket((string) data);
+                Assert.Equal(Packet.PONG, p.Type);
+                Assert.Equal("1", p.Data);
+            }
+
+            public Packet GetPacket()
+            {
+                return new Packet(Packet.PONG, "1");
+            }
+        }
+
+        public class EncodeMessagePacket : IEncodeCallback, IPacketTest
+        {
+            public void Call(object data)
+            {
+                Packet p = Parser.DecodePacket((string) data);
+                Assert.Equal(Packet.MESSAGE, p.Type);
+                Assert.Equal("aaa", p.Data);
+            }
+
+            public Packet GetPacket()
+            {
+                return new Packet(Packet.MESSAGE, "aaa");
+            }
+        }
+
+        public class EncodeUTF8SpecialCharsPacket : IEncodeCallback, IPacketTest
+        {
+            public void Call(object data)
+            {
+                Packet p = Parser.DecodePacket((string) data);
+                Assert.Equal(Packet.MESSAGE, p.Type);
+                Assert.Equal("utf8 — string", p.Data);
+            }
+
+            public Packet GetPacket()
+            {
+                return new Packet(Packet.MESSAGE, "utf8 — string");
+            }
+        }
+
+        public class EncodeUpgradePacket : IEncodeCallback, IPacketTest
+        {
+            public void Call(object data)
+            {
+                Packet p = Parser.DecodePacket((string) data);
+                Assert.Equal(Packet.UPGRADE, p.Type);
+            }
+
+            public Packet GetPacket()
+            {
+                return new Packet(Packet.UPGRADE);
+            }
+        }
+
+        public class EncodeFormat1 : IEncodeCallback, IPacketTest
+        {
+            public void Call(object data)
+            {
+                var dataString = data as string;
+                var r = new Regex(@"[0-9]", RegexOptions.IgnoreCase);
+                Assert.True(r.Match(dataString).Success);
+            }
+
+            public Packet GetPacket()
+            {
+                return new Packet(Packet.MESSAGE);
+            }
+        }
+
+        public class EncodeFormat2 : IEncodeCallback, IPacketTest
+        {
+            public void Call(object data)
+            {
+                var dataString = data as string;
+                Assert.Equal("4test", dataString);
+            }
+
+            public Packet GetPacket()
+            {
+                return new Packet(Packet.MESSAGE, "test");
+            }
+        }
+
+
+
+        public class EncodePayloadsCallback : IEncodeCallback
+        {
+            public void Call(object data)
+            {
+                Assert.IsType<byte[]>(data);
+            }
+
+
+
+        }
+
+        [Fact]
+        public void EncodePayloads()
+        {
+            var packets = new Packet[] {new Packet(Packet.PING), new Packet(Packet.PONG),};
+            Parser.EncodePayload(packets, new EncodePayloadsCallback());
+
+        }
+
+
+        public class EncodeAndDecodePayloads_EncodeCallback : IEncodeCallback
+        {
+            public void Call(object data)
+            {
+                Parser.DecodePayload((byte[]) data, new EncodeAndDecodePayloads_DecodeCallback());
+            }
+
+            public class EncodeAndDecodePayloads_DecodeCallback : IDecodePayloadCallback
+            {
+
+                public bool Call(Packet packet, int index, int total)
+                {
+                    bool isLast = index + 1 == total;
+                    Assert.True(isLast);
+                    return true;
+                }
+            }
+
+        }
+
+        [Fact]
+        public void EncodeAndDecodePayloads()
+        {
+            var packets = new Packet[] {new Packet(Packet.MESSAGE, "a"),};
+            Parser.EncodePayload(packets, new EncodeAndDecodePayloads_EncodeCallback());
+
+        }
+
+        public class EncodeAndDecodePayloads_EncodeCallback2 : IEncodeCallback
+        {
+            public void Call(object data)
+            {
+                Parser.DecodePayload((byte[]) data, new EncodeAndDecodePayloads_DecodeCallback2());
+            }
+
+            public class EncodeAndDecodePayloads_DecodeCallback2 : IDecodePayloadCallback
+            {
+
+                public bool Call(Packet packet, int index, int total)
+                {
+                    var isLast = index + 1 == total;
+                    Assert.Equal(isLast ? Packet.PING : Packet.MESSAGE, packet.Type);
+                    return true;
+                }
+            }
+
+        }
+
+        [Fact]
+        public void EncodeAndDecodePayloads2()
+        {
+            var packets = new Packet[] {new Packet(Packet.MESSAGE, "a"), new Packet(Packet.PING),};
+            Parser.EncodePayload(packets, new EncodeAndDecodePayloads_EncodeCallback2());
+
+        }
+
+        public class EncodeAndDecodeEmptyPayloads_EncodeCallback : IEncodeCallback
+        {
+            public void Call(object data)
+            {
+                Parser.DecodePayload((byte[]) data, new EncodeAndDecodeEmptyPayloads_DecodeCallback());
+            }
+
+            public class EncodeAndDecodeEmptyPayloads_DecodeCallback : IDecodePayloadCallback
+            {
+
+                public bool Call(Packet packet, int index, int total)
+                {
+                    Assert.Equal(Packet.OPEN, packet.Type);
+                    var isLast = index + 2 == total;
+                    Assert.True(isLast);
+                    return true;
+                }
+            }
+
+        }
+
+        [Fact]
+        public void EncodeAndDecodeEmptyPayloads()
+        {
+            var packets = new Packet[] {};
+            Parser.EncodePayload(packets, new EncodeAndDecodeEmptyPayloads_EncodeCallback());
+
+        }
+
+
+        public class EncodeAndDecodeBinaryContents_EncodeCallback : IEncodeCallback
+        {
+            public void Call(object data)
+            {
+                Parser.DecodePayload((byte[]) data, new EncodeAndDecodeBinaryContents_DecodeCallback());
+            }
+
+            public class EncodeAndDecodeBinaryContents_DecodeCallback : IDecodePayloadCallback
+            {
+
+                public bool Call(Packet packet, int index, int total)
+                {
+                    Assert.Equal(Packet.MESSAGE, packet.Type);
+                    var isLast = index + 1 == total;
+                    if (!isLast)
+                    {
+                        Assert.Equal(FirstBuffer(), packet.Data);
+                    }
+                    else
+                    {
+                        Assert.Equal(SecondBuffer(), packet.Data);
+                    }
+                    return true;
+                }
+            }
+
+        }
+
+        [Fact]
+        public void EncodeAndDecodeBinaryContents()
+        {
+            var firstBuffer = FirstBuffer();
+            var secondBuffer = SecondBuffer();
+
+            var packets = new Packet[]
+            {new Packet(Packet.MESSAGE, firstBuffer), new Packet(Packet.MESSAGE, secondBuffer)};
+            Parser.EncodePayload(packets, new EncodeAndDecodeBinaryContents_EncodeCallback());
+
+        }
+
+        private static byte[] SecondBuffer()
+        {
+            var secondBuffer = new byte[4];
+            for (int i = 0; i < secondBuffer.Length; i++)
+            {
+                secondBuffer[i] = (byte) (5 + i);
+            }
+            return secondBuffer;
+        }
+
+        private static byte[] FirstBuffer()
+        {
+            var firstBuffer = new byte[5];
+            for (int i = 0; i < firstBuffer.Length; i++)
+            {
+                firstBuffer[i] = (byte) i;
+            }
+            return firstBuffer;
+        }
+
+        private static byte[] ThirdBuffer()
+        {
+            var result = new byte[123];
+            for (int i = 0; i < result.Length; i++)
+            {
+                result[i] = (byte) i;
+            }
+            return result;
+        }
+
+
+        public class EncodeMixedBinaryAndStringContents_EncodeCallback : IEncodeCallback
+        {
+
+            public void Call(object data)
+            {
+                Parser.DecodePayload((byte[]) data, new EncodeMixedBinaryAndStringContents_DecodeCallback());
+            }
+
+            public class EncodeMixedBinaryAndStringContents_DecodeCallback : IDecodePayloadCallback
+            {
+
+                public bool Call(Packet packet, int index, int total)
+                {
+                    if (index == 0)
+                    {
+                        Assert.Equal(Packet.MESSAGE, packet.Type);
+                        Assert.Equal(ThirdBuffer(), packet.Data);
+                    }
+                    else if (index == 1)
+                    {
+                        Assert.Equal(Packet.MESSAGE, packet.Type);
+                        Assert.Equal("hello", packet.Data);
+                    }
+                    else
+                    {
+                        Assert.Equal(Packet.CLOSE, packet.Type);
+                    }
+                    return true;
+                }
+            }
+
+        }
+
+        [Fact]
+        public void EncodeMixedBinaryAndStringContents()
+        {
+            var packets = new Packet[]
+            {
+                new Packet(Packet.MESSAGE, ThirdBuffer()),
+                new Packet(Packet.MESSAGE, "hello"),
+                new Packet(Packet.CLOSE),
+            };
+            Parser.EncodePayload(packets, new EncodeMixedBinaryAndStringContents_EncodeCallback());
+
+        }
+
+    }
+}

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/Properties/AssemblyInfo.cs

@@ -0,0 +1,35 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("EngineIoClientDotNet")]
+[assembly: AssemblyDescription("Engine.IO Client Library for .Net")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Quobject Software")]
+[assembly: AssemblyProduct("EngineIoClientDotNet")]
+[assembly: AssemblyCopyright("Copyright ©  2014")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("a95e75cd-35e6-4e88-9e22-631e3fd01546")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("0.9.4")]
+[assembly: AssemblyFileVersion("0.9.4")]

ThirdParty/EngineIoClientDotNet/Src/EngineIoClientDotNet.Tests.mono/packages.config

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Microsoft.NETCore.Platforms" version="1.1.0" targetFramework="net45" />
+  <package id="NETStandard.Library" version="1.6.1" targetFramework="net45" />
+  <package id="Newtonsoft.Json" version="10.0.1" targetFramework="net45" />
+  <package id="SuperSocket.ClientEngine.Core" version="0.8.0.8" targetFramework="net45" />
+  <package id="System.Collections" version="4.3.0" targetFramework="net45" />
+  <package id="System.Collections.Concurrent" version="4.3.0" targetFramework="net45" />
+  <package id="System.Diagnostics.Debug" version="4.3.0" targetFramework="net45" />
+  <package id="System.Diagnostics.Tools" version="4.3.0" targetFramework="net45" />
+  <package id="System.Diagnostics.Tracing" version="4.3.0" targetFramework="net45" />
+  <package id="System.Globalization" version="4.3.0" targetFramework="net45" />
+  <package id="System.IO" version="4.3.0" targetFramework="net45" />
+  <package id="System.IO.Compression" version="4.3.0" targetFramework="net45" />
+  <package id="System.Linq" version="4.3.0" targetFramework="net45" />
+  <package id="System.Linq.Expressions" version="4.3.0" targetFramework="net45" />
+  <package id="System.Net.Http" version="4.3.1" targetFramework="net45" />
+  <package id="System.Net.Primitives" version="4.3.0" targetFramework="net45" />
+  <package id="System.ObjectModel" version="4.3.0" targetFramework="net45" />
+  <package id="System.Reflection" version="4.3.0" targetFramework="net45" />
+  <package id="System.Reflection.Extensions" version="4.3.0" targetFramework="net45" />
+  <package id="System.Reflection.Primitives" version="4.3.0" targetFramework="net45" />
+  <package id="System.Resources.ResourceManager" version="4.3.0" targetFramework="net45" />
+  <package id="System.Runtime" version="4.3.0" targetFramework="net45" />
+  <package id="System.Runtime.Extensions" version="4.3.0" targetFramework="net45" />
+  <package id="System.Runtime.InteropServices" version="4.3.0" targetFramework="net45" />
+  <package id="System.Runtime.InteropServices.RuntimeInformation" version="4.3.0" targetFramework="net45" />
+  <package id="System.Runtime.Numerics" version="4.3.0" targetFramework="net45" />
+  <package id="System.Text.Encoding" version="4.3.0" targetFramework="net45" />
+  <package id="System.Text.Encoding.Extensions" version="4.3.0" targetFramework="net45" />
+  <package id="System.Text.RegularExpressions" version="4.3.0" targetFramework="net45" />
+  <package id="System.Threading" version="4.3.0" targetFramework="net45" />
+  <package id="System.Threading.Tasks" version="4.3.0" targetFramework="net45" />
+  <package id="System.Xml.ReaderWriter" version="4.3.0" targetFramework="net45" />
+  <package id="System.Xml.XDocument" version="4.3.0" targetFramework="net45" />
+  <package id="WebSocket4Net" version="0.15.0-beta6" targetFramework="net45" />
+  <package id="xunit" version="2.2.0" targetFramework="net45" />
+  <package id="xunit.abstractions" version="2.0.1" targetFramework="net45" />
+  <package id="xunit.assert" version="2.2.0" targetFramework="net45" />
+  <package id="xunit.core" version="2.2.0" targetFramework="net45" />
+  <package id="xunit.extensibility.core" version="2.2.0" targetFramework="net45" />
+  <package id="xunit.extensibility.execution" version="2.2.0" targetFramework="net45" />
+</packages>