public void ContainerShouldUseFirstRegisteredDependencyOfTypeByDefault_EmailRegisteredFirst() { IKernel kernel = new DefaultKernel(); kernel.AddComponent("email", typeof(IAlarmSender), typeof(EmailSender)); kernel.AddComponent("sms", typeof(IAlarmSender), typeof(SmsSender)); kernel.AddComponent("generator", typeof(AlarmGenerator)); AlarmGenerator gen = (AlarmGenerator)kernel["generator"]; Assert.AreEqual(typeof(EmailSender), gen.Sender.GetType()); }
public void UsingPropertyWithPrivateSetter() { IKernel container = new DefaultKernel(); container.AddComponent("service1", typeof(IService1), typeof(Service1)); container.AddComponent("service2", typeof(IService2), typeof(Service2)); Service2 service2 = (Service2)container.Resolve<IService2>(); Assert.IsNull(service2.S,"Kernel should ignore private setter properties"); }
public void ComponentGraph() { IKernel kernel = new DefaultKernel(); kernel.AddSubSystem(SubSystemConstants.NamingKey, new NamingPartsSubSystem()); kernel.AddComponent("common:key1=true", typeof(ICommon), typeof(CommonImpl1)); kernel.AddComponent("common:secure=true", typeof(ICommon), typeof(CommonImpl2)); GraphNode[] nodes = kernel.GraphNodes; Assert.IsNotNull(nodes); Assert.AreEqual(2, nodes.Length); }
public void ServiceLookup() { IKernel kernel = new DefaultKernel(); kernel.AddSubSystem(SubSystemConstants.NamingKey, new NamingPartsSubSystem()); kernel.AddComponent("common:key1=true", typeof(ICommon), typeof(CommonImpl1)); kernel.AddComponent("common:secure=true", typeof(ICommon), typeof(CommonImpl2)); ICommon common = kernel[typeof(ICommon)] as ICommon; Assert.IsNotNull(common); Assert.AreEqual(typeof(CommonImpl1), common.GetType()); }
public void GetAssignableHandlers() { IKernel kernel = new DefaultKernel(); kernel.AddSubSystem(SubSystemConstants.NamingKey, new NamingPartsSubSystem()); kernel.AddComponent("common:key1=true", typeof(ICommon), typeof(CommonImpl1)); kernel.AddComponent("common:secure=true", typeof(ICommon), typeof(CommonImpl2)); IHandler[] handlers = kernel.GetAssignableHandlers(typeof(ICommon)); Assert.IsNotNull(handlers); Assert.AreEqual(2, handlers.Length); }
public void EmptyDelegateReturnsFirstTypeLoaded() { IKernel kernel = new DefaultKernel(); kernel.AddSubSystem(SubSystemConstants.NamingKey, new KeySearchNamingSubSystem()); kernel.AddComponent("1.common", typeof(ICommon), typeof(CommonImpl1)); kernel.AddComponent("2.common", typeof(ICommon), typeof(CommonImpl2)); ICommon common = kernel[typeof(ICommon)] as ICommon; Assert.IsNotNull(common); Assert.AreEqual(typeof(CommonImpl1), common.GetType()); }
public void ReturnsFirstMatchingType() { IKernel kernel = new DefaultKernel(); kernel.AddSubSystem(SubSystemConstants.NamingKey, new KeySearchNamingSubSystem(delegate(string key) { return key.StartsWith("1"); })); kernel.AddComponent("1.common", typeof(ICommon), typeof(CommonImpl1)); kernel.AddComponent("11.common", typeof(ICommon), typeof(CommonImpl2)); ICommon common = kernel[typeof(ICommon)] as ICommon; Assert.IsNotNull(common); Assert.AreEqual(typeof(CommonImpl1), common.GetType()); }
public void ReturnsCorrectType() { IKernel kernel = new DefaultKernel(); kernel.AddSubSystem(SubSystemConstants.NamingKey, new KeySearchNamingSubSystem( delegate(string key) { return key.StartsWith("castlestronghold.com"); })); kernel.AddComponent("castleproject.org.common", typeof(ICommon), typeof(CommonImpl1)); kernel.AddComponent("castlestronghold.com.common", typeof(ICommon), typeof(CommonImpl2)); ICommon common = kernel[typeof(ICommon)] as ICommon; Assert.IsNotNull(common); Assert.AreEqual(typeof(CommonImpl2), common.GetType()); }
public void TransientMultipleConstructorNonValueTypeTest() { DefaultKernel container = new DefaultKernel(); container.AddComponent("FooBar", typeof(FooBarNonValue)); Tester1 bla1 = new Tester1("FOOBAR"); Tester2 bla2 = new Tester2(666); Hashtable arguments1 = new Hashtable(); arguments1.Add("test1", bla1); Hashtable arguments2 = new Hashtable(); arguments2.Add("test2", bla2); object a = container.Resolve(typeof(FooBarNonValue), arguments1); object b = container.Resolve(typeof(FooBarNonValue), arguments2); Assert.AreNotSame(a, b, "A should not be B"); // multi resolve test a = container.Resolve(typeof(FooBarNonValue), arguments1); b = container.Resolve(typeof(FooBarNonValue), arguments2); Assert.AreNotSame(a, b, "A should not be B"); }
public void MaxSize() { IKernel kernel = new DefaultKernel(); kernel.AddComponent("a", typeof(PoolableComponent1)); ArrayList instances = new ArrayList(); instances.Add(kernel["a"] as PoolableComponent1); instances.Add(kernel["a"] as PoolableComponent1); instances.Add(kernel["a"] as PoolableComponent1); instances.Add(kernel["a"] as PoolableComponent1); instances.Add(kernel["a"] as PoolableComponent1); PoolableComponent1 other1 = kernel["a"] as PoolableComponent1; Assert.IsNotNull(other1); Assert.IsTrue(!instances.Contains(other1)); foreach (object inst in instances) { kernel.ReleaseComponent(inst); } kernel.ReleaseComponent(other1); PoolableComponent1 other2 = kernel["a"] as PoolableComponent1; Assert.IsNotNull(other2); Assert.IsTrue(other1 != other2); Assert.IsTrue(instances.Contains(other2)); kernel.ReleaseComponent(other2); }
public void SimpleUsage() { IKernel kernel = new DefaultKernel(); kernel.AddComponent("a", typeof(PoolableComponent1)); PoolableComponent1 inst1 = kernel["a"] as PoolableComponent1; PoolableComponent1 inst2 = kernel["a"] as PoolableComponent1; Assert.IsNotNull(inst1); Assert.IsNotNull(inst2); kernel.ReleaseComponent(inst2); kernel.ReleaseComponent(inst1); PoolableComponent1 other1 = kernel["a"] as PoolableComponent1; PoolableComponent1 other2 = kernel["a"] as PoolableComponent1; Assert.IsNotNull(other1); Assert.IsNotNull(other2); Assert.AreSame(inst1, other1); Assert.AreSame(inst2, other2); kernel.ReleaseComponent(inst2); kernel.ReleaseComponent(inst1); }
public void MaxSize() { IKernel kernel = new DefaultKernel(); kernel.AddComponent("a", typeof(PoolableComponent1)); ArrayList instances = new ArrayList(); instances.Add(kernel["a"] as PoolableComponent1); instances.Add(kernel["a"] as PoolableComponent1); instances.Add(kernel["a"] as PoolableComponent1); instances.Add(kernel["a"] as PoolableComponent1); instances.Add(kernel["a"] as PoolableComponent1); PoolableComponent1 other1 = kernel["a"] as PoolableComponent1; Assert.IsNotNull(other1); Assert.IsTrue(!instances.Contains(other1)); foreach(object inst in instances) { kernel.ReleaseComponent(inst); } kernel.ReleaseComponent(other1); PoolableComponent1 other2 = kernel["a"] as PoolableComponent1; Assert.IsNotNull(other2); Assert.IsTrue(other1 != other2); Assert.IsTrue(instances.Contains(other2)); kernel.ReleaseComponent(other2); }
public void Should_not_fail_when_constructor_parameter_and_public_property_with_private_setter_have_same_name() { IKernel kernel = new DefaultKernel(); kernel.AddComponent<Service2>(); kernel.AddComponent<Service1>(); try { Service2 svc = kernel.Resolve<Service2>(); Assert.IsNotNull(svc); } catch (NullReferenceException) { Assert.Fail("Should not have thrown a NullReferenceException"); } }
public void AddingComponentToRootKernelWhenChildKernelHasStartableFacility() { IKernel kernel = new DefaultKernel(); IKernel childKernel = new DefaultKernel(); kernel.AddChildKernel(childKernel); childKernel.AddFacility("StartableFacility", new StartableFacility()); kernel.AddComponent("string", typeof(String)); // exception here }
public void Public_property_with_Protected_setter_causes_Object_Reference_exception() { IKernel kernel = new DefaultKernel(); kernel.AddComponent<Presenter>(); kernel.AddComponent<View>(); try { Presenter p = (Presenter)kernel.Resolve(typeof(Presenter)); Assert.IsNotNull(p); } catch (NullReferenceException) { Assert.Fail("Should not have thrown a NullReferenceException"); } }
public void ParentKernelFindsAndCreateChildComponent() { IKernel subkernel = new DefaultKernel(); subkernel.AddComponent("templateengine", typeof(DefaultTemplateEngine)); kernel.AddChildKernel(subkernel); Assert.IsFalse(kernel.HasComponent(typeof(DefaultTemplateEngine))); object engine = kernel[typeof(DefaultTemplateEngine)]; }
public void ChildDependenciesIsSatisfiedEvenWhenComponentTakesLongToBeAddedToParentContainer() { DefaultKernel container = new DefaultKernel(); DefaultKernel childContainer = new DefaultKernel(); container.AddChildKernel(childContainer); childContainer.AddComponent("component", typeof(Component)); container.AddComponent("service1", typeof(IService), typeof(Service)); Component comp = (Component) childContainer[typeof(Component)]; }
private static IKernel InitializeContainer() { IKernel container = new DefaultKernel(); container.AddComponentInstance <AccountRepository>( typeof(IAccountRepository), new AccountRepository( Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "DinDin"))); container.AddComponent <AccountServices>(typeof(IAccountServices), LifestyleType.Singleton, true); return(container); }
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); }
public void TransientMultiConstructorTest() { DefaultKernel container = new DefaultKernel(); container.AddComponent("FooBar", typeof(FooBar)); Hashtable arguments1 = new Hashtable(); arguments1.Add("integer", 1); Hashtable arguments2 = new Hashtable(); arguments2.Add("datetime", DateTime.Now.AddDays(1)); object a = container.Resolve(typeof(FooBar), arguments1); object b = container.Resolve(typeof(FooBar), arguments2); Assert.AreNotSame(a, b, "A should not be B"); }
public void KernelSerialization() { IKernel kernel = new DefaultKernel(); kernel.AddComponent("key", typeof(CustomerImpl)); Assert.IsTrue(kernel.HasComponent("key")); MemoryStream stream = new MemoryStream(); BinaryFormatter formatter = new BinaryFormatter(); formatter.Serialize(stream, kernel); stream.Position = 0; IKernel desKernel = (IKernel) formatter.Deserialize(stream); Assert.IsTrue(desKernel.HasComponent("key")); }
public void ChildDependenciesSatisfiedAmongContainers() { IKernel subkernel = new DefaultKernel(); kernel.AddComponent("templateengine", typeof(DefaultTemplateEngine)); kernel.AddComponent("mailsender", typeof(DefaultMailSenderService)); kernel.AddChildKernel(subkernel); subkernel.AddComponent("spamservice", typeof(DefaultSpamService)); DefaultSpamService spamservice = (DefaultSpamService) subkernel["spamservice"]; Assert.IsNotNull(spamservice); Assert.IsNotNull(spamservice.MailSender); Assert.IsNotNull(spamservice.TemplateEngine); }
public void DependenciesSatisfiedAmongContainers() { IKernel subkernel = new DefaultKernel(); kernel.AddComponent("mailsender", typeof(DefaultMailSenderService)); kernel.AddComponent("templateengine", typeof(DefaultTemplateEngine)); kernel.AddChildKernel(subkernel); subkernel.AddComponent("spamservice", typeof(DefaultSpamService)); DefaultSpamService spamservice = (DefaultSpamService)subkernel["spamservice"]; Assert.IsNotNull(spamservice); Assert.IsNotNull(spamservice.MailSender); Assert.IsNotNull(spamservice.TemplateEngine); }
public void TestInterfaceBasedStartable() { IKernel kernel = new DefaultKernel(); kernel.AddFacility("startable", new StartableFacility()); kernel.AddComponent("a", typeof(StartableComponent)); StartableComponent component = kernel["a"] as StartableComponent; Assert.IsNotNull(component); Assert.IsTrue(component.Started); Assert.IsFalse(component.Stopped); kernel.ReleaseComponent(component); Assert.IsTrue(component.Stopped); }
public void WillAskResolverWhenTryingToResolveDependencyAfterAnotherHandlerWasRegistered() { FooBarResolver resolver = new FooBarResolver(); IKernel kernel = new DefaultKernel(); kernel.Resolver.AddSubResolver(resolver); kernel.AddComponent("foo", typeof(Foo)); IHandler handler = kernel.GetHandler("foo"); Assert.AreEqual(HandlerState.WaitingDependency, handler.CurrentState); resolver.Result = 15; kernel.RaiseHandlerRegistered(null);//should force reevaluation of state Assert.AreEqual(HandlerState.Valid, handler.CurrentState); }
public void SameLevelDependenciesSatisfied() { IKernel child = new DefaultKernel(); kernel.AddComponent("templateengine", typeof(DefaultTemplateEngine)); kernel.AddComponent("spamservice", typeof(DefaultSpamService)); kernel.AddChildKernel(child); child.AddComponent("mailsender", typeof(DefaultMailSenderService)); DefaultSpamService spamservice = (DefaultSpamService) child["spamservice"]; Assert.IsNotNull(spamservice); Assert.IsNotNull(spamservice.MailSender); Assert.IsNotNull(spamservice.TemplateEngine); }
public void KernelSerialization() { IKernel kernel = new DefaultKernel(); kernel.AddComponent("key", typeof(CustomerImpl)); Assert.IsTrue(kernel.HasComponent("key")); MemoryStream stream = new MemoryStream(); BinaryFormatter formatter = new BinaryFormatter(); formatter.Serialize(stream, kernel); stream.Position = 0; IKernel desKernel = (IKernel)formatter.Deserialize(stream); Assert.IsTrue(desKernel.HasComponent("key")); }
public void When_attemting_to_resolve_component_with_nonpublic_ctor_should_throw_meaningfull_exception() { IKernel kernel = new DefaultKernel(); kernel.AddComponent<WithNonPublicCtor>(); bool exceptionThrown = false; try { WithNonPublicCtor svc = kernel.Resolve<WithNonPublicCtor>(); Assert.IsNotNull(svc); } catch (ComponentActivatorException exception) { ComponentActivatorException inner = exception.InnerException as ComponentActivatorException; Assert.IsNotNull(inner); StringAssert.Contains("public", inner.Message, "Exception should say that constructor has to be public."); exceptionThrown = true; } Assert.IsTrue(exceptionThrown, "A {0} should have been thrown.", typeof(ComponentActivatorException).Name); }
public void TestComponentWithNoInterface() { IKernel kernel = new DefaultKernel(); 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.AddComponent("b", typeof(NoInterfaceStartableComponent)); 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 void MultiThreaded_RemoveResolve_Throws_When_LargeRatio_Of_ComponentsToService() { int threadCount = 1000; ArrayList list = ArrayList.Synchronized(new ArrayList()); Random rand = new Random(); ManualResetEvent waitEvent = new ManualResetEvent(false); IKernel kernel = new DefaultKernel(); kernel.AddSubSystem(SubSystemConstants.NamingKey, new KeySearchNamingSubSystem(delegate { return false; })); kernel.AddComponent("common", typeof(ICommon), typeof(CommonImpl1)); WaitCallback resolveThread = delegate { waitEvent.WaitOne(); while(threadCount > 0 && list.Count == 0) { try { ICommon common = kernel[typeof(ICommon)] as ICommon; } catch(Exception e) { list.Add(e); } } }; ThreadPool.QueueUserWorkItem(resolveThread); WaitCallback removeThread = delegate { waitEvent.WaitOne(); kernel.RemoveComponent(threadCount + ".common"); Interlocked.Decrement(ref threadCount); }; for(int i = 0; i < threadCount; i++) { kernel.AddComponent(i + ".common", typeof(ICommon), typeof(CommonImpl1)); ThreadPool.QueueUserWorkItem(removeThread); } waitEvent.Set(); while(threadCount > 0 && list.Count == 0) { Thread.Sleep(15); } if (list.Count > 0) { throw (Exception) list[0]; } }
public void UseChildComponentsForParentDependenciesWhenRequestedFromChild() { IKernel subkernel = new DefaultKernel(); kernel.AddComponent("spamservice", typeof(DefaultSpamService), LifestyleType.Transient); kernel.AddComponent("mailsender", typeof(DefaultMailSenderService)); kernel.AddComponent("templateengine", typeof(DefaultTemplateEngine)); kernel.AddChildKernel(subkernel); subkernel.AddComponent("templateengine", typeof(DefaultTemplateEngine)); DefaultTemplateEngine templateengine = (DefaultTemplateEngine) kernel["templateengine"]; DefaultTemplateEngine sub_templateengine = (DefaultTemplateEngine) subkernel["templateengine"]; DefaultSpamService spamservice = (DefaultSpamService) subkernel["spamservice"]; Assert.AreNotEqual(spamservice.TemplateEngine, templateengine); Assert.AreEqual(spamservice.TemplateEngine, sub_templateengine); spamservice = (DefaultSpamService) kernel["spamservice"]; Assert.AreNotEqual(spamservice.TemplateEngine, sub_templateengine); Assert.AreEqual(spamservice.TemplateEngine, templateengine); kernel.RemoveComponent("templateengine"); spamservice = (DefaultSpamService) kernel["spamservice"]; Assert.IsNull(spamservice.TemplateEngine); }
public void AddingDependencyToServiceWithCustomDependency() { DefaultKernel k = new DefaultKernel(); k.AddComponent("NeedClassWithCustomerDependency",typeof(NeedClassWithCustomerDependency)); k.AddComponent("HasCustomDependency", typeof(HasCustomDependency)); Assert.AreEqual(HandlerState.WaitingDependency, k.GetHandler("HasCustomDependency").CurrentState); Hashtable hash = new Hashtable(); hash["name"] = new CompA(); k.RegisterCustomDependencies("HasCustomDependency", hash); Assert.AreEqual(HandlerState.Valid, k.GetHandler("HasCustomDependency").CurrentState); Assert.IsNotNull(k.Resolve(typeof(NeedClassWithCustomerDependency))); }
public void Singleton_WithNonSingletonDependencies_DoesNotReResolveDependencies() { kernel.AddComponent("spamservice", typeof(DefaultSpamService)); kernel.AddComponent("mailsender", typeof(DefaultMailSenderService)); IKernel subkernel1 = new DefaultKernel(); subkernel1.AddComponent("templateengine", typeof(DefaultTemplateEngine)); kernel.AddChildKernel(subkernel1); IKernel subkernel2 = new DefaultKernel(); subkernel2.AddComponent("templateengine", typeof(DefaultTemplateEngine), LifestyleType.Transient); kernel.AddChildKernel(subkernel2); DefaultTemplateEngine templateengine1 = (DefaultTemplateEngine) subkernel1["templateengine"]; DefaultSpamService spamservice1 = (DefaultSpamService) subkernel1["spamservice"]; Assert.IsNotNull(spamservice1); Assert.AreEqual(spamservice1.TemplateEngine.Key, templateengine1.Key); DefaultTemplateEngine templateengine2 = (DefaultTemplateEngine) subkernel2["templateengine"]; DefaultSpamService spamservice2 = (DefaultSpamService) subkernel2["spamservice"]; Assert.IsNotNull(spamservice2); Assert.AreEqual(spamservice1, spamservice2); Assert.AreEqual(spamservice1.TemplateEngine.Key, templateengine1.Key); Assert.AreNotEqual(spamservice2.TemplateEngine.Key, templateengine2.Key); }
public void ComponentUnregistersProperly() { IKernel kernel = new DefaultKernel(); kernel.AddSubSystem(SubSystemConstants.NamingKey, new KeySearchNamingSubSystem(delegate(string key) { return key.StartsWith("2"); })); kernel.AddComponent("1.common", typeof(ICommon), typeof(CommonImpl1)); kernel.AddComponent("2.common", typeof(ICommon), typeof(CommonImpl2)); ICommon common = kernel[typeof(ICommon)] as ICommon; Assert.IsNotNull(common); Assert.AreEqual(typeof(CommonImpl2), common.GetType()); kernel.RemoveComponent("2.common"); common = kernel[typeof(ICommon)] as ICommon; Assert.IsNotNull(common); Assert.AreEqual(typeof(CommonImpl1), common.GetType()); kernel.RemoveComponent("1.common"); Assert.AreEqual(0, kernel.GetHandlers(typeof(ICommon)).Length); }
public void MultiThreadedAddResolve([Values(100)] int threadCount) { object locker = new object(); IList<string> list = new List<string>(); ManualResetEvent waitEvent = new ManualResetEvent(false); IKernel kernel = new DefaultKernel(); kernel.AddSubSystem(SubSystemConstants.NamingKey, new KeySearchNamingSubSystem()); kernel.AddComponent("common", typeof(ICommon), typeof(CommonImpl1)); WaitCallback resolveThread = delegate { waitEvent.WaitOne(); while(threadCount > 0 && list.Count == 0) { try { ICommon common = kernel[typeof(ICommon)] as ICommon; } catch(Exception e) { lock (locker) { list.Add(e.ToString()); } } } }; ThreadPool.QueueUserWorkItem(resolveThread); WaitCallback addThread = delegate { waitEvent.WaitOne(); kernel.AddComponent(Guid.NewGuid() + ".common", typeof(ICommon), typeof(CommonImpl1)); Interlocked.Decrement(ref threadCount); }; for(int i = 0; i < threadCount; i++) { ThreadPool.QueueUserWorkItem(addThread); } waitEvent.Set(); while(threadCount > 0 && list.Count == 0) { Thread.Sleep(15); } if (list.Count > 0) { Assert.Fail(list[0].ToString()); } }
public void MultiThreadedAddResolve() { int threadCount = 100; ArrayList list = ArrayList.Synchronized(new ArrayList()); Random rand = new Random(); ManualResetEvent waitEvent = new ManualResetEvent(false); IKernel kernel = new DefaultKernel(); kernel.AddSubSystem(SubSystemConstants.NamingKey, new KeySearchNamingSubSystem()); kernel.AddComponent("common", typeof(ICommon), typeof(CommonImpl1)); WaitCallback resolveThread = delegate { waitEvent.WaitOne(); while(threadCount > 0 && list.Count == 0) { try { ICommon common = kernel[typeof(ICommon)] as ICommon; } catch(Exception e) { list.Add(e.ToString()); } } }; ThreadPool.QueueUserWorkItem(resolveThread); WaitCallback addThread = delegate { waitEvent.WaitOne(); kernel.AddComponent(rand.Next() + ".common", typeof(ICommon), typeof(CommonImpl1)); Interlocked.Decrement(ref threadCount); }; for(int i = 0; i < threadCount; i++) { ThreadPool.QueueUserWorkItem(addThread); } waitEvent.Set(); while(threadCount > 0 && list.Count == 0) { Thread.Sleep(15); } if (list.Count > 0) { Assert.Fail(list[0].ToString()); } }