private void InitFactory(DefaultListableObjectFactory factory)
        {
            Console.WriteLine("init factory");
            RootObjectDefinition tee = new RootObjectDefinition(typeof(Tee), true);
            tee.IsLazyInit = true;
            ConstructorArgumentValues teeValues = new ConstructorArgumentValues();
            teeValues.AddGenericArgumentValue("test");
            tee.ConstructorArgumentValues = teeValues;

            RootObjectDefinition bar = new RootObjectDefinition(typeof(BBar), false);
            ConstructorArgumentValues barValues = new ConstructorArgumentValues();
            barValues.AddGenericArgumentValue(new RuntimeObjectReference("tee"));
            barValues.AddGenericArgumentValue(5);
            bar.ConstructorArgumentValues = barValues;

            RootObjectDefinition foo = new RootObjectDefinition(typeof(FFoo), false);
            MutablePropertyValues fooValues = new MutablePropertyValues();
            fooValues.Add("i", 5);
            fooValues.Add("bar", new RuntimeObjectReference("bar"));
            fooValues.Add("copy", new RuntimeObjectReference("bar"));
            fooValues.Add("s", "test");
            foo.PropertyValues = fooValues;

            factory.RegisterObjectDefinition("foo", foo);
            factory.RegisterObjectDefinition("bar", bar);
            factory.RegisterObjectDefinition("tee", tee);
        }

        public void DoesNotAcceptInfrastructureAdvisorsDuringScanning()
        {
            DefaultListableObjectFactory of = new DefaultListableObjectFactory();

            GenericObjectDefinition infrastructureAdvisorDefinition = new GenericObjectDefinition();
            infrastructureAdvisorDefinition.ObjectType = typeof (TestAdvisor);
            infrastructureAdvisorDefinition.PropertyValues.Add("Name", "InfrastructureAdvisor");
            infrastructureAdvisorDefinition.Role = ObjectRole.ROLE_INFRASTRUCTURE;
            of.RegisterObjectDefinition("infrastructure", infrastructureAdvisorDefinition);

            GenericObjectDefinition regularAdvisorDefinition = new GenericObjectDefinition();
            regularAdvisorDefinition.ObjectType = typeof (TestAdvisor);
            regularAdvisorDefinition.PropertyValues.Add("Name", "RegularAdvisor");
            //            regularAdvisorDefinition.Role = ObjectRole.ROLE_APPLICATION;
            of.RegisterObjectDefinition("regular", regularAdvisorDefinition);

            TestAdvisorAutoProxyCreator apc = new TestAdvisorAutoProxyCreator();
            apc.ObjectFactory = of;
            object[] advisors = apc.GetAdvicesAndAdvisorsForObject(typeof (object), "dummyTarget");
            Assert.AreEqual(1, advisors.Length);
            Assert.AreEqual( "RegularAdvisor", ((TestAdvisor)advisors[0]).Name );

            Assert.AreEqual(1, apc.CheckedAdvisors.Count);
            Assert.AreEqual("regular", apc.CheckedAdvisors[0]);
        }

        public void ClearWithDynamicProxies()
        {
            CompositionProxyTypeBuilder typeBuilder = new CompositionProxyTypeBuilder();
            typeBuilder.TargetType = typeof(TestObject);
            Type proxyType = typeBuilder.BuildProxyType();

            DefaultListableObjectFactory of = new DefaultListableObjectFactory();
            RootObjectDefinition od1 = new RootObjectDefinition(proxyType, false);
            od1.PropertyValues.Add("Name", "Bruno");
            of.RegisterObjectDefinition("testObject", od1);

            GenericApplicationContext ctx1 = new GenericApplicationContext(of);
            ContextRegistry.RegisterContext(ctx1);

            ITestObject to1 = ContextRegistry.GetContext().GetObject("testObject") as ITestObject;
            Assert.IsNotNull(to1);
            Assert.AreEqual("Bruno", to1.Name);

            DefaultListableObjectFactory of2 = new DefaultListableObjectFactory();
            RootObjectDefinition od2 = new RootObjectDefinition(proxyType, false);
            od2.PropertyValues.Add("Name", "Baia");
            of2.RegisterObjectDefinition("testObject", od2);
            GenericApplicationContext ctx2 = new GenericApplicationContext(of2);

            ContextRegistry.Clear();

            ITestObject to2 = ctx2.GetObject("testObject") as ITestObject;
            Assert.IsNotNull(to2);
            Assert.AreEqual("Baia", to2.Name);
        }

        /// <summary>
        /// Load all registered configuration into spring. This method should only be called internally by the FluentApplicationContext, i.e. you shouldn't call it.
        /// </summary>
        /// <param name="objectFactory">The object factory.</param>
        public static void LoadConfiguration(DefaultListableObjectFactory objectFactory)
        {
            // This check is mainly for backward compability and avoid people trying to register their configuration twice.
            if (!_configurationRegistry.ContainsConfiguration())
            {
                if (_assembliesList.Count == 0)
                {
                    _assembliesList.Add(() => AppDomain.CurrentDomain.GetAssemblies());
                }

                IList<Type> applicationContextConfigurerTypes = new List<Type>();
                // only load the configuration once (in case the assembly was registered twice)
                foreach (Type type in from assemblies in _assembliesList
                                      from assembly in assemblies()
                                      from type in assembly.GetTypes()
                                      where type.GetInterfaces().Contains(typeof (ICanConfigureApplicationContext))
                                      where !applicationContextConfigurerTypes.Contains(type)
                                      select type)
                {
                    applicationContextConfigurerTypes.Add(type);
                }
                // load each class containing configuration.
                foreach (ICanConfigureApplicationContext contextConfigurer in
                    applicationContextConfigurerTypes.Select(applicationContextConfigurerType => (ICanConfigureApplicationContext) Activator.CreateInstance(applicationContextConfigurerType)))
                {
                    contextConfigurer.Configure();
                }
            }

            _configurationRegistry.LoadObjectDefinitions(objectFactory);
        }

        protected void SetUp()
        {
            parent = new DefaultListableObjectFactory();
            IDictionary<string, object> m = new Dictionary<string, object>();
            m["name"] = "Albert";
            parent.RegisterObjectDefinition("father", new RootObjectDefinition(typeof(TestObject), new MutablePropertyValues(m)));
            m = new Dictionary<string, object>();
            m["name"] = "Roderick";
            parent.RegisterObjectDefinition("rod", new RootObjectDefinition(typeof(TestObject), new MutablePropertyValues(m)));

            // for testing dynamic ctor arguments + parent.GetObject() call propagation 
            parent.RegisterObjectDefinition("namedfather", new RootObjectDefinition(typeof(TestObject), false));
            parent.RegisterObjectDefinition("typedfather", new RootObjectDefinition(typeof(TestObject), false));

            // add unsupported IObjectDefinition implementation...
            //UnsupportedObjectDefinitionImplementation unsupportedDefinition = new UnsupportedObjectDefinitionImplementation();
            //parent.RegisterObjectDefinition("unsupportedDefinition", unsupportedDefinition);

            XmlObjectFactory factory;
            factory = new XmlObjectFactory(new ReadOnlyXmlTestResource("test.xml", GetType()), parent);

            // TODO: should this be allowed?
            //this.factory.RegisterObjectDefinition("typedfather", new RootObjectDefinition(typeof(object), false));
            factory.AddObjectPostProcessor(new AnonymousClassObjectPostProcessor());
            factory.AddObjectPostProcessor(new LifecycleObject.PostProcessor());

            factory.PreInstantiateSingletons();
            base.ObjectFactory = factory;
        }

            private static NamedObjectDefinition Find( string url, string objectName )
            {
                DefaultListableObjectFactory of = new DefaultListableObjectFactory();
                RootObjectDefinition rod = new RootObjectDefinition( typeof( Type1 ) );
                of.RegisterObjectDefinition( objectName, rod );

                return FindWebObjectDefinition( url, of );
            }

 public void Can_Create_Custom_Scan_Routine()
 {
     var scanner = new ScanOverridingAssemblyObjectDefinitionScanner();
     var registry = new DefaultListableObjectFactory();
     scanner.ScanAndRegisterTypes(registry);
     Assert.That(registry.ObjectDefinitionCount, Is.EqualTo(1), "found multiple definitions");
     Assert.That(registry.GetObject<ComponentScan.ScanComponentsAndAddToContext.ConfigurationImpl>(), Is.Not.Null,
                 "correct single defintion was not registered");
 }

 protected override void LoadObjectDefinitions(DefaultListableObjectFactory objectFactory)
 {
     //wrap the objectFactory with our own proxy so that we keep track of the objects ids defined in the Spring.NET context
     callbacks.Add(new BeanohObjectFactoryMethodInterceptor(objectFactory));
     ProxyGenerator generator = new ProxyGenerator();
     DefaultListableObjectFactory wrapper = (DefaultListableObjectFactory)generator.CreateClassProxy(objectFactory.GetType(), callbacks.ToArray());
     //delegate to our proxy
     base.LoadObjectDefinitions(wrapper);
 }

        public void CanCreateHostTwice()
        {
            DefaultListableObjectFactory of = new DefaultListableObjectFactory();

            string svcRegisteredName = System.Guid.NewGuid().ToString();

            of.RegisterObjectDefinition(svcRegisteredName, new RootObjectDefinition(new RootObjectDefinition(typeof(Service))));
            SpringServiceHost ssh = new SpringServiceHost(svcRegisteredName, of, true);
            SpringServiceHost ssh1 = new SpringServiceHost(svcRegisteredName, of, true);
        }

 public virtual void StaticEventWiring()
 {
     DefaultListableObjectFactory factory = new DefaultListableObjectFactory();
     XmlObjectDefinitionReader reader = new XmlObjectDefinitionReader(factory);
     reader.LoadObjectDefinitions(new ReadOnlyXmlTestResource("event-wiring.xml", GetType()));
     TestEventHandler staticHandler = factory["staticEventListener"] as TestEventHandler;
     // raise the event... handlers should be notified at this point (obviously)
     TestObject.OnStaticClick();
     Assert.IsTrue(staticHandler.EventWasHandled,
                   "The instance handler did not get notified when the static event was raised (and was probably not wired up in the first place).");
 }

        protected override void AddPersistenceExceptionTranslation(ProxyFactory pf, IPersistenceExceptionTranslator pet)
        {
            if (AttributeUtils.FindAttribute(pf.TargetType, typeof(RepositoryAttribute)) != null)
            {
                DefaultListableObjectFactory of = new DefaultListableObjectFactory();
                of.RegisterObjectDefinition("peti", new RootObjectDefinition(typeof(PersistenceExceptionTranslationInterceptor)));
                of.RegisterSingleton("pet", pet);
                pf.AddAdvice((PersistenceExceptionTranslationInterceptor) of.GetObject("peti"));

            }
        }

 public void BailsIfTargetNotFound()
 {
     using (DefaultListableObjectFactory of = new DefaultListableObjectFactory())
     {
         SaoExporter saoExporter = new SaoExporter();
         saoExporter.ObjectFactory = of;
         saoExporter.TargetName = "DOESNOTEXIST";
         saoExporter.ServiceName = "RemotedSaoSingletonCounter";
         saoExporter.AfterPropertiesSet();
     }
 }

 public virtual void EventWiringInstanceSinkToPrototypeSource()
 {
     DefaultListableObjectFactory factory = new DefaultListableObjectFactory();
     XmlObjectDefinitionReader reader = new XmlObjectDefinitionReader(factory);
     reader.LoadObjectDefinitions(new ReadOnlyXmlTestResource("event-wiring-prototypes.xml", GetType()));
     TestEventHandler instanceHandler = factory["instanceSink"] as TestEventHandler;
     ITestObject source = factory["source"] as ITestObject;
     // raise the event... handlers should be notified at this point (obviously)
     source.OnClick();
     Assert.IsTrue(instanceHandler.EventWasHandled,
                   "The instance handler did not get notified when the instance event was raised (and was probably not wired up in the first place).");
 }

        public void ProxyObjectWithoutInterface()
        {
            DefaultListableObjectFactory of = new DefaultListableObjectFactory();
            of.RegisterObjectDefinition("bar", new RootObjectDefinition(typeof(ObjectWithoutInterface)));

            TestAutoProxyCreator apc = new TestAutoProxyCreator(of);
            of.AddObjectPostProcessor(apc);

            ObjectWithoutInterface o = of.GetObject("bar") as ObjectWithoutInterface;
            Assert.IsTrue(AopUtils.IsAopProxy(o));
            o.Foo();
            Assert.AreEqual(1, apc.NopInterceptor.Count);
        }

		public void SetUp()
		{
			_singletonDefinition = new RootObjectDefinition(typeof (TestObject), AutoWiringMode.No);
			_singletonDefinitionWithFactory = new RootObjectDefinition(_singletonDefinition);
			_singletonDefinitionWithFactory.FactoryMethodName = "GetObject";
			_singletonDefinitionWithFactory.FactoryObjectName = "TestObjectFactoryDefinition";
			_testObjectFactory = new RootObjectDefinition(typeof (TestObjectFactory), AutoWiringMode.No);
			DefaultListableObjectFactory myFactory = new DefaultListableObjectFactory();
			myFactory.RegisterObjectDefinition("SingletonObjectDefinition", SingletonDefinition);
			myFactory.RegisterObjectDefinition("SingletonDefinitionWithFactory", SingletonDefinitionWithFactory);
			myFactory.RegisterObjectDefinition("TestObjectFactoryDefinition", TestObjectFactoryDefinition);
			_factory = myFactory;
		}

        public void ConvertsWriteConcernCorrectly()
        {
            DefaultListableObjectFactory factory = new DefaultListableObjectFactory();
            factory.RegisterCustomConverter(typeof(WriteConcern), new WriteConcernTypeConverter());

            RootObjectDefinition definition = new RootObjectDefinition(typeof(MongoFactoryObject));
            definition.PropertyValues.Add("Url", "mongodb://localhost");
            definition.PropertyValues.Add("WriteConcern", "Acknowledged");
            factory.RegisterObjectDefinition("factory", definition);

            MongoFactoryObject obj = factory.GetObject<MongoFactoryObject>("&factory");
            Assert.That(ReflectionUtils.GetInstanceFieldValue(obj, "_writeConcern"),
                        Is.EqualTo(WriteConcern.Acknowledged));
        }

        public void ExportSingleton()
        {
            using (DefaultListableObjectFactory of = new DefaultListableObjectFactory())
            {
                of.RegisterSingleton("simpleCounter", new SimpleCounter());
                SaoExporter saoExporter = new SaoExporter();
                saoExporter.ObjectFactory = of;
                saoExporter.TargetName = "simpleCounter";
                saoExporter.ServiceName = "RemotedSaoSingletonCounter";
                saoExporter.AfterPropertiesSet();
                of.RegisterSingleton("simpleCounterExporter", saoExporter); // also tests SaoExporter.Dispose()!

                AssertExportedService(saoExporter.ServiceName, 2);
            }
        }

        public void Test()
        {
            int numIterations = 10000;
            start = DateTime.Now;
            DefaultListableObjectFactory factory = new DefaultListableObjectFactory();
            InitFactory(factory);
            for (int i = 0; i < numIterations; i++)
            {
              FFoo foo = (FFoo)factory.GetObject("foo");
            }
            stop = DateTime.Now;
            double timeElapsed = Elapsed;
            PrintTest("Creations", numIterations, timeElapsed);


        }

        public void ShouldAllowConfigurationClassInheritance()
        {
            var factory = new DefaultListableObjectFactory();
            factory.RegisterObjectDefinition("DerivedConfiguration", new GenericObjectDefinition
                                                                         {
                                                                             ObjectType = typeof(DerivedConfiguration)
                                                                         });

            var processor = new ConfigurationClassPostProcessor();

            processor.PostProcessObjectFactory(factory);

            // we should get singleton instances only
            TestObject testObject = (TestObject) factory.GetObject("DerivedDefinition");
            string singletonParent = (string) factory.GetObject("BaseDefinition");

            Assert.That(testObject.Value, Is.SameAs(singletonParent));
        }

		public void SunnyDayReplaceMethod()
		{
			RootObjectDefinition replacerDef = new RootObjectDefinition(typeof (NewsFeedFactory));

			RootObjectDefinition managerDef = new RootObjectDefinition(typeof (ReturnsNullNewsFeedManager));
			managerDef.MethodOverrides.Add(new ReplacedMethodOverride("CreateNewsFeed", "replacer"));

			DefaultListableObjectFactory factory = new DefaultListableObjectFactory();
			factory.RegisterObjectDefinition("manager", managerDef);
			factory.RegisterObjectDefinition("replacer", replacerDef);
			INewsFeedManager manager = (INewsFeedManager) factory["manager"];
			NewsFeed feed1 = manager.CreateNewsFeed();
			Assert.IsNotNull(feed1, "The CreateNewsFeed() method is not being replaced.");
			Assert.AreEqual(NewsFeedFactory.DefaultName, feed1.Name);
			NewsFeed feed2 = manager.CreateNewsFeed();
			// NewsFeedFactory always yields a new NewsFeed (see class definition below)...
			Assert.IsFalse(ReferenceEquals(feed1, feed2));
		}