public void Messages()
        {
            var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
            log.Info("Start");
            _manualResetEvent = new ManualResetEvent(false);

            var events = new ConcurrentQueue<string>();

            var socket = new Socket(CreateOptionsSecure());
            socket.On(Socket.EVENT_OPEN, () =>
            {
                log.Info("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);
        }
        public void ReceiveBinaryData()
        {
            var log = LogManager.GetLogger(Global.CallerName());
            log.Info("Start");
            _manualResetEvent = new ManualResetEvent(false);

            var events = new Queue<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.Send("why");
            });

            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();

            var binaryData2 = new byte[5];
            for (int i = 0; i < binaryData.Length; i++)
            {
                binaryData2[i] = (byte) (i + 1);
            }

            object result = events.Dequeue();
            if (result is string)
            {
                log.Info(result as string);
            }
            CollectionAssert.AreEqual(binaryData, (byte[]) result);
        }
        public void ReceiveBinaryData()
        {
            var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
            log.Info("Start");
            _manualResetEvent = new ManualResetEvent(false);

            var events = new Queue<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;
            result = events.Dequeue();
            Assert.Equal(binaryData, result);
        }
        public void ReceiveBinaryData()
        {
            LogManager.SetupLogManager();
            var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
            log.Info("Start");
            this._autoResetEvent = new AutoResetEvent(false);

            var events = new Queue<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, () =>
            {

                log.Info("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);
                    this._autoResetEvent.Set();
                });
                socket.Send(binaryData);
                //socket.Send("cash money €€€");
            });

            socket.Open();
            this._autoResetEvent.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;
            result = events.Dequeue();
            CollectionAssert.AreEqual(binaryData, (byte[])result);
        }
        public void Usage1()
        {
            var log = LogManager.GetLogger(Global.CallerName());
            log.Info("Start");

            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));
        }
        public void Usage1()
        {
            LogManager.SetupLogManager();
            var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
            log.Info("Start");

            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));
        }
        public void Cookie()
        {
            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");
            var socket = new Socket(options);
            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);
        }
        public void Testemoji()
        {

            var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
            log.Info("Start");
            _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);

        }
        public void TestmultibyteUtf8StringsWithPolling()
        {

            var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
            log.Info("Start");
            _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);
        }
        public void ReceiveBinaryDataAndMultibyteUTF8String()
        {
            var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
            log.Info("Start");
            _manualResetEvent = new ManualResetEvent(false);

            var events = new Queue<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 = new List<string>() { "polling" };

            var socket = new Socket(options);

            socket.On(Socket.EVENT_OPEN, () =>
            {

                log.Info("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;
            result = events.Dequeue();
            Assert.Equal(binaryData, result);
            result = events.Dequeue();
            Assert.Equal(stringData, (string) result);
            socket.Close();
        }
        public void UpgradeCookie()
        {
            var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
            log.Info("Start");
            _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);
        }
        public void Testemoji()
        {

            var log = LogManager.GetLogger(Global.CallerName());
            log.Info("Start");
            _manualResetEvent = new ManualResetEvent(false);

            const string SendMessage = "\uD800-\uDB7F\uDB80-\uDBFF\uDC00-\uDFFF\uE000-\uF8FF";


            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(Socket.EVENT_MESSAGE);

                if (data == "hi")
                {
                    return;
                }

                this.Message = data;
	            _manualResetEvent.Set();
            });

            socket.Open();
	        _manualResetEvent.WaitOne();		
            socket.Close();
            Assert.AreEqual(SendMessage , this.Message);

        }
        public void TestmultibyteUtf8StringsWithPolling()
        {

            var log = LogManager.GetLogger(Global.CallerName());
            log.Info("Start");
            _manualResetEvent = new ManualResetEvent(false);

            const string SendMessage = "cash money €€€";

            //socket = new Socket(CreateOptions());

            var options = CreateOptions();
            options.Transports = ImmutableList.Create<string>(Polling.NAME);
            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("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.AreEqual(SendMessage, this.Message);
        }
        public void Messages()
        {
            var log = LogManager.GetLogger(Global.CallerName());
            log.Info("Start");
            //Setting the event to false.
            _manualResetEvent = new ManualResetEvent(false);

            var events = new Queue<string>();

            var socket = new Socket(CreateOptionsSecure());
            socket.On(Socket.EVENT_OPEN, () =>
            {
                log.Info("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)
                {
                    log.Info("EVENT_MESSAGE 2");
                    _manualResetEvent.Set();
                }
            });
            socket.Open();
            //await Task.Delay(4000);
            _manualResetEvent.WaitOne();
            socket.Close();

            string result;
            result = events.Dequeue();
            Assert.AreEqual("hi", result);
            result = events.Dequeue();
            Assert.AreEqual("hello", result);
        }
        public void Messages()
        {
            LogManager.SetupLogManager();
            var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
            log.Info("Start");
            //Setting the event to false.
            this._autoResetEvent = new AutoResetEvent(false);

            var events = new Queue<string>();

            var socket = new Socket(CreateOptionsSecure());
            socket.On(Socket.EVENT_OPEN, () =>
            {
                log.Info("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)
                {
                    log.Info("EVENT_MESSAGE 2");
                    this._autoResetEvent.Set();
                }
            });
            socket.Open();
            this._autoResetEvent.WaitOne();
            //await Task.Delay(4000);
            socket.Close();

            string result;
            result = events.Dequeue();
            Assert.AreEqual("hi", result);
            result = events.Dequeue();
            Assert.AreEqual("hello", result);
        }
        static void Main(string[] args) {
            Socket.Options opts = new Socket.Options();
            opts.Path = "live.eio";
            opts.Port = 443;
            opts.PolicyPort = 843;
            opts.Secure = true;
            opts.Hostname = "ws.www.livecoding.tv";
            opts.Transports = ImmutableList.Create<string>("websocket");

            Socket socket = new Socket("www.livecoding.tv", opts);
            socket.On("connect", (fn) => {
                Console.WriteLine(TimeStamp() + "\r\nConnected event...\r\n");
            }); 
            
            socket.On("update", (data) => {
                Console.WriteLine(TimeStamp() + "recv [socket].[update] event");
                Console.WriteLine(TimeStamp() + "recv [socket].[update] data: " + data);
            }); 
            
            socket.On("message", (data) => {
                Console.WriteLine(TimeStamp() + "recv [socket].[message] event");
                string message = ""; //= Encoding.UTF8.GetString((byte[])data);
                if (data.GetType() == typeof(string)) {
                    message = (string)data;
                } else if (data.GetType() == typeof(byte[])) {
                    message = Encoding.UTF8.GetString((byte[])data);
                } else {
                    message = data.ToString();
                }
                Console.WriteLine(TimeStamp() + "recv [socket].[message] data: " + message);
            }); 
            
            socket.On("open", (data) => { 
                string json = @"['join','stream.callumc']";
                json = json.Replace("'", "\"");
                Console.WriteLine(TimeStamp() + "CONNECTED (" + data + "), sending channels : " + json);
                socket.Send(Encoding.UTF8.GetBytes(json));
            });

            socket.On(Socket.EVENT_ERROR, (data) => {
                EngineIOException exception = (EngineIOException)(data);
                Console.WriteLine(TimeStamp() + "Could not connect " + exception.StackTrace); 
            });


            socket.On("noop", (data) => {
                Console.WriteLine(TimeStamp() + "Noop: " + data);
            });

            socket.On(Socket.EVENT_HANDSHAKE, (data) => { Console.WriteLine(TimeStamp() + "Connection Handshake : " + data); });
            socket.On(Socket.EVENT_HEARTBEAT, () => { Console.WriteLine(TimeStamp() + "HeartBeat"); });
            socket.On(Socket.EVENT_OPEN, () => { Console.WriteLine(TimeStamp() + "SOCKET OPENED"); });
            socket.On(Socket.EVENT_CLOSE, () => { Console.WriteLine(TimeStamp() + "SOCKET CLOSED"); });
            socket.On(Socket.EVENT_HANDSHAKE, () => { Console.WriteLine(TimeStamp() + "SOCKET HANDSHAKE"); });
            socket.On(Socket.EVENT_PACKET, (data) => { 
                Quobject.EngineIoClientDotNet.Parser.Packet packet = ((Quobject.EngineIoClientDotNet.Parser.Packet)data);
                Console.WriteLine(TimeStamp() + "SOCKET PACKET  " + packet.Type); 
            });
            socket.On(Socket.EVENT_UPGRADE, () => { Console.WriteLine(TimeStamp() + "SOCKET UPGRADE"); });
            socket.On(Socket.EVENT_DRAIN, () => { Console.WriteLine(TimeStamp() + "SOCKET DRAINED"); });
            socket.On(Socket.EVENT_FLUSH, () => { Console.WriteLine(TimeStamp() + "SOCKET FLUSHED"); });
            socket.On(Socket.EVENT_PACKET_CREATE, () => { Console.WriteLine(TimeStamp() + "SOCKET PACKET CREATED"); });
            socket.On(Socket.EVENT_TRANSPORT, (dat) => { Console.WriteLine(TimeStamp() + "SOCKET TRANSPORT"); });
            socket.Open();

            do { } while (true);
        }