public static IUnityContainer GetContainer(FrontEndUnityContainerAvailable containerSelected)
        {
            IUnityContainer result = new UnityContainer();
            result.RegisterType(typeof(IAuthenticationProxy), typeof(AuthenticationProxy), new InjectionMember[0]);
            result.RegisterType(typeof(IMembershipProxy), typeof(MembershipProxy), new InjectionMember[0]);
            result.RegisterType(typeof(IRoleManagerProxy), typeof(RoleManagerProxy), new InjectionMember[0]);
            result.RegisterType(typeof(IRolesProxy), typeof(RolesProxy), new InjectionMember[0]);
            result.RegisterType(typeof(IProfileProxy), typeof(ProfileProxy), new InjectionMember[0]);
            result.RegisterType(typeof(ILoggingProxy), typeof(LoggingProxy), new InjectionMember[0]);
            result.RegisterType(typeof(ISyndicationProxy), typeof(SyndicationProxy), new InjectionMember[0]);
            result.RegisterType(typeof(IUserRequestContextFrontEnd), typeof(UserRequestContextFrontEnd), new InjectionMember[0]);
            result.RegisterType(typeof(IUserSessionModel), typeof(UserSessionAtHttpCookies), new InjectionMember[0]);

            switch (containerSelected)
            {
                case FrontEndUnityContainerAvailable.ProxiesToCustomHost:
                    result.RegisterType(typeof(IClientChannelInitializer<>), typeof(ClientChannelCustomHostInitializer<>), new InjectionMember[0]);
                    break;
                case FrontEndUnityContainerAvailable.ProxiesToAzure:
                    result.RegisterType(typeof(IClientChannelInitializer<>), typeof(ClientChannelAzureInternalRoleInitializer<>), new InjectionMember[0]);
                    break;
                default:
                    throw new Exception("IUnityContainer does not exist in the list of available providers");
            }

            return result;
        }

        public void OptionalDependencyParametersAreInjectedWithNull()
        {
            IUnityContainer container = new UnityContainer();

            var result = container.Resolve<ObjectWithOptionalConstructorParameter>();
            Assert.IsNull(result.SomeInterface);
        }

        public void When_getting_controller_attributes_then_builds_up_instance()
        {
            using (var container = new UnityContainer())
            {
                // Arrange
                var someInstance = new SomeClass();
                container.RegisterInstance<ISomeInterface>(someInstance);
                container.RegisterType<TestFilterAttribute>(new InjectionProperty("Some"));

                var context = new ControllerContext { Controller = new ControllerWithTypeAttribute() };
                var controllerDescriptor = new ReflectedControllerDescriptor(context.Controller.GetType());
                var action = context.Controller.GetType().GetMethod("MyActionMethod");
                var actionDescriptor = new ReflectedActionDescriptor(action, "MyActionMethod", controllerDescriptor);
                var provider = new UnityFilterAttributeFilterProvider(container);

                // Act
                Filter filter = provider.GetFilters(context, actionDescriptor).Single();

                // Assert
                TestFilterAttribute attrib = filter.Instance as TestFilterAttribute;
                Assert.IsNotNull(attrib);
                Assert.AreEqual(FilterScope.Controller, filter.Scope);
                Assert.AreEqual(1234, filter.Order);
                Assert.AreSame(someInstance, attrib.Some);
            }
        }

        public void CanUseContainerToResolveFactoryParameters()
        {
            bool factoryWasCalled = false;
            string connectionString = "Northwind";

            IUnityContainer container = new UnityContainer();

            container.AddNewExtension<StaticFactoryExtension>()
                .Configure<IStaticFactoryConfiguration>()
                    .RegisterFactory<MockDatabase>(c =>
                    {
                        Assert.AreSame(container, c);
                        factoryWasCalled = true;
                        string cs = c.Resolve<string>("connectionString");
                        return MockDatabase.Create(cs);
                    })
                    .Container
                .RegisterInstance<string>("connectionString", connectionString);

            MockDatabase db = container.Resolve<MockDatabase>();

            Assert.IsTrue(factoryWasCalled);
            Assert.IsNotNull(db);
            Assert.AreEqual(connectionString, db.ConnectionString);
        }

        public void StaticMethodsShouldNotBeInjected()
        {
            IUnityContainer container = new UnityContainer();

            GuineaPig pig = container.Resolve<GuineaPig>();
            Assert.IsFalse(GuineaPig.StaticMethodWasCalled);
        }

        public void ContainerControlledLifetimeReturnsSameInstanceFromMultipleThreads()
        {
            IUnityContainer container = new UnityContainer()
                .AddExtension(new SpyExtension(new DelayStrategy(), UnityBuildStage.Lifetime))
                .RegisterType<object>(new ContainerControlledLifetimeManager());

            object result1 = null;
            object result2 = null;

            Thread thread1 = new Thread(delegate()
            {
                result1 = container.Resolve<object>();
            });

            Thread thread2 = new Thread(delegate()
            {
                result2 = container.Resolve<object>();
            });

            thread1.Start();
            thread2.Start();

            thread2.Join();
            thread1.Join();

            Assert.IsNotNull(result1);
            Assert.AreSame(result1, result2);
        }

 protected virtual void Arrange()
 {
     Container =
         new UnityContainer()
             .RegisterType<BaseClass, DerivedClass>("derived",
                 new Interceptor<TransparentProxyInterceptor>(),
                 new InterceptionBehavior<PolicyInjectionBehavior>())
             .RegisterType<BaseClass, DerivedWithNoOverrideClass>("derived-nooverride",
                 new Interceptor<TransparentProxyInterceptor>(),
                 new InterceptionBehavior<PolicyInjectionBehavior>())
             .RegisterType<BaseClass>(
                 new Interceptor<TransparentProxyInterceptor>(),
                 new InterceptionBehavior<PolicyInjectionBehavior>())
             .AddNewExtension<Interception>()
             .Configure<Interception>()
                 .AddPolicy("base")
                     .AddMatchingRule(new TypeMatchingRule(typeof(BaseClass)))
                     .AddMatchingRule(new MemberNameMatchingRule("InterceptedMethod"))
                     .AddCallHandler(new AppendSuffixCallHandler { Suffix = "-basehandler", Order = 1 })
                 .Interception
                 .AddPolicy("derived-no-override")
                     .AddMatchingRule(new TypeMatchingRule(typeof(DerivedWithNoOverrideClass)))
                     .AddMatchingRule(new MemberNameMatchingRule("InterceptedMethod"))
                     .AddCallHandler(new AppendSuffixCallHandler { Suffix = "-derivednooverridehandler", Order = 2 })
                 .Interception
                 .AddPolicy("derived")
                     .AddMatchingRule(new TypeMatchingRule(typeof(DerivedClass)))
                     .AddMatchingRule(new MemberNameMatchingRule("InterceptedMethod"))
                     .AddCallHandler(new AppendSuffixCallHandler { Suffix = "-derivedhandler", Order = 3 })
                 .Interception
             .Container;
 }

 public void CanAddExtensionWithNonDefaultConstructor()
 {
     IUnityContainer container = new UnityContainer();
     container.AddNewExtension<ContainerExtensionWithNonDefaultConstructor>();
     var extension = container.Configure(typeof (ContainerExtensionWithNonDefaultConstructor));
     Assert.IsNotNull(extension);
 }

        public void CanConfigureRemotingInterceptionOnInterface()
        {
            IUnityContainer container = new UnityContainer();
            container.AddNewExtension<Interception>();

            container.Configure<Interception>().SetInterceptorFor<Interface>(new TransparentProxyInterceptor());
        }

 public void ContainerThrowsWhenConfiguringStaticMethodForInjection()
 {
     IUnityContainer container = new UnityContainer()
         .RegisterType<GuineaPig>(
                new InjectionMethod("ShouldntBeCalled"));
     Assert.Fail("Should not get here");
 }

        public void DoesNotRegisterTypeWithNoLifetimeOrInjectionMembers()
        {
            var container = new UnityContainer();
            container.RegisterTypes(new[] { typeof(MockLogger) }, getName: t => "name");

            Assert.IsFalse(container.Registrations.Any(r => r.MappedToType == typeof(MockLogger)));
        }

        public override void Configure(Container container)
        {
            var unityContainer = new UnityContainer()
              .AddNewExtension<BuildTracking>()
              .AddNewExtension<LogCreation>();

            var userRepository = new InMemoryAuthRepository();

            this.Plugins.Add(new AuthFeature(() => new AuthUserSession(),
              new IAuthProvider[] { new BasicAuthProvider()}));

            this.Plugins.Add(new RegistrationFeature());

            unityContainer.RegisterInstance<ICacheClient>(new MemoryCacheClient());
            unityContainer.RegisterInstance<IUserAuthRepository>(userRepository);

            unityContainer.RegisterInstance<IDbConnectionFactory>(new OrmLiteConnectionFactory("~/Database/SmartDom.db".MapServerPath(),
                SqliteOrmLiteDialectProvider.Instance));

            unityContainer.RegisterType<IOrmWrapper, OrmWrapper>();
            unityContainer.RegisterType<IConfigurationRepository, AppConfigRepository>();
            unityContainer.RegisterType<MediaAdapterAbstractFactory<SerialPort>, SerialPortAdapterFactory>(new ContainerControlledLifetimeManager());
            unityContainer.RegisterType<ModbusMasterAbstractFactory<SerialPort>, RtuSerialModbusMasterFactory>(new ContainerControlledLifetimeManager());
            unityContainer.RegisterType<IGenericRepository<Device>, DeviceDbRepository>(new ContainerControlledLifetimeManager(),
                new InjectionMethod("Initialize"));
            unityContainer.RegisterType<IDeviceAccessLayer, SerialAccessLayer>(new ContainerControlledLifetimeManager());
            unityContainer.RegisterType<IMessageDecoder, MessageDecoder>();
            unityContainer.RegisterType<IDeviceManager, DeviceManager>();

            var unityAdapter = new UnityContainerAdapter(unityContainer);
            container.Adapter = unityAdapter;

            AddUser(userRepository);
        }

        public void CanSetUpAPolicyWithExternallyConfiguredRulesAndHandlers()
        {
            IUnityContainer container = new UnityContainer();
            container.AddNewExtension<Interception>();

            container
                .Configure<Interception>()
                    .AddPolicy("policy1")
                        .AddMatchingRule("rule1")
                        .AddCallHandler("handler1")
                        .AddCallHandler("handler2").Interception.Container
                .RegisterType<IMatchingRule, AlwaysMatchingRule>("rule1")
                .RegisterType<ICallHandler, GlobalCountCallHandler>(
                    "handler1",
                    new InjectionConstructor("handler1"))
                .RegisterType<ICallHandler, GlobalCountCallHandler>(
                    "handler2",
                    new InjectionConstructor("handler2"),
                    new InjectionProperty("Order", 10));

            GlobalCountCallHandler.Calls.Clear();

            container
                .Configure<Interception>()
                    .SetInterceptorFor<Wrappable>("wrappable", new VirtualMethodInterceptor());

            Wrappable wrappable1 = container.Resolve<Wrappable>("wrappable");
            wrappable1.Method2();

            Assert.AreEqual(1, GlobalCountCallHandler.Calls["handler1"]);
            Assert.AreEqual(1, GlobalCountCallHandler.Calls["handler2"]);
        }

 public void UnityResolver_Resolves_Registered_Utilities_Test()
 {
     var container = new UnityContainer();
     container.RegisterInstance<IUtilities>(new Utilities(new PersistenceService(_context),new LogService("ConnectionString", new EmailService())));
     var resolver = new UnityResolver(container);
     var instance = resolver.GetService(typeof(IUtilities));
     Assert.IsNotNull(instance);
 }

 public void UnityResolver_Resolves_Registered_LogService_Test()
 {
     var container = new UnityContainer();
     container.RegisterInstance<ILogService>(new LogService("ConnectionString", new EmailService()));
     var resolver = new UnityResolver(container);
     var instance = resolver.GetService(typeof(ILogService));
     Assert.IsNotNull(instance);
 }

 public void UnityResolver_Resolves_Registered_PersistenceService_Test()
 {
     var container = new UnityContainer();
     container.RegisterInstance<IPersistenceService>(new PersistenceService(_context));
     var resolver = new UnityResolver(container);
     var instance = resolver.GetService(typeof(IPersistenceService));
     Assert.IsNotNull(instance);
 }

 public void UnityResolver_Resolves_Registered_DBContect_Test()
 {
     var container = new UnityContainer();
     container.RegisterInstance<IDataContext>(_context);
     var resolver = new UnityResolver(container);
     var instance = resolver.GetService(typeof(IDataContext));
     Assert.IsNotNull(instance);
 }

        public void CanResolveALazy()
        {
            var container = new UnityContainer()
                .RegisterType<ILogger, MockLogger>();

            var lazy = container.Resolve<Lazy<ILogger>>();
            Assert.IsNotNull(lazy);
        }

        public void OptionalPropertiesGetNullWhenNotConfigured()
        {
            IUnityContainer container = new UnityContainer();

            var result = container.Resolve<ObjectWithOptionalProperty>();

            Assert.IsNull(result.SomeInterface);
        }

        public void ContainerReturnsEmptyArrayIfNoObjectsRegistered()
        {
            IUnityContainer container = new UnityContainer();
            List<object> results = new List<object>(container.ResolveAll<object>());

            Assert.IsNotNull(results);
            CollectionAssert.AreEqual(new object[0], results);
        }