/// <summary>
        /// Listens for numMessages consecutive messages
        /// </summary>
        /// <param name="numMessages">Number of messages to listen to</param>
        /// <returns>The last received message</returns>
        public override T Listen <T>(int numMessages)
        {
            int messages    = numMessages;
            T   messageBody = default(T);

            // Continuously process messages received from the HighMessages subscription
            while (messages > 0)
            {
                BrokeredMessage message = SubClient.Receive(TimeSpan.FromSeconds(15));

                messages--;

                if (message != null)
                {
                    try
                    {
                        messageBody = message.GetBody <T>();
                        // Remove message from subscription
                        message.Complete();
                    }
                    catch (Exception)
                    {
                        // Indicate a problem, unlock message in subscription
                        message.Abandon();
                    }
                }
            }
            return(messageBody);
        }
            public Task <StorageClient> Create()
            {
                var mock = new SubClient();

                _clients.Add(mock);
                if (Interlocked.Increment(ref _callCounter) == _unblockAt)
                {
                    _sync.Set();
                }
                else
                {
                    // Block all calls until the last one arrives.
                    _sync.Wait();
                }

                return(Task.FromResult((StorageClient)mock));
            }