public void CreateQueue_ValidName_CreatesQueue()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();

            client.CreateQueue(queueName);

            _util.AssertQueueExists(queueName);
        }

        public void CreateQueue_AlreadyExistsWithNoMetadata_ReportsNoContentPerDocumentation()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName);

            client.CreateQueue(queueName);

            // I don't think I can/should-be-able-to test the return code at this level...
        }

        public void ListQueues_AtLeastOneQueue_ReturnsListContainingThatQueue()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName);

            var response = client.ListQueues();

            Assert.IsTrue(response.Queues.Any(q => q.Name == queueName));
        }

        public void PutMessage_TooLargeMessage_ThrowsRequestBodyTooLargeException()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName);
            string message = new String('a', 64 * 1024 + 1);

            client.PutMessage(queueName, message);

            //expects exception
        }

        public void CreateQueue_ValidNameAndMetadata_CreatesQueue()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();

            client.CreateQueue(queueName, new Dictionary<string, string>() { 
                { "SampleName", "SampleValue" }
            });

            _util.AssertQueueExists(queueName);
        }

        public void PutMessage_ValidMessage_AddsMessageToQueue()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName);
            string message = "Unit Test Message";

            client.PutMessage(queueName, message);

            _util.AssertQueueHasMessage(queueName);
        }

        public void PutMessage_InvalidXMLCharacters_DoesNotThrowException()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName);
            string message = "{\"KeyValueLogPayload\": {\"UserIP\": \"::1\",\"URL\": \"http://fakeurl/foo?bar=baz&baz=bar\"}}";

            Assert.DoesNotThrow(() =>
            {
                client.PutMessage(queueName, message);
            });
        }

        public void CreateQueue_AlreadyExistsWithMatchingMetadata_ReportsNoContentPerDocumentation()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName, new Dictionary<string, string> { 
                { "SampleKey", "SampleValue" }
            });

            client.CreateQueue(queueName, new Dictionary<string, string> { 
                { "SampleKey", "SampleValue" }
            });

            // I don't think I can/should-be-able-to test the return code at this level...
        }

        public void ListQueues_MaxResultsSmallerThanQueueList_ReturnsOnlyThatManyResults()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueNames = new List<string>();
            for (int i = 0; i < 5; i++)
            {
                var queueName = GenerateSampleQueueName(i.ToString());
                _util.CreateQueue(queueName);
                queueNames.Add(queueName);
            }

            var response = client.ListQueues(maxResults: 3);

            Assert.AreEqual(3, response.Queues.Count);
        }

        public void ListQueues_WithPrefix_ReturnsListContainingOnlyQueuesWithThatPrefix()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueNames = new List<string>();
            for (int i = 18; i < 21; i++)
            {
                var queueName = GenerateSampleQueueName(i.ToString());
                _util.CreateQueue(queueName);
                queueNames.Add(queueName);
            }

            var response = client.ListQueues("1");

            Assert.AreEqual("1", response.Prefix);
            Assert.IsTrue(response.Queues.Count(q => q.Name.StartsWith("1")) >= 2);
            Assert.AreEqual(0, response.Queues.Count(q => !q.Name.StartsWith("1")));
        }

        public void UpdateMessage_InvalidXMLMessageTextCharacters_DoesNotThrowException()
        {
            const string rawFirstText = "<QueueMessage><MessageText>Test</MessageText></QueueMessage>";
            const string rawSecondText = "{\"KeyValueLogPayload\": {\"UserIP\": \"::1\",\"URL\": \"http://fakeurl/foo?bar=baz&baz=bar\"}}";
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName);
            _util.AddItemsToQueue(queueName, new List<string>() { rawFirstText });
            var itemFromQueue = _util.GetItemFromQueue(queueName, 1);

            Assert.DoesNotThrow(() =>
            {
                client.UpdateMessage(queueName, itemFromQueue.Id, itemFromQueue.PopReceipt, 0, rawSecondText);
            });
        }

        public void UpdateMessage_DifferentMessageText_ChangesMessageText()
        {
            const string rawFirstText = "1";
            const string rawSecondText = "2";
            var firstText = Convert.ToBase64String(Encoding.UTF8.GetBytes(rawFirstText));
            var secondText = Convert.ToBase64String(Encoding.UTF8.GetBytes(rawSecondText));
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName);
            _util.AddItemsToQueue(queueName, new List<string>() { firstText });
            var itemFromQueue = _util.GetItemFromQueue(queueName, 1);

            client.UpdateMessage(queueName, itemFromQueue.Id, itemFromQueue.PopReceipt, 0, secondText);

            var itemFromQueueAgain = _util.GetItemFromQueue(queueName);
            Assert.AreEqual(rawSecondText, itemFromQueueAgain.AsString);
        }

        public void UpdateMessage_ExtendVisibility_ExtendsMessageVisibilityInTheQueue()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName);
            _util.AddItemsToQueue(queueName, new List<string>() { "1" });
            var itemFromQueue = _util.GetItemFromQueue(queueName, 1);

            var response = client.UpdateMessage(queueName, itemFromQueue.Id, itemFromQueue.PopReceipt, 30);

            Assert.IsNotNullOrEmpty(response.PopReceipt);
            Thread.Sleep(2000); // longer than the original visibility timeout
            var itemFromQueueAgain = _util.GetItemFromQueue(queueName);
            Assert.IsNull(itemFromQueueAgain);
        }

        public void UpdateMessage_UpdateContent_UpdatesContentOfMessageInQueue()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName);
            _util.AddItemsToQueue(queueName, new List<string>() { "1" });
            var itemFromQueue = _util.GetItemFromQueue(queueName);
            var newString = Convert.ToBase64String(Encoding.ASCII.GetBytes("2"));   // the official SDK base 64's the values automatically

            client.UpdateMessage(queueName, itemFromQueue.Id, itemFromQueue.PopReceipt, 0, newString);

            var itemFromQueueAgain = _util.GetItemFromQueue(queueName);
            Assert.IsNotNull(itemFromQueueAgain);
            Assert.AreEqual(itemFromQueue.Id, itemFromQueueAgain.Id);
            Assert.AreEqual("1", itemFromQueue.AsString);
            Assert.AreEqual("2", itemFromQueueAgain.AsString);
        }

        public async Task ClearMessagesAsync_QueueDoesNotExist_ThrowsQueueNotFoundException()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();

            await client.ClearMessagesAsync(queueName);

            //expects exception
        }

        public void PeekMessages_RequestUndefinedNumberOfItemsFromFullQueue_ReturnsOneItem()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName);
            _util.AddItemsToQueue(queueName, Enumerable.Range(1, 40).Select(n => n.ToString()).ToList());
            var expectedMessage = "1";

            var response = client.PeekMessages(queueName);

            Assert.AreEqual(1, response.Messages.Count);
            var message = response.Messages.Single();
            // Base 64 encode the expected message since Azure SDK did so when enqueueing it
            Assert.AreEqual(Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(expectedMessage)), message.MessageText);
        }

        public async Task UpdateMessageAsync_NonExistentMessage_ThrowsException()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName);

            await client.UpdateMessageAsync(queueName, "123-abc", FakePopReceipt, 0);

            // expects exception
        }

        public void GetMessages_RequestItemFromPopulatedQueue_ReturnsItemWithPopReceiptAndDequeueCount()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName);
            _util.AddItemsToQueue(queueName, new List<string>() { "1" });

            var response = client.GetMessages(queueName, 1, 30);

            Assert.AreEqual(1, response.Messages.Count);
            var message = response.Messages.Single();
            Assert.IsNotNullOrEmpty(message.PopReceipt);
            Assert.Greater(message.DequeueCount, 0);
        }

        public void PutMessage_ValidMessageWithVisibilityTimeout_IsNotVisibleInQueue()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName);
            string message = "Unit Test Message";

            client.PutMessage(queueName, message, visibilityTimeout: 5);

            _util.AssertQueueInvisibleMessage(queueName);
        }

        public void DeleteMessage_BadlyFormattedPopReceipt_ThrowsInvalidQueryParameterException()
        {
            IQueueServiceClient client = new QueueServiceClient(_accountSettings);
            var queueName = GenerateSampleQueueName();
            _util.CreateQueue(queueName);

            client.DeleteMessage(queueName, "abc-123", "bad format");

            // expects exception
        }