public void RunShouldCallCreateLogger()
        {
            var bootstrapper = new DefaultMefBootstrapper();
            bootstrapper.Run();

            Assert.IsTrue(bootstrapper.CreateLoggerCalled);
        }

        public void RunConfiguresServiceLocatorProvider()
        {
            var bootstrapper = new DefaultMefBootstrapper();
            bootstrapper.Run();

            Assert.IsTrue(ServiceLocation.ServiceLocator.Current is MefServiceLocatorAdapter);
        }

        public void ContainerDefaultsToNull()
        {
            var bootstrapper = new DefaultMefBootstrapper();
            var container = bootstrapper.BaseContainer;

            Assert.IsNull(container);
        }

        public void RunShouldCallCreateModuleCatalog()
        {
            var bootstrapper = new DefaultMefBootstrapper();
            bootstrapper.Run();

            Assert.IsTrue(bootstrapper.CreateModuleCatalogCalled);
        }

        public void RunShouldCallConfigureAggregateCatalog()
        {
            var bootstrapper = new DefaultMefBootstrapper();
            bootstrapper.Run();

            Assert.IsTrue(bootstrapper.ConfigureAggregateCatalogCalled);
        }

        public void CreateContainerShouldNotInitializeContainerProviders()
        {
            var bootstrapper = new DefaultMefBootstrapper();

            bootstrapper.CallCreateContainer();

            Assert.AreEqual(0, bootstrapper.BaseContainer.Providers.Count);
        }

        public void CreateAggregateCatalogShouldInitializeCatalog()
        {
            var bootstrapper = new DefaultMefBootstrapper();

            bootstrapper.CallCreateAggregateCatalog();

            Assert.IsNotNull(bootstrapper.BaseAggregateCatalog);
        }

        public void CreateContainerShouldInitializeContainer()
        {
            var bootstrapper = new DefaultMefBootstrapper();

            bootstrapper.CallCreateContainer();

            Assert.IsNotNull(bootstrapper.BaseContainer);
            Assert.IsInstanceOfType(bootstrapper.BaseContainer, typeof(CompositionContainer));
        }

        public void RegionNavigationJournalEntryIsRegisteredWithContainer()
        {
            var bootstrapper = new DefaultMefBootstrapper();
            bootstrapper.Run();

            var actual1 = bootstrapper.BaseContainer.GetExportedValue<IRegionNavigationJournalEntry>();
            var actual2 = bootstrapper.BaseContainer.GetExportedValue<IRegionNavigationJournalEntry>();

            Assert.IsNotNull(actual1);
            Assert.IsNotNull(actual2);
            Assert.AreNotSame(actual1, actual2);
        }

        public void SingleIRegionBehaviorFactoryIsRegisteredWithContainer()
        {
            var bootstrapper = new DefaultMefBootstrapper();
            bootstrapper.Run();

            var exported = bootstrapper.BaseContainer.GetExportedValue<IRegionBehaviorFactory>();
            Assert.IsNotNull(exported);
        }

        public void RegionLifetimeBehaviorIsRegisteredWithContainer()
        {
            var bootstrapper = new DefaultMefBootstrapper();
            bootstrapper.Run();

            var exported = bootstrapper.BaseContainer.GetExportedValue<RegionMemberLifetimeBehavior>();
            Assert.IsNotNull(exported);
        }

        public void SingleRegionActiveAwareBehaviorIsRegisteredWithContainer()
        {
            var bootstrapper = new DefaultMefBootstrapper();
            bootstrapper.Run();

            var exported = bootstrapper.BaseContainer.GetExportedValue<RegionActiveAwareBehavior>();
            Assert.IsNotNull(exported);
        }

        public async Task RunShouldCallTheMethodsInOrder()
        {
            await ExecuteOnUIThread(() =>
                {
                    var bootstrapper = new DefaultMefBootstrapper { ShellObject = new UserControl() };
                    bootstrapper.Run();

                    Assert.AreEqual("CreateLogger", bootstrapper.MethodCalls[0]);
                    Assert.AreEqual("CreateModuleCatalog", bootstrapper.MethodCalls[1]);
                    Assert.AreEqual("ConfigureModuleCatalog", bootstrapper.MethodCalls[2]);
                    Assert.AreEqual("CreateContainerConfiguration", bootstrapper.MethodCalls[3]);
                    Assert.AreEqual("ConfigureAggregateCatalog", bootstrapper.MethodCalls[4]);
                    Assert.AreEqual("CreateContainer", bootstrapper.MethodCalls[5]);
                    Assert.AreEqual("ConfigureContainer", bootstrapper.MethodCalls[6]);
                    Assert.AreEqual("ConfigureServiceLocator", bootstrapper.MethodCalls[7]);
                    //Assert.AreEqual("ConfigureRegionAdapterMappings", bootstrapper.MethodCalls[8]);
                    //Assert.AreEqual("ConfigureDefaultRegionBehaviors", bootstrapper.MethodCalls[9]);
                    Assert.AreEqual("RegisterFrameworkExceptionTypes", bootstrapper.MethodCalls[8]);
                    Assert.AreEqual("CreateShell", bootstrapper.MethodCalls[9]);
                    Assert.AreEqual("InitializeShell", bootstrapper.MethodCalls[10]);
                    Assert.AreEqual("InitializeModules", bootstrapper.MethodCalls[11]);
                });
        }

        public void RunShouldLogAboutRunCompleting()
        {
            const string expectedMessageText = "Bootstrapper sequence completed";
            var bootstrapper = new DefaultMefBootstrapper();
            bootstrapper.Run();

            Assert.IsTrue(bootstrapper.TestLog.LogMessages.Contains(expectedMessageText));
        }

        public void ConfigureContainerAddsAggregateCatalogToContainer()
        {
            var bootstrapper = new DefaultMefBootstrapper();
            bootstrapper.CallCreateLogger();
            bootstrapper.CallCreateAggregateCatalog();
            bootstrapper.CallCreateModuleCatalog();
            bootstrapper.CallCreateContainer();
            bootstrapper.CallConfigureContainer();

            var returnedCatalog = bootstrapper.BaseContainer.GetExportedValue<AggregateCatalog>();
            Assert.IsNotNull(returnedCatalog);
            Assert.AreEqual(typeof(AggregateCatalog), returnedCatalog.GetType());
        }

        public void RunShouldLogAboutInitializingModules()
        {
            const string expectedMessageText = "Initializing modules";
            var bootstrapper = new DefaultMefBootstrapper();
            bootstrapper.Run();

            Assert.IsTrue(bootstrapper.TestLog.LogMessages.Contains(expectedMessageText));
        }

        public void SingleBindRegionContextToDependencyObjectBehaviorIsRegisteredWithContainer()
        {
            var bootstrapper = new DefaultMefBootstrapper();
            bootstrapper.Run();

            var exported = bootstrapper.BaseContainer.GetExportedValue<BindRegionContextToDependencyObjectBehavior>();
            Assert.IsNotNull(exported);
        }

        public void SingleSelectorItemsSourceSyncBehaviorIsRegisteredWithContainer()
        {
            var bootstrapper = new DefaultMefBootstrapper();
            bootstrapper.Run();

            var exported = bootstrapper.BaseContainer.GetExportedValue<SelectorItemsSourceSyncBehavior>();
            Assert.IsNotNull(exported);
        }

 public void CanRunBootstrapper()
 {
     var bootstrapper = new DefaultMefBootstrapper();
     bootstrapper.Run();
 }

        public void ModuleManagerRunCalled()
        {
            var bootstrapper = new DefaultMefBootstrapper();
            var container = new CompositionContainer();

            Mock<IModuleManager> mockModuleManager = SetupModuleManager(container);

            bootstrapper.BaseContainer = container;

            bootstrapper.CallInitializeModules();

            mockModuleManager.Verify(mm => mm.Run(), Times.Once());
        }