diff --git a/README.md b/README.md
index b8c29e8..171b84b 100644
--- a/README.md
+++ b/README.md
@@ -8,8 +8,8 @@
     <a href="https://www.nuget.org/packages/WebsocketRPC.AspCore/"> <img src="https://img.shields.io/badge/WebSokcetRPC.AspCore-v1.x-blue.svg?style=flat-square" alt="NuGet packages version"/>  </a>
 </p>
 
-**WebSokcetRPC** - RPC over weboskcets for .NET    
-Leightweight .NET framework for making RPC over websockets. Supports full duplex connections; .NET or Javascript clients. 
+**WebSokcetRPC** - RPC over websocket for .NET    
+Lightweight .NET framework for making RPC over websockets. Supports full duplex connections; .NET or Javascript clients. 
 
 <!--
  > **Tutorial:** <a href="https://www.codeproject.com/Articles/0000/Introducing-Leightweight-WebSocket-RPC-library" target="_blank">CodeProject article</a>
@@ -22,50 +22,178 @@ Leightweight .NET framework for making RPC over websockets. Supports full duplex
 The only dependency is <a href="https://www.newtonsoft.com/json">JSON.NET</a> library used for serialization/deserialization.
 
 + **Simple**   
-There is only one relevant method: **Bind** for binding object/interface onto connection, and **CallAsync** for calling RPCs.
+There are two relevant method: **Bind** for binding object/interface onto connection, and **CallAsync** for making RPCs.
 
 + **Use 3rdParty assemblies as API(s)**   
 Implemented API, if used only for RPC, does not use anything from the library.
 
-+ **Automatic Javascript code generation** *(WebsocketRPC.JS package)*  
- Javascript websokcet client code is automatically generated **_(with JsDoc comments)_** from an existing .NET
++ **Automatic Javascript code generation** *(WebSocketRPC.JS package)*  
+ Javascript websocket client code is automatically generated **_(with JsDoc comments)_** from an existing .NET
                         interface (API contract).
 
  
-## Sample
+## <a href="Samples/"> Samples</a>
 
-To scratch the surface... *(RPC in both directions, multi-service, .NET clients)*
+Check the samples by following the link above. The snippets below demonstrate the base functionality.
 
-**Server**
+#### 1) .NET <-> .NET (raw messaging)
+The sample demonstrates communication between server and client using raw messaging. The server relays client messages.
+
+**Server** (C#)
+ ``` csharp
+Server.ListenAsync("http://localhost:8000/", CancellationToken.None, (c, wc) => 
+{
+    c.OnOpen  += ()                    => Task.Run(() => Console.WriteLine("Opened"));
+    c.OnClose += (status, description) => Task.Run(() => Console.WriteLine("Closed: " + description));
+    c.OnError += ex                    => Task.Run(() => Console.WriteLine("Error: " + ex.Message));     
+
+    c.OnReceive += msg                 => await c.SendAsync("Received: " + msg); //relay message
+})
+.Wait(0);
+ ``` 
+
+ **Client** (C#)
+  ``` csharp
+Client.ListenAsync("ws://localhost:8000/", CancellationToken.None, c => 
+{
+      c.OnOpen += () => await c.SendAsync("Hello from a client");
+},
+reconnectOnError: true)
+.Wait(0);
+ ```
+{empty} . 
+
+
+#### 2) .NET <-> .NET (RPC)
+A data aggregator service is built. The server gets the multiple number sequences of each client and sums all the numbers.  
+The procedure is repeated for each new client connection.
+
+**Server** (C#)
+ ``` csharp
+//client API contract
+interface IClientAPI
+{
+    int[] GetLocalNumbers();
+}
+
+....
+async Task WriteTotalSum()
+{  
+    //get all the clients (notice there is no 'this' (the sample above))
+    var clients = RPC.For<IClientAPI>();
+
+    //get the numbers sequences
+    var numberGroups = await clients.CallAsync(x => x.GetLocalNumbers());
+    //flatten the collection and sum all the elements
+    var sum = numberGroups.SelectMany(x => x).Sum();
+
+    Console.WriteLine("Client count: {0}; sum: {1}.", clients.Count(), sum);
+}
+
+//run server
+Server.ListenAsync("http://localhost:8000/", CancellationToken.None, 
+                   (c, wc) => 
+                   { 
+                       c.Bind<IClientAPI>();
+                       c.OnOpen += WriteTotalSum;
+                   })
+                   .Wait(0);
+
+/*
+Output: 
+   Client count: 1; sum: 4.
+   Client count: 3; sum: 14.
+   ...
+*/
+ ``` 
+ 
+**Client** (C#)
+``` csharp
+//client API
+class ClientAPI
+{
+    int[] GetLocalNumbers()
+    {
+       var r = new Random();
+      
+       var numbers = new int[10];
+       for(var i = 0; i < numbers.Length; i++)
+          numbers[i] = r.Next();
+
+       return numbers;
+    }
+}
+
+....
+//run client
+Client.ListenAsync("ws://localhost:8000/", CancellationToken.None, 
+                   c => c.Bind(new ClientAPI())).Wait(0);
+ ``` 
+{empty} .  
+
+#### 3) .NET <-> Javascript (RPC)
+Simple math service is built and invoked remotely. The math service has a single long running method which adds two numbers (server side).
+Client calls the method and receives progress update until the result does not become available.
+
+**Server** (C#)
  ``` csharp
+//client API contract
+interface IReportAPI
+{
+    void WriteProgress(int progress);
+}
+
+//server API
 class MathAPI
 {
     public async Task<int> LongRunningTask(int a, int b)
     {
-        await Task.Delay(250);
+        for (var p = 0; p <= 100; p += 5)
+        {
+            await Task.Delay(250);
+            //update only the client which called this method (hence 'this')
+            await RPC.For<IReportAPI>(this).CallAsync(x => x.WriteProgress(p));
+        }
+
         return a + b;
     }
 }
 
 ....
-//generate js code
+//generate js code with JsDoc documentation taken from XML comments (if any)
 File.WriteAllText("MathAPI.js", RPCJs.GenerateCallerWithDoc<MathAPI>());
 //run server
 Server.ListenAsync("http://localhost:8000/", CancellationToken.None, 
-                    (c, wc) => c.Bind<MathAPI>(new MathAPI())).Wait(0);
+                    (c, wc) => c.Bind<MathAPI, IReportAPI>(new MathAPI())).Wait(0);
  ``` 
 
- **Client**
+ **Client** (Javascript)
   ``` javascript
+//init 'MathAPI'
 var api = new MathAPI("ws://localhost:8000");
+//implement the 'IReportAPI'
+api.writeProgress = p => console.log("Progress: " + p + "%");
+
+//connect to the server and call the remote function
 api.connect(async () => 
 {
     var r = await api.longRunningTask(5, 3);
     console.log("Result: " + r);
 });
+
+/*
+  Output: 
+     Progress: 0 %
+     Progress: 5 %
+     Progress: 10 %
+     ...
+     Result: 8
+*/
  ``` 
   
- 
+{empty} .  
+
+
 ## Getting started
 + Samples
 <!--
diff --git a/Samples/ClientJs/Site/Index.html b/Samples/ClientJs/Site/Index.html
index f4e6b2b..ebcb1c7 100644
--- a/Samples/ClientJs/Site/Index.html
+++ b/Samples/ClientJs/Site/Index.html
@@ -23,7 +23,7 @@
             var api = new LocalAPI("ws://localhost:8001");
 
             //implement the interface
-            api.writeProgress = function (p)
+            api.writeProgress = p =>
             {
                 document.getElementById("progress").innerHTML = "Completed: " + p * 100 + "%";
             }
diff --git a/Samples/README.md b/Samples/README.md
index d8985a0..8311c2f 100644
--- a/Samples/README.md
+++ b/Samples/README.md
@@ -5,7 +5,7 @@ The recommendation is to run samples in the following order (from the more simpl
 
 1. **RawMsgJs**  
     Javascript client and C# server.    
-    Sending/receiving raw text mesages.  
+    Sending/receiving raw text messages.  
     *Server is receiving messages form a client and sends back altered messages.*
 
 2. **ServerClientSample/++**  
diff --git a/Samples/RawMsgJs/Program.cs b/Samples/RawMsgJs/Program.cs
index a495107..a114a36 100644
--- a/Samples/RawMsgJs/Program.cs
+++ b/Samples/RawMsgJs/Program.cs
@@ -22,7 +22,7 @@ static void Main(string[] args)
 
             //generate js code
             File.WriteAllText($"./Site/{nameof(MessagingAPI)}.js", RPCJs.GenerateCaller<MessagingAPI>());
-          
+
             //start server
             var cts = new CancellationTokenSource();
             var t = Server.ListenAsync("http://localhost:8001/", cts.Token, (c, ws) =>
@@ -31,9 +31,9 @@ static void Main(string[] args)
                 c.BindTimeout(TimeSpan.FromSeconds(30));
 
                 c.OnOpen += async () => await c.SendAsync("Hello from server using WebSocketRPC");
-                c.OnClose += () => { Console.WriteLine("Connection closed."); return Task.FromResult(true); };
-                c.OnError += e => { Console.WriteLine("Error: " + e.Message); return Task.FromResult(true); };
-                
+                c.OnClose += (s, d)  => Task.Run(() => Console.WriteLine("Connection closed: " + d));
+                c.OnError += e       => Task.Run(() => Console.WriteLine("Error: " + e.Message));
+
                 c.OnReceive += async msg =>
                 {
                     Console.WriteLine("Received: " + msg);
diff --git a/Samples/ServerClientSample/Client/Program.cs b/Samples/ServerClientSample/Client/Program.cs
index 2c8abcf..10188f2 100644
--- a/Samples/ServerClientSample/Client/Program.cs
+++ b/Samples/ServerClientSample/Client/Program.cs
@@ -40,7 +40,8 @@ static void Main(string[] args)
                     var r = await RPC.For<ILocalAPI>().CallAsync(x => x.LongRunningTask(5, 3));
                     Console.WriteLine("\nResult: " + r.First());
                 };
-            });
+            }, 
+            reconnectOnError: true);
 
             Console.Write("{0} ", nameof(TestClient));
             AppExit.WaitFor(cts, t);
diff --git a/Samples/ServerClientSample/Run.bat b/Samples/ServerClientSample/Run.bat
index 85a42b0..2a43320 100644
--- a/Samples/ServerClientSample/Run.bat
+++ b/Samples/ServerClientSample/Run.bat
@@ -1,5 +1,5 @@
 set serverApp = "Server\bin\Server.exe"
-set clientApp = "Server\bin\Client.exe"
+set clientApp = "Client\bin\Client.exe"
 
 if NOT EXIST %serverApp% (
   echo Build 'Server' project first.
diff --git a/Samples/ServerClientSample/Server/Program.cs b/Samples/ServerClientSample/Server/Program.cs
index 3e5814d..1ca563a 100644
--- a/Samples/ServerClientSample/Server/Program.cs
+++ b/Samples/ServerClientSample/Server/Program.cs
@@ -1,5 +1,6 @@
 using SampleBase;
 using System;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using WebSocketRPC;
@@ -30,15 +31,27 @@ public class Program
         //if access denied execute: "netsh http delete urlacl url=http://+:8001/" (delete for 'localhost', add for public address)
         static void Main(string[] args)
         {
-            Console.ForegroundColor = ConsoleColor.Red;
+            Console.ForegroundColor = ConsoleColor.Yellow;
             Console.WriteLine("Server\n");
 
             //start server and bind to its local and remote API
             var cts = new CancellationTokenSource();
-            var t = Server.ListenAsync("http://localhost:8001/", cts.Token, (c, wc) => c.Bind<LocalAPI, IRemoteAPI>(new LocalAPI()));
+            var t = Server.ListenAsync("http://localhost:8001/", cts.Token, (c, wc) =>
+            {
+                c.Bind<LocalAPI, IRemoteAPI>(new LocalAPI());
+
+                c.OnOpen  += () => Task.Run((Action)writeClientCount);
+                c.OnClose += (s, d) => Task.Run((Action)writeClientCount);
+            });
 
             Console.Write("{0} ", nameof(TestServer));
             AppExit.WaitFor(cts, t);
         }
+
+        static void writeClientCount()
+        {
+            var cc = RPC.For<IRemoteAPI>().Count();
+            Console.WriteLine("Client count: " + cc);
+        }
     }
 }
diff --git a/Source/WebSocketRPC.Base/ClientServer/Client.cs b/Source/WebSocketRPC.Base/ClientServer/Client.cs
index 29bec71..b966028 100644
--- a/Source/WebSocketRPC.Base/ClientServer/Client.cs
+++ b/Source/WebSocketRPC.Base/ClientServer/Client.cs
@@ -41,13 +41,15 @@ public static class Client
         /// <param name="uri">The target uri of the format: "ws://(address)/[path]".</param>
         /// <param name="token">Cancellation token.</param>
         /// <param name="onConnect">Action executed when connection is established.</param>
-        /// <param name="reconnectOnError">True to reconnect on error, false otherwise.</param>
+        /// <param name="reconnectOnError">True to reconnect on error, false otherwise.
+        /// <para>If true, exceptions will not be thrown. Set to false when debugging.</para>
+        /// </param>
         /// <param name="reconnectOnClose">True to reconnect on normal close request, false otherwise.</param>
         /// <param name="secondsBetweenReconnect">The number of seconds between two reconnect attempts.</param>
         /// <param name="setOptions">Websocket option set method.</param>
         /// <returns>Client task.</returns>
         /// <exception cref="Exception">Socket connection exception thrown in case when <paramref name="reconnectOnError"/> and <paramref name="reconnectOnClose"/> is set to false.</exception>
-        public static async Task ConnectAsync(string uri, CancellationToken token, Action<Connection> onConnect, bool reconnectOnError = true,
+        public static async Task ConnectAsync(string uri, CancellationToken token, Action<Connection> onConnect, bool reconnectOnError = false,
                                               bool reconnectOnClose = false, int secondsBetweenReconnect = 0, Action<ClientWebSocketOptions> setOptions = null)
         {
             var isClosedSuccessfully = true;
diff --git a/Source/WebSocketRPC.Base/ClientServer/Connection.cs b/Source/WebSocketRPC.Base/ClientServer/Connection.cs
index 53f95f6..4c85b85 100644
--- a/Source/WebSocketRPC.Base/ClientServer/Connection.cs
+++ b/Source/WebSocketRPC.Base/ClientServer/Connection.cs
@@ -73,7 +73,7 @@ public static Encoding Encoding
             }
         }
 
-        static string messageToBig = "The message exceeds the maximum allowed message size: {0} bytes.";
+        static string messageToBig = "The message exceeds the maximum allowed message size: {0} of allowed {1} bytes.";
 
         #endregion
 
@@ -97,6 +97,11 @@ internal protected Connection(WebSocket socket, IReadOnlyDictionary<string, stri
         /// </summary>
         public IReadOnlyDictionary<string, string> Cookies { get; private set; }
 
+        /// <summary>
+        /// Gets whether the connection is opened or not.
+        /// </summary>
+        public bool IsAlive => socket?.State == WebSocketState.Open;
+
         #region Events
 
         /// <summary>
@@ -110,7 +115,7 @@ internal protected Connection(WebSocket socket, IReadOnlyDictionary<string, stri
         /// <summary>
         /// Close event.
         /// </summary>
-        public event Func<Task> OnClose;
+        public event Func<WebSocketCloseStatus, string, Task> OnClose;
         /// <summary>
         /// Error event Args: exception.
         /// </summary>
@@ -170,16 +175,16 @@ private void invokeOnReceive(string msg)
             { }
         }
 
-        private void invokeOnClose()
+        private void invokeOnClose(WebSocketCloseStatus closeStatus, string statusDescription)
         {
             if (OnClose == null)
                 return;
 
             try
             {
-                var members = OnClose.GetInvocationList().Cast<Func<Task>>();
+                var members = OnClose.GetInvocationList().Cast<Func< WebSocketCloseStatus, string, Task >>();
 
-                Task.WhenAll(members.Select(x => x()))
+                Task.WhenAll(members.Select(x => x(closeStatus, statusDescription)))
                     .ContinueWith(t => InvokeOnError(t.Exception), TaskContinuationOptions.OnlyOnFaulted)
                     .Wait(0);
             }
@@ -207,7 +212,8 @@ public async Task<bool> SendAsync(string data)
             var bData = Encoding.GetBytes(data);
             if (bData.Length >= MaxMessageSize)
             {
-                await CloseAsync(WebSocketCloseStatus.MessageTooBig, String.Format(messageToBig, MaxMessageSize));
+                //InvokeOnError(new NotSupportedException(String.Format(messageToBig, maxMessageSize)));
+                await CloseAsync(WebSocketCloseStatus.MessageTooBig, String.Format(messageToBig, bData.Length, maxMessageSize));
                 return false;
             }
 
@@ -256,7 +262,7 @@ public async Task CloseAsync(WebSocketCloseStatus closeStatus = WebSocketCloseSt
             }
             finally
             {
-                invokeOnClose();
+                invokeOnClose(closeStatus, statusDescription);
                 clearEvents();
             }
         }
@@ -312,7 +318,8 @@ async Task listenReceiveAsync(CancellationToken token)
 
                     if (count >= maxMessageSize)
                     {
-                        await CloseAsync(WebSocketCloseStatus.MessageTooBig, String.Format(messageToBig, maxMessageSize));
+                        //InvokeOnError(new NotSupportedException(String.Format(messageToBig, maxMessageSize)));
+                        await CloseAsync(WebSocketCloseStatus.MessageTooBig, String.Format(messageToBig, count, maxMessageSize));
                         return;
                     }
                 }
diff --git a/Source/WebSocketRPC.Base/Features/TimeoutBinder.cs b/Source/WebSocketRPC.Base/Features/TimeoutBinder.cs
index be446d9..2a8c736 100644
--- a/Source/WebSocketRPC.Base/Features/TimeoutBinder.cs
+++ b/Source/WebSocketRPC.Base/Features/TimeoutBinder.cs
@@ -63,7 +63,7 @@ public static void BindTimeout(this Connection connection, TimeSpan timeout, str
             var binder = new TimeoutBinder(connection, timeout, closeMessage);
 
             lock (timeoutBinders) timeoutBinders.Add(binder);
-            connection.OnClose += () => 
+            connection.OnClose += (s, d) => 
             {
                 lock (timeoutBinders) timeoutBinders.Remove(binder);
                 return Task.FromResult(true);
diff --git a/Source/WebSocketRPC.Base/Invokers/RemoteInvoker.cs b/Source/WebSocketRPC.Base/Invokers/RemoteInvoker.cs
index f64f0ef..603312f 100644
--- a/Source/WebSocketRPC.Base/Invokers/RemoteInvoker.cs
+++ b/Source/WebSocketRPC.Base/Invokers/RemoteInvoker.cs
@@ -31,7 +31,6 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Collections.Concurrent;
-using System.Threading;
 
 namespace WebSocketRPC
 {
diff --git a/Source/WebSocketRPC.Base/RPC.cs b/Source/WebSocketRPC.Base/RPC.cs
index 7fcc8b0..4f94eb7 100644
--- a/Source/WebSocketRPC.Base/RPC.cs
+++ b/Source/WebSocketRPC.Base/RPC.cs
@@ -270,20 +270,6 @@ public static async Task<TResult[]> CallAsync<TInterface, TResult>(this IEnumera
 
         #region Misc
 
-        /// <summary>
-        /// Gets the connection count.
-        /// </summary>
-        public static int ConnectionCount
-        {
-            get
-            {
-                return AllBinders.ToArray()
-                                 .Select(x => x.Connection)
-                                 .Distinct()
-                                 .Count();
-            }
-        }
-
         /// <summary>
         /// Gets whether the data contain RPC message or not.
         /// </summary>
diff --git a/Source/WebSocketRPC.Base/RpcBinders/Base/Binder.cs b/Source/WebSocketRPC.Base/RpcBinders/Base/Binder.cs
index 3853577..ceb0630 100644
--- a/Source/WebSocketRPC.Base/RpcBinders/Base/Binder.cs
+++ b/Source/WebSocketRPC.Base/RpcBinders/Base/Binder.cs
@@ -38,7 +38,7 @@ protected Binder(Connection connection)
             Connection = connection;
             lock(RPC.AllBinders) RPC.AllBinders.Add(this);
 
-            Connection.OnClose += () =>
+            Connection.OnClose += (s, d) =>
             {
                 Debug.WriteLine("Close");
 
diff --git a/Source/WebSocketRPC.Base/RpcBinders/LocalBinder.cs b/Source/WebSocketRPC.Base/RpcBinders/LocalBinder.cs
index 259c284..c4d9ef5 100644
--- a/Source/WebSocketRPC.Base/RpcBinders/LocalBinder.cs
+++ b/Source/WebSocketRPC.Base/RpcBinders/LocalBinder.cs
@@ -47,7 +47,7 @@ public LocalBinder(Connection connection, TObj obj)
                 await Connection.SendAsync(result.ToJson());
             };
 
-            Connection.OnClose += () =>
+            Connection.OnClose += (s, d) =>
             {
                 try { (Object as IDisposable)?.Dispose(); }
                 catch (Exception ex) { Connection.InvokeOnError(ex); }
diff --git a/Source/WebSocketRPC.Base/Utils/CookieUtils.cs b/Source/WebSocketRPC.Base/Utils/CookieUtils.cs
index ae67d14..309065d 100644
--- a/Source/WebSocketRPC.Base/Utils/CookieUtils.cs
+++ b/Source/WebSocketRPC.Base/Utils/CookieUtils.cs
@@ -3,7 +3,7 @@
 
 namespace WebSocketRPC
 {
-    internal static class CookieUtils
+    static class CookieUtils
     {
         public static Dictionary<string, string> GetCookies(CookieCollection cookieCollection)
         {
diff --git a/Tests/ConcurencyTests/ConcurencyTests.cs b/Tests/ConcurencyTests/ConcurencyTests.cs
new file mode 100644
index 0000000..985c0d2
--- /dev/null
+++ b/Tests/ConcurencyTests/ConcurencyTests.cs
@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using WebSocketRPC;
+
+namespace Tests
+{
+    partial class Program
+    {
+        static Task[] TestMultiClient(CancellationTokenSource cts)
+        {
+            var tasks = new List<Task>();
+
+            var ts = Server.ListenAsync($"http://{address}", cts.Token, (c, wc) => 
+            {
+                c.OnReceive += msg => Task.Run(() => Console.WriteLine("Received: " + msg));
+            });
+            tasks.Add(ts);
+
+            int id = 0;
+            for (int i = 0; i < 10; i++)
+            {
+                var tc = Client.ConnectAsync($"ws://{address}", cts.Token, c =>
+                {
+                    Interlocked.Increment(ref id);
+
+                    c.OnOpen += async () =>
+                    {
+                        int n = 10;
+                        while (n > 0)
+                        {
+                            await c.SendAsync("Hello from: " + id);
+                            await Task.Delay(10);
+                            n--;
+                        }
+                    };
+
+                    c.OnError += e => Task.Run(() => Console.WriteLine("Error: " + e.Message));
+                    c.OnClose += (s, d) => Task.Run(() => Console.WriteLine("Close: " + s));
+                },
+                reconnectOnError: false);
+
+                tasks.Add(tc);
+            }
+           
+
+            return tasks.ToArray();
+        }
+    }
+}
diff --git a/Tests/ConnectionException.cs b/Tests/ExceptionTests/ConnectionExceptionTests.cs
similarity index 75%
rename from Tests/ConnectionException.cs
rename to Tests/ExceptionTests/ConnectionExceptionTests.cs
index 59a02bc..6807d09 100644
--- a/Tests/ConnectionException.cs
+++ b/Tests/ExceptionTests/ConnectionExceptionTests.cs
@@ -12,17 +12,12 @@ static Task[] TestConnectionUnhandledException(CancellationTokenSource cts)
             var ts = Server.ListenAsync($"http://{address}", cts.Token, (c, wc) => c.Bind(new ServiceAPI()));
             var tc = Client.ConnectAsync($"ws://{address}", cts.Token, c =>
             {
-                c.Bind<IServiceAPI>();
                 c.OnOpen += () =>
                 {
                     throw new NotImplementedException();
                 };
 
-                c.OnError += e =>
-                {
-                    Console.WriteLine("Error: " + e.Message);
-                    return Task.FromResult(true);
-                };
+                c.OnError += e => Task.Run(() => Console.WriteLine("Error: " + e.Message));
             },
             reconnectOnError: false);
 
diff --git a/Tests/RpcException.cs b/Tests/ExceptionTests/RpcExceptionTests.cs
similarity index 82%
rename from Tests/RpcException.cs
rename to Tests/ExceptionTests/RpcExceptionTests.cs
index 3b751ff..9d73245 100644
--- a/Tests/RpcException.cs
+++ b/Tests/ExceptionTests/RpcExceptionTests.cs
@@ -25,7 +25,7 @@ static Task[] TestRpcInitializeException(CancellationTokenSource cts)
             var ts = Server.ListenAsync($"http://{address}", cts.Token, (c, wc) => c.Bind(new ServiceAPI()));
             var tc = Client.ConnectAsync($"ws://{address}", cts.Token, c =>
             {
-                c.Bind<ServiceAPI>();
+                c.Bind<ServiceAPI>(); //should generate an exception: must be an interface
                 c.OnOpen += async () =>
                 {
                     try
@@ -38,11 +38,7 @@ static Task[] TestRpcInitializeException(CancellationTokenSource cts)
                     }
                 };
 
-                c.OnError += e =>
-                {
-                    Console.WriteLine("Error: " + e.Message);
-                    return Task.FromResult(true);
-                };
+                c.OnError += e => Task.Run(() => Console.WriteLine("Error: " + e.Message));
             },
             reconnectOnError: false);
 
@@ -60,11 +56,7 @@ static Task[] TestRpcUnhandledException(CancellationTokenSource cts)
                     var results = await RPC.For<IServiceAPI>().CallAsync(x => x.LongRunningTask(1, 2));
                 };
 
-                c.OnError += e =>
-                {
-                    Console.WriteLine("Error: " + e.Message);
-                    return Task.FromResult(true);
-                };
+                c.OnError += e => Task.Run(() => Console.WriteLine("Error: " + e.Message));
             },
             reconnectOnError: false);
 
@@ -89,11 +81,7 @@ static Task[] TestRpcHandledException(CancellationTokenSource cts)
                     }
                 };
 
-                c.OnError += e =>
-                {
-                    Console.WriteLine("Error: " + e.Message);
-                    return Task.FromResult(true);
-                };
+                c.OnError += e => Task.Run(() => Console.WriteLine("Error: " + e.Message));
             },
             reconnectOnError: false);
 
diff --git a/Tests/Program.cs b/Tests/Program.cs
index 7ab326f..c684fe7 100644
--- a/Tests/Program.cs
+++ b/Tests/Program.cs
@@ -39,9 +39,15 @@ static void Main(string[] args)
         {
             //RunTest(TestConnectionException);
 
-            RunTest(TestRpcInitializeException);
+            //RunTest(TestRpcInitializeException);
             //RunTest(TestRpcUnhandledException);
             //RunTest(TestRpcHandledException);
+
+            //RunTest(TestMaxMessageSize);
+
+            //RunTest(TestTimeout);
+
+            RunTest(TestMultiClient);
         }
     }
 }
diff --git a/Tests/SettingsTests/SettingsTests.cs b/Tests/SettingsTests/SettingsTests.cs
new file mode 100644
index 0000000..c2c0074
--- /dev/null
+++ b/Tests/SettingsTests/SettingsTests.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using WebSocketRPC;
+
+namespace Tests
+{
+    partial class Program
+    {
+        static Task[] TestMaxMessageSize(CancellationTokenSource cts)
+        {
+            Connection.MaxMessageSize = Connection.Encoding.GetMaxByteCount(10);
+
+            var ts = Server.ListenAsync($"http://{address}", cts.Token, (c, wc) => c.Bind(new ServiceAPI()));
+            var tc = Client.ConnectAsync($"ws://{address}", cts.Token, c =>
+            {
+                c.OnOpen += async () =>
+                {
+                    await c.SendAsync("Long long message.");
+                };
+
+                c.OnError += e => Task.Run(() => Console.WriteLine("Error: " + e.Message));
+                c.OnClose += (s, d) => Task.Run(() => Console.WriteLine("Close: " + d));
+            },
+            reconnectOnError: false);
+
+            return new Task[] { ts, tc };
+        }
+    }
+}
diff --git a/Tests/TimeoutTests/TimeoutTests.cs b/Tests/TimeoutTests/TimeoutTests.cs
new file mode 100644
index 0000000..cb58695
--- /dev/null
+++ b/Tests/TimeoutTests/TimeoutTests.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using WebSocketRPC;
+
+namespace Tests
+{
+    partial class Program
+    {
+        static Task[] TestTimeout(CancellationTokenSource cts)
+        {
+            var ts = Server.ListenAsync($"http://{address}", cts.Token, (c, wc) => c.Bind(new ServiceAPI()));
+            var tc = Client.ConnectAsync($"ws://{address}", cts.Token, c =>
+            {
+                c.BindTimeout(TimeSpan.FromSeconds(5));
+
+                c.OnError += e => Task.Run(() => Console.WriteLine("Error: " + e.Message));
+                c.OnClose += (s, d) => Task.Run(() => Console.WriteLine("Close: " + d));
+            },
+            reconnectOnError: false);
+
+            return new Task[] { ts, tc };
+        }
+    }
+}