public void GenericResolveByTypeNotRegisteredThrowsException()
 {
     using (var container = new IocContainer())
     {
         container.Resolve<IFoo>();
     }
 }

 public void DefaultLifetimeMangerIsNull()
 {
     using (var iocContainer = new IocContainer())
     {
         Assert.IsNull(iocContainer.DefaultLifetimeManager);
     }
 }

 public void CanSetDefaultLifetimeToTransient()
 {
     using (var container = new IocContainer(() => new TransientLifetime()))
     {
         Assert.IsInstanceOfType(container.DefaultLifetime, typeof(TransientLifetime));
     }
 }

 public void DefaultLifetimeIsDefaultSetToTransient()
 {
     using (var container = new IocContainer())
     {
         Assert.IsInstanceOfType(container.DefaultLifetime, typeof(TransientLifetime));
     }
 }

		public void CanSetDefaultLifetimeToSessionLifetime()
		{
			using (var container = new IocContainer(() => new SessionLifetime()))
			{
				Assert.IsInstanceOfType(container.DefaultLifetimeFactory(), typeof(SessionLifetime));
			}
		}

        static MunqUseCase()
        {
            container = new IocContainer();
            singleton = new Munq.LifetimeManagers.ContainerLifetime();

            container.Register<IWebService>(
                c => new WebService(
                    c.Resolve<IAuthenticator>(),
                    c.Resolve<IStockQuote>()));

            container.Register<IAuthenticator>(
                c => new Authenticator(
                    c.Resolve<ILogger>(),
                    c.Resolve<IErrorHandler>(),
                    c.Resolve<IDatabase>()));

            container.Register<IStockQuote>(
                c => new StockQuote(
                    c.Resolve<ILogger>(),
                    c.Resolve<IErrorHandler>(),
                    c.Resolve<IDatabase>()));

            container.Register<IDatabase>(
                c => new Database(
                    c.Resolve<ILogger>(),
                    c.Resolve<IErrorHandler>()));

            container.Register<IErrorHandler>(
                c => new ErrorHandler(c.Resolve<ILogger>()));

            container.RegisterInstance<ILogger>(new Logger())
                    .WithLifetimeManager(singleton);
        }

		public void SessionLifetimeReturnsSameInstanceForSameSessionAndDifferentInstanceForDifferentSession()
		{
			// Arrange
			using (var container = new IocContainer())
			{
				var sessionItems1 = new SessionStateItemCollection();
				var sessionItems2 = new SessionStateItemCollection();
				var context1 = new FakeHttpContext("Http://fakeUrl1.com", null, null, null, null, sessionItems1);
				var context2 = new FakeHttpContext("Http://fakeUrl2.com", null, null, null, null, sessionItems2);

				HttpContextBase currentContext = null;

				var lifetime = new SessionLifetime(() => currentContext);		// better solution for injecting HttpContext ?

				container.Register<IFoo>(c => new Foo1()).SetLifetime(lifetime);

				// Act
				currentContext = context1;

				var result1 = container.Resolve<IFoo>();
				var result2 = container.Resolve<IFoo>();

				currentContext = context2;

				var result3 = container.Resolve<IFoo>();

				// Assert
				Assert.IsNotNull(result1);
				Assert.IsNotNull(result2);
				Assert.IsNotNull(result3);

				Assert.AreSame(result1, result2);
				Assert.AreNotSame(result1, result3);
			}
		}

        public void Configuration(IAppBuilder appBuilder)
        {
            IIocContainer iocContainer = new IocContainer();

            Bootstrap.Application()
                .ResolveReferencesWith(iocContainer)
                .UseEnvironment()
                .UseDomain().WithSimpleMessaging()
                .ConfigureRouteInspectorServer().WithRouteLimitOf(10)
                .ConfigureRouteInspectorWeb()
                .UseEventSourcing().PersistToMemory()
                .Initialise();

            var configuration = new HttpConfiguration
            {
                DependencyResolver = new SystemDotDependencyResolver(iocContainer)
            };

            configuration.MapHttpAttributeRoutes();
            configuration.Filters.Add(new ModelStateContextFilterAttribute());
            configuration.Filters.Add(new NoCacheFilterAttribute());

            configuration.MapSynchronisationRoutes();

             configuration.Routes.MapHttpRoute(
                  "Default",
                  "{controller}/{id}",
                  new { id = RouteParameter.Optional });
            
            appBuilder.UseWebApi(configuration);
        }

		public void CanSetDefaultLifetimeToThreadLocalStorageLifetime()
		{
			using (var container = new IocContainer(() => new ThreadLocalLifetime()))
			{
				Assert.IsInstanceOfType(container.DefaultLifetimeFactory(), typeof(ThreadLocalLifetime));
			}
		}

		public void ThreadLocalStorageLifetimeReturnsSameInstanceForSameThread()
		{
			using (var container = new IocContainer())
			{
				container.Register<IFoo>(c => new Foo1()).SetLifetime(new ThreadLocalLifetime());

				IFoo result1 = container.Resolve<IFoo>();
				IFoo result2 = container.Resolve<IFoo>();

				IFoo result3 = null;
				IFoo result4 = null;

				// Resolve on a different thread
				var task = Task.Factory.StartNew(() =>
				{
					result3 = container.Resolve<IFoo>();
					result4 = container.Resolve<IFoo>();
				});

				task.Wait();

				// Assert
				Assert.IsNotNull(result1);
				Assert.IsNotNull(result2);
				Assert.IsNotNull(result3);
				Assert.IsNotNull(result4);

				Assert.AreSame(result1, result2);
				Assert.AreSame(result3, result4);

				Assert.AreNotSame(result1, result3);
			}
		}

 public override void Prepare()
 {
     this.container = new IocContainer();
     this.container.Register<ISingleton, Singleton>().WithLifetimeManager(new ContainerLifetime());
     this.container.Register<ITransient, Transient>().WithLifetimeManager(new AlwaysNewLifetime());
     this.container.Register<ICombined, Combined>().WithLifetimeManager(new AlwaysNewLifetime());
 }

        public void TransientLifetimeAlwaysReturnsANewInstance()
        {
            // Arrange
            using (var container = new IocContainer())
            {
                container.Register<IFoo>(c => new Foo1());	//.SetLifetime(new TransientLifetime<IFoo>);

                // Act
                var result1 = container.Resolve<IFoo>();
                var result2 = container.Resolve<IFoo>();
                var result3 = container.Resolve<IFoo>();

                // Assert
                Assert.IsNotNull(result1);
                Assert.IsNotNull(result2);
                Assert.IsNotNull(result3);

                Assert.AreNotSame(result1, result2);
                Assert.AreNotSame(result2, result3);
                Assert.AreNotSame(result1, result3);

                Assert.IsInstanceOfType(result1, typeof(Foo1));
                Assert.IsInstanceOfType(result2, typeof(Foo1));
                Assert.IsInstanceOfType(result3, typeof(Foo1));
            }
        }

        public void TryResolveAllReturnsExpectedInstances()
        {
            using (var container = new IocContainer())
            {
                // Arrange
                var foo1 = new Foo1();
                var foo2 = new Foo2();
                var foo3 = new Foo2();
                var bar1 = new Bar1();

                container.RegisterInstance<IFoo>(foo1);
                container.RegisterInstance<IFoo>(foo2, "Foo1");
                container.RegisterInstance<IFoo>(foo3, "Foo2");
                container.RegisterInstance<IBar>(bar1);

                // Act
                var results = container.TryResolveAll<IFoo>();

                var resultList = results.ToList();

                // Assert
                Assert.IsTrue(results.Count() == 3);

                CollectionAssert.Contains(resultList, foo1);
                CollectionAssert.Contains(resultList, foo2);
                CollectionAssert.Contains(resultList, foo3);
            }
        }

 public void GenericResolveByNameNotRegisteredThrowsException2()
 {
     using (var container = new IocContainer())
     {
         container.Register<IFoo>(c => new Foo1());
         container.Resolve<IFoo>("Foo");
     }
 }

        protected void Application_Start()
        {
            IocContainer = new IocContainer();

            AreaRegistration.RegisterAllAreas();

            RegisterRoutes(RouteTable.Routes);
        }

 public void GetServiceTest2()
 {
     var type = typeof(DefaultService1);
     var container = new IocContainer();
     container.AddService(type, true);
     var childContainer = new IocContainer(container);
     Assert.Equal(childContainer.GetService(type), container.GetService(type));
 }

        public void AddService_TypeObjectBoolean_Test1()
        {
            var container = new IocContainer();
            container.AddService(typeof(IService2), new XService2());

            var childContainer = new IocContainer(container);
            Assert.IsAssignableFrom<XService2>(childContainer.GetService(typeof(IService2)));
        }

        public void CanSetProvider()
        {
            var resolver = new IocContainer();
            var locator = new DynamoServiceLocator(resolver);
            ServiceLocator.SetLocatorProvider(() => locator);

            // No way to get provider from ServiceLocator.Current to verify!!
        }

        public override void PrepareBasic()
        {
            this.container = new IocContainer();

            this.RegisterDummies();
            this.RegisterStandard();
            this.RegisterComplex();
        }

		public void ResolveAllByTypeNotRegisteredThrowsException()
		{
			using (var container = new IocContainer())
			{
				var results = container.ResolveAll<IFoo>();

				// Doesnt throw exception before it is enumerated because it uses yield return - OK ?
				var test = results.Count();
			}
		}