public void CombinedSpecialTest()
		{
			DependencyInjectionContainer container = new DependencyInjectionContainer();

			container.Configure(c => c.Export<LazyService>().As<ILazyService>().WithMetadata("Hello", "World"));

			LazyService.Created = false;

			Lazy<Meta<ILazyService>> lazy = container.Locate<Lazy<Meta<ILazyService>>>();

			Assert.NotNull(lazy);
			Assert.False(LazyService.Created);

			Assert.NotNull(lazy.Value);
			Assert.NotNull(lazy.Value.Value);

			ILazyService service = lazy.Value.Value;

			Assert.NotNull(service);
			Assert.True(LazyService.Created);

			KeyValuePair<string, object> metadata = lazy.Value.Metadata.First();

			Assert.Equal("Hello", metadata.Key);
			Assert.Equal("World", metadata.Value);
		}

        /// <summary>
        /// Configures the default dependencies.
        /// </summary>
        /// <param name="dependencyInjectionContainer">The dependency injection container.</param>
        public void ConfigureDefaultDependencies(DependencyInjectionContainer dependencyInjectionContainer)
        {
            ExceptionUtilities.CheckArgumentNotNull(dependencyInjectionContainer, "dependencyInjectionContainer");

            foreach (var param in this.TestParameters)
            {
                dependencyInjectionContainer.TestParameters[param.Key] = param.Value;
            }

            // set up dependency injector
            dependencyInjectionContainer.RegisterCustomResolver(typeof(Logger), this.GetLoggerForType).Transient();
            dependencyInjectionContainer.RegisterInstance<IDependencyInjector>(dependencyInjectionContainer);
            dependencyInjectionContainer.InjectDependenciesInto(dependencyInjectionContainer);
            dependencyInjectionContainer.InjectDependenciesInto(this.implementationSelector);

            this.implementations = this.implementationSelector.GetImplementations(this.TestParameters).ToList();

            // only register dependencies that cannot already be resolved (unless the dependency was specified as a
            // test parameter, in which case override the default)
            foreach (var implInfo in this.implementations.Where(i => i.IsTestParameterSpecified || !dependencyInjectionContainer.CanResolve(i.ContractType)))
            {
                var options = dependencyInjectionContainer.Register(implInfo.ContractType, implInfo.ImplementationType);
                options.IsTransient = implInfo.IsTransient;
            }
        }

        public void BeginLifetimeScope()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(c => c.Export<DisposableService>().As<IDisposableService>().Lifestyle.SingletonPerScope());

            IDisposableService service = container.Locate<IDisposableService>();

            Assert.NotNull(service);

            bool called = false;

            using (var scope = container.BeginLifetimeScope())
            {
                var secondService = scope.Locate<IDisposableService>();

                Assert.NotNull(secondService);
                Assert.NotSame(service, secondService);
                Assert.Same(secondService, scope.Locate<IDisposableService>());

                secondService.Disposing += (sender, args) => called = true;
            }

            Assert.True(called);
        }

        public void FactoryFiveArgWithOutBasicAndOutOfOrderTest()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            BasicService basicService = new BasicService();

            container.Configure(c =>
                                {
                                    c.Export<FiveArgParameterService>().As<IArrayOfObjectsPropertyService>();
                                    c.ExportInstance(basicService).As<IBasicService>();
                                });

            FiveArgParameterService.ActivateWithOutBasicServiceAndOutOfOrder factory =
                container.Locate<FiveArgParameterService.ActivateWithOutBasicServiceAndOutOfOrder>();

            Assert.NotNull(factory);

            IArrayOfObjectsPropertyService instance = factory(14.0m, "Blah", 9.0, 5);

            Assert.NotNull(instance);
            Assert.Equal(5, instance.Parameters.Length);
            Assert.Equal("Blah", instance.Parameters[0]);
            Assert.Equal(5, instance.Parameters[1]);
            Assert.Equal(9.0, instance.Parameters[2]);
            Assert.Equal(14.0m, instance.Parameters[3]);
            Assert.Equal(basicService, instance.Parameters[4]);
        }

        public void OwnedLazyMetaTest()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(c => c.Export<DisposableService>().As<IDisposableService>().WithMetadata(
                "Hello",
                "World"));

            Owned<Lazy<Meta<IDisposableService>>> ownedLazy =
                container.Locate<Owned<Lazy<Meta<IDisposableService>>>>();

            Assert.NotNull(ownedLazy);
            Assert.NotNull(ownedLazy.Value);
            Assert.NotNull(ownedLazy.Value.Value);
            Assert.NotNull(ownedLazy.Value.Value.Value);

            bool disposedCalled = false;

            ownedLazy.Value.Value.Value.Disposing += (sender, args) => disposedCalled = true;

            ownedLazy.Dispose();

            Assert.True(disposedCalled);

            KeyValuePair<string, object> metadata = ownedLazy.Value.Value.Metadata.First();

            Assert.Equal("Hello", metadata.Key);
            Assert.Equal("World", metadata.Value);
        }

        public void BulkLocateWithKey()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(c => c.Export(Types.FromThisAssembly())
                                      .ByInterface<ISimpleObject>()
                                      .WithKey(t => t.Name.Last()));

            container.Configure(c =>
            {
                foreach (char ch in "ABCDE")
                {
                    c.Export<ImportSingleSimpleObject>()
                     .WithKey(ch)
                     .WithCtorParam<ISimpleObject>()
                     .LocateWithKey(ch);
                }
            });

            ImportSingleSimpleObject single = container.Locate<ImportSingleSimpleObject>(withKey: 'A');

            Assert.NotNull(single);
            Assert.IsType<SimpleObjectA>(single.SimpleObject);

            Assert.Equal(3, container.LocateAll<ImportSingleSimpleObject>(withKey: new[] { 'A', 'C', 'E' }).Count);
        }

		static int Main(string[] args)
		{
			DependencyInjectionContainer container = new DependencyInjectionContainer();

			container.Configure(c => c.Export(Types.FromThisAssembly()).
											   ByInterface(typeof(IExampleModule)).
											   ByInterface(typeof(IExampleSubModule<>)).
											   ByInterface(typeof(IExample<>)));

			IEnumerable<IExampleModule> exampleModules = container.LocateAll<IExampleModule>();

			try
			{
				foreach (IExampleModule exampleModule in exampleModules)
				{
					exampleModule.Execute();
				}
			}
			catch (Exception exp)
			{
				Console.WriteLine("Exception thrown");
				Console.WriteLine(exp.Message);

			    return -1;
			}

		    return 0;
		}

        /// <summary>
        /// Configures the dependencies for the test case.
        /// </summary>
        /// <param name="container">The container (private to the test case).</param>
        protected override void ConfigureDependencies(DependencyInjectionContainer container)
        {
            base.ConfigureDependencies(container);
#if WINDOWS_PHONE
            container.Register<IAuthenticationProvider, AnonymousAuthenticationProvider>();
#endif
            AstoriaTestServices.ConfigureDependencies(container);
        }

		public void ImportIInjectionScopeDiagnostic()
		{
			DependencyInjectionContainer container = new DependencyInjectionContainer();

			InjectionScopeDiagnostic diag = container.Locate<InjectionScopeDiagnostic>();

			Assert.Equal(0, diag.PossibleMissingDependencies.Count());
		}

 public GraceServiceLocator(DependencyInjectionContainer container)
 {
     if (container == null)
     {
         throw new ArgumentNullException("container");
     }
     this.container = container;
 }

        /// <summary>
        /// Default constructor
        /// </summary>
        /// <param name="container">container for the kernel manager</param>
        /// <param name="comparer">used to compare to export strategies for which one should be used</param>
        /// <param name="blackList">export strategy black list</param>
        public InjectionKernelManager(DependencyInjectionContainer container,
			ExportStrategyComparer comparer,
			BlackList blackList)
        {
            Container = container;

            this.comparer = comparer;
            this.blackList = blackList;
        }

        public void ConfigureWithXmlModulePropertySetTest()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.ConfigureWithXml();

            int intProperty = (int)container.Locate("IntProperty");

            Assert.Equal(5, intProperty);
        }

        public void ConfigureWithXmlModuleTest()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.ConfigureWithXml();

            IBasicService basicService = container.Locate<IBasicService>();

            Assert.NotNull(basicService);
        }

        public void AutoCreateTest()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(c => c.Export<BasicService>().As<IBasicService>());

            ImportConstructorService constructorService = container.Locate<ImportConstructorService>();

            Assert.NotNull(constructorService);
        }

        public void ConfigureWithXmlExportTest()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.ConfigureWithXml();

            IConstructorImportService importService = container.Locate<IConstructorImportService>();

            Assert.NotNull(importService);
        }

        public void InEnvironment()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer(ExportEnvironment.UnitTest);

            container.Configure(c => c.ExportAssembly(GetType().Assembly).InEnvironment(ExportEnvironment.RunTimeOnly));

            IEnumerable<ISimpleObject> simpleObjects = container.LocateAll<ISimpleObject>();

            Assert.NotNull(simpleObjects);
            Assert.Equal(0, simpleObjects.Count());
        }

        private static IDependencyInjectionContainer CreateDIContainer()
        {
            var container = new DependencyInjectionContainer { ThrowExceptions = false };

            container.Configure(
                registration => registration
                    .Export<PeopleService>()
                    .As<IPeopleService>());

            return container;
        }

        public void DebugConsoleLog()
        {
            Logger.SetLogService(new DebugConsoleLogService());

            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(c => c.Export<BasicService>().As<IBasicService>());

            IBasicService basicService = container.Locate<IBasicService>();

            Assert.NotNull(basicService);
        }

        public void SelectTypes()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(
                c => c.ExportAssembly(GetType().Assembly).ByInterface(typeof(ISimpleObject)).Select(TypesThat.EndWith("C")));

            IEnumerable<ISimpleObject> simpleObjects = container.LocateAll<ISimpleObject>();

            Assert.NotNull(simpleObjects);
            Assert.Equal(1, simpleObjects.Count());
        }

        public void ConfigureWithXmlThirdSectionWithShortNames()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.ConfigureWithXml("thirdGrace");

            IConstructorImportService importService = container.Locate<IConstructorImportService>();

            Assert.NotNull(importService);

            Assert.Equal(5, container.Locate("IntProperty"));
        }