public void TestComponentWithNoInterface()
		{
			IKernel kernel = new DefaultKernel();
			kernel.ComponentCreated += new ComponentInstanceDelegate(OnNoInterfaceStartableComponentStarted);

			MutableConfiguration compNode = new MutableConfiguration("component");
			compNode.Attributes["id"] = "b";
			compNode.Attributes["startable"] = "true";
			compNode.Attributes["startMethod"] = "Start";
			compNode.Attributes["stopMethod"] = "Stop";

			kernel.ConfigurationStore.AddComponentConfiguration("b", compNode);

			kernel.AddFacility("startable", new StartableFacility());
			kernel.Register(Component.For(typeof(NoInterfaceStartableComponent)).Named("b"));

			Assert.IsTrue(startableCreatedBeforeResolved, "Component was not properly started");

			NoInterfaceStartableComponent component = kernel["b"] as NoInterfaceStartableComponent;

			Assert.IsNotNull(component);
			Assert.IsTrue(component.Started);
			Assert.IsFalse(component.Stopped);

			kernel.ReleaseComponent(component);
			Assert.IsTrue(component.Stopped);
		}

 public static ICollection<IHandler> SimulateRegistration(this IRegistration reg)
 {
     using (var kernel = new DefaultKernel()) {
         kernel.Register(reg);
         return kernel.GetAssignableHandlers(typeof (object));
     }
 }

		public void MissingManifestResourceConfiguration()
		{
			var store = new DefaultConfigurationStore();
			var source = new AssemblyResource("assembly://Castle.Windsor.Tests/missing_config.xml");
			IKernel kernel = new DefaultKernel();
			new XmlInterpreter(source).ProcessResource(source, store, kernel);
		}

		public void ProperDeserialization()
		{
			var store = new DefaultConfigurationStore();
			var interpreter = new XmlInterpreter(new ConfigResource());
			IKernel kernel = new DefaultKernel();
			interpreter.ProcessResource(interpreter.Source, store, kernel);

			Assert.AreEqual(2, store.GetFacilities().Length);
			Assert.AreEqual(4, store.GetComponents().Length);

			var config = store.GetFacilityConfiguration(typeof(NoopFacility).FullName);
			var childItem = config.Children["item"];
			Assert.IsNotNull(childItem);
			Assert.AreEqual("value", childItem.Value);

			config = store.GetFacilityConfiguration(typeof(Noop2Facility).FullName);
			Assert.IsNotNull(config);
			Assert.AreEqual("value within CDATA section", config.Value);

			config = store.GetComponentConfiguration("testidcomponent1");
			childItem = config.Children["item"];
			Assert.IsNotNull(childItem);
			Assert.AreEqual("value1", childItem.Value);

			config = store.GetComponentConfiguration("testidcomponent2");
			childItem = config.Children["item"];
			Assert.IsNotNull(childItem);
			Assert.AreEqual("value2", childItem.Value);
		}

		public void Starts_component_without_start_method()
		{
			ClassWithInstanceCount.InstancesCount = 0;
			IKernel kernel = new DefaultKernel();
			kernel.AddFacility<StartableFacility>(f => f.DeferredTryStart());
			kernel.Register(Component.For<ClassWithInstanceCount>().Start());
			Assert.AreEqual(1, ClassWithInstanceCount.InstancesCount);
		}

        public void current_property_exposes_the_correct_resolver()
        {
            var kernel = new DefaultKernel();
            var resolver = new CastleDependencyResolver(kernel);

            GlobalHost.DependencyResolver = resolver;

            Assert.That(CastleDependencyResolver.Current, Is.EqualTo(GlobalHost.DependencyResolver));
        }

        public void tt()
        {
            var kernel = new DefaultKernel();
            kernel.Register(AllTypes.Pick()
                                   .FromAssembly(Assembly.GetExecutingAssembly())
                                   .WithService.FirstInterface());

            kernel.Resolve<ISomeInterface>();
        }

        public void get_service_returns_null_for_unregistered_service()
        {
            var kernel = new DefaultKernel();
            var resolver = new CastleDependencyResolver(kernel);

            var service = resolver.GetService(typeof(object));

            Assert.That(service, Is.Null);
        }

        public void get_services_returns_empty_enumerable_for_unregistered_service()
        {
            var kernel = new DefaultKernel();
            var resolver = new CastleDependencyResolver(kernel);

            var services = resolver.GetServices(typeof(object));

            Assert.That(services.Count(), Is.EqualTo(0));
        }

 protected void Application_Start(object sender, EventArgs e) {
     var kernel = new DefaultKernel();
     kernel.Register(Component.For<HttpContextBase>()
                         .LifeStyle.Transient
                         .UsingFactoryMethod(() => new HttpContextWrapper(HttpContext.Current)));
     kernel.Register(Component.For<SomeService>()
         .LifeStyle.HybridPerWebRequestTransient());
     kernel.Resolve<SomeService>();
 }

		public static void Main(string[] args)
		{
			IKernel kernel = new DefaultKernel();
			
			kernel.AddFacility("non.opt.props", new NonOptionalPropertiesFacility());
			
			kernel.AddComponent("sql.connmng", typeof(SqlConnectionManager));
			
			SqlConnectionManager connManager = (SqlConnectionManager) kernel["sql.connmng"];
		}

		public void AddChildKernelToTwoParentsThrowsException()
		{
			IKernel kernel2 = new DefaultKernel();

			IKernel subkernel = new DefaultKernel();

			Kernel.AddChildKernel(subkernel);
			Assert.AreEqual(Kernel, subkernel.Parent);

			kernel2.AddChildKernel(subkernel);
		}

 public void Kernel_should_select_ctor_with_available_dependencies()
 {
     var kernel = new DefaultKernel();
     kernel.AddComponent<Service>();
     kernel.AddComponent<ComponentX>();
     kernel.AddComponent<ComponentY>();
     var service = kernel.Resolve<Service>();
     Assert.IsNull(service.A);
     Assert.IsNotNull(service.X);
     Assert.IsNotNull(service.Y);
 }

        public virtual void Should_Dispose_From_Containers()
        {
            DefaultKernel disposableKernel = new DefaultKernel();
            using (var disposableLocater = new SiegeContainer(new WindsorAdapter.WindsorAdapter(disposableKernel)))
            {
                disposableLocater.Register(Given<ITestInterface>.Then<TestCase1>());
                Assert.IsTrue(disposableLocater.GetInstance<ITestInterface>() is TestCase1);
            }

            Assert.IsFalse(disposableKernel.HasComponent(typeof(ITestInterface)));
        }

        public void get_services_returns_registered_service()
        {
            var kernel = new DefaultKernel();
            kernel.Register(Component.For<object>().Instance(new object()));

            var resolver = new CastleDependencyResolver(kernel);

            var services = resolver.GetServices(typeof(object));

            Assert.That(services.Count(), Is.EqualTo(1));
        }

		public void CorrectConfigurationMapping()
		{
			var store = new DefaultConfigurationStore();
			var interpreter = new XmlInterpreter(Xml.Embedded("sample_config.xml"));
			IKernel kernel = new DefaultKernel();
			interpreter.ProcessResource(interpreter.Source, store, kernel);

			var container = new WindsorContainer(store);
			var facility = container.Kernel.GetFacilities().OfType<HiperFacility>().Single();
			Assert.IsTrue(facility.Initialized);
		}

		public void ComponentIdGetsLoadedFromTheParsedConfiguration()
		{
			var store = new DefaultConfigurationStore();
			var interpreter = new XmlInterpreter(Xml.Embedded("sample_config_with_spaces.xml"));
			IKernel kernel = new DefaultKernel();
			interpreter.ProcessResource(interpreter.Source, store, kernel);

			var container = new WindsorContainer(store);

			var handler = container.Kernel.GetHandler(typeof(ICalcService));
			Assert.AreEqual(Core.LifestyleType.Transient, handler.ComponentModel.LifestyleType);
		}

		public void FacilityConfig_is_not_null()
		{
			using (var c = new DefaultKernel())
			{
				const string facilityKey = "hiper";
				var config = new MutableConfiguration("facility");
				c.ConfigurationStore.AddFacilityConfiguration(facilityKey, config);
				var facility = new HiperFacility();
				c.AddFacility(facilityKey, facility);
				Assert.IsTrue(facility.Initialized);
			}
		}

        public void DoesNotResolveArraysByDefault()
        {
            var kernel = new DefaultKernel();

            kernel.Register(
                Component.For<Thing>(),
                Component.For<ISubThing>().ImplementedBy<First>(),
                Component.For<ISubThing>().ImplementedBy<Second>(),
                Component.For<ISubThing>().ImplementedBy<Third>()
                );

            var thing = kernel.Resolve<Thing>();
        }

		public void LoadWindsorAssembly()
		{
			IKernel kernel = new DefaultKernel();
			kernel.AddComponent( "A", typeof(AssemblyResolverComponent) );
			
			AssemblyResolverComponent comp = (AssemblyResolverComponent) kernel["A"];
			comp.Start();

			Type windsor = Type.GetType( 
				"Castle.Windsor.WindsorContainer, Castle.Windsor", false, false );
			
			Assert.IsNotNull(windsor);
		}