protected void EnsureStorage( string connectionString )
        {
            bool runInstall = CreateDatabaseIfNotExists( connectionString );

             if( runInstall )
             {
            SchemaManager.Install( connectionString );
             }

             var storage = new QueueStorage( connectionString );

             try
             {
            storage.Initialize();
             }
             catch(Exception ex)
             {
            if ( !( ex is InvalidOperationException ) && !( ex is SqlException ) )
            {
               throw;
            }

            SchemaManager.Install( connectionString );
            storage.Initialize();
             }

             using ( var qManager = new QueueManager( connectionString, port: 2204 ) )
             {
            qManager.ConfigureEndPoint();
             }

             StorageUtil.PurgeAll( connectionString );
        }

        public StartingRhinoQueues()
        {
            if (Directory.Exists("test.esent"))
                Directory.Delete("test.esent", true);

            queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), "test.esent");
        }

        public AutoSelectPort()
        {
            if (Directory.Exists("test.esent"))
                Directory.Delete("test.esent", true);

            queueManager = new QueueManager(endPoint, "test.esent");
        }

        public void MessageSent_EventIsRaised()
        {
            using (var sender = SetupSender())
            {
                sender.MessageSent += RecordMessageEvent;

                using (var receiver = new QueueManager("localhost", "test2.esent"))
                {
                    receiver.CreateQueues("h");
                    receiver.Start();

                    using (var tx = new TransactionScope())
                    {
                        sender.Send(
                            new Uri("file://localhost/h"),
                            new MessagePayload
                            {
                                Data = new byte[] { 1, 2, 4, 5 }
                            });
                        tx.Complete();
                    }
                    sender.WaitForAllMessagesToBeSent();
                }

                sender.MessageSent -= RecordMessageEvent;
            }

            Assert.NotNull(_messageEventArgs);
            Assert.Equal("localhost", _messageEventArgs.Endpoint);
            Assert.Equal("h", _messageEventArgs.Message.Queue);
        }

 public bool Start(HostControl hostControl)
 {
     _logger.Info("Producer service starting");
     _queueManager = new QueueManager(_queueName, _svcBusConnection);
     _queueManager.Start().Wait();
     _task = StartProducing();
     return true;
 }

 public QueueIsAsync()
 {
     if (Directory.Exists("test.esent"))
         Directory.Delete("test.esent", true);
     _queueManager = new QueueManager("localhost", "test.esent");
     _queueManager.CreateQueues("h");
     _queueManager.Start();
 }

        public QueueIsAsync()
        {
            if (Directory.Exists("test.esent"))
                Directory.Delete("test.esent", true);

            queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), "test.esent");
            queueManager.CreateQueues("h");
        }

        public Errors()
        {
            if (Directory.Exists("test.esent"))
                Directory.Delete("test.esent", true);

            _sender = new QueueManager(null, "test.esent");
            _sender.Start();
        }

 public WhenPeekingMessages()
 {
     if (Directory.Exists("test.esent"))
         Directory.Delete("test.esent", true);
     _queueManager = new QueueManager("localhost", "test.esent");
     _queueManager.CreateQueues("h");
     _queueManager.Start();
 }

        public Errors()
        {
            if (Directory.Exists("test.esent"))
                Directory.Delete("test.esent", true);

            sender = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), "test.esent");
            sender.Start();
        }

 public ReceivingFromRhinoQueue()
 {
     if (Directory.Exists("test.esent"))
         Directory.Delete("test.esent", true);
     _queueManager = new QueueManager("localhost", "test.esent");
     _queueManager.CreateQueues("h");
     _queueManager.Start();
 }

        public void Enabling_performance_counters_without_existing_categories_throws_meaningful_error()
        {
            PerformanceCounterCategoryCreation.DeletePerformanceCounters();

            using (var queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), TEST_QUEUE_1))
            {
                Assert.Throws<ApplicationException>(() => queueManager.EnablePerformanceCounters());
            }
        }

 public static QueueManager QueueManager(string name = "test", string queue = "h")
 {
     var directory = string.Format("{0}.esent", name);
     if (Directory.Exists(directory))
         Directory.Delete(directory, true);
     var queueManager = new QueueManager("localhost", directory);
     queueManager.CreateQueues(queue);
     return queueManager;
 }

        public static QueueManager GetInstance()
        {
            if (queueManager == null)
            {
                queueManager = new QueueManager();
            }

            return queueManager;
        }

 public void Enabling_performance_counters_after_queue_has_started_should_throw()
 {
     Setup();
     using (var queueManager = new QueueManager("localhost", TEST_QUEUE_1))
     {
         queueManager.Start();
         Assert.Throws<InvalidOperationException>(() => queueManager.EnablePerformanceCounters());
     }
 }

        public WhenPeekingMessages()
        {
            if (Directory.Exists("test.esent"))
                Directory.Delete("test.esent", true);

            queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), "test.esent");
            queueManager.CreateQueues("h");
            queueManager.Start();
        }

        public ReceivingFromRhinoQueue()
        {
            if (Directory.Exists("test.esent"))
                Directory.Delete("test.esent", true);

            queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), "test.esent");
            queueManager.CreateQueues("h");
            queueManager.Start();
        }

 public void After_enabling_performance_counters_changes_to_queue_state_should_be_reflected_in_counters()
 {
     Setup();
     using (var queueManager = new QueueManager("localhost", TEST_QUEUE_1))
     {
         queueManager.EnablePerformanceCounters();
         EnqueueMessages(queueManager);
     }
     AssertAllCountersHaveCorrectValues();
 }

        public void Enabling_performance_counters_after_queue_has_started_should_throw()
        {
            Setup();

            using (var queueManager = new QueueManager(new IPEndPoint(IPAddress.Loopback, 23456), TEST_QUEUE_1))
            {
                queueManager.Start();
                Assert.Throws<InvalidOperationException>(() => queueManager.EnablePerformanceCounters());
            }
        }

        public void Setup()
        {
            using (var tx = new TransactionScope())
            {
                receiver = ObjectMother.QueueManager("receiver", 4545, "uno");
                receiver.Start();

                tx.Complete();
            }
        }