public void CannotCreateSameServiceTypeTwiceSinceServicesAreSingletons()
        {
            TestableServiceCollection services = CreateServiceCollection();

            services.AddNew(typeof(MockDataObject));
            services.AddNew(typeof(MockDataObject));
        }
        public void CannotCreateSameServiceTypeTwiceSinceServicesAreSingletons_Generic()
        {
            TestableServiceCollection services = CreateServiceCollection();

            services.AddNew <MockDataObject>();
            services.AddNew <MockDataObject>();
        }
        public void RemovingServiceAllowsNewServiceToBeRegisteredForGivenServiceType_Generic()
        {
            TestableServiceCollection services = CreateServiceCollection();

            services.AddNew <object>();
            services.Remove <object>();
            services.AddNew <object>();
        }
        public void RemovingServiceAllowsNewServiceToBeRegisteredForGivenServiceType()
        {
            TestableServiceCollection services = CreateServiceCollection();

            services.AddNew(typeof(object));
            services.Remove(typeof(object));
            services.AddNew(typeof(object));
        }
        private WeakReference RemovingServiceRemovesStrongReferenceToService_TestHelper()
        {
            TestableServiceCollection services = CreateServiceCollection();
            WeakReference             wr       = new WeakReference(services.AddNew <object>());

            services.Remove(typeof(object));
            return(wr);
        }
        public void AddedServiceCanBeLocatedByTypeIDPair()
        {
            TestableServiceCollection collection = CreateServiceCollection();

            object obj = collection.AddNew <object>();

            Assert.AreSame(obj, collection.Locator.Get(new DependencyResolutionLocatorKey(typeof(object), null)));
        }
        public void CanCreateService_Generic()
        {
            TestableServiceCollection services = CreateServiceCollection();

            MockDataObject svc = services.AddNew <MockDataObject>();

            Assert.IsNotNull(svc);
            Assert.AreSame(svc, services.Get <MockDataObject>());
        }
        public void CanCreateService()
        {
            TestableServiceCollection services = CreateServiceCollection();

            object svc = services.AddNew(typeof(MockDataObject));

            Assert.IsNotNull(svc);
            Assert.AreSame(svc, services.Get(typeof(MockDataObject)));
        }
        public void RemovingItemRemovesTypeIdPairFromLocator()
        {
            TestableServiceCollection collection = CreateServiceCollection();
            object obj = collection.AddNew <object>();

            collection.Remove(typeof(object));

            Assert.IsNull(collection.Locator.Get(new DependencyResolutionLocatorKey(typeof(object), null)));
        }
        public void RemovingServiceRemovesStrongReferenceToService()
        {
            TestableServiceCollection services = CreateServiceCollection();
            WeakReference             wr       = new WeakReference(services.AddNew <object>());

            services.Remove(typeof(object));
            GC.Collect();

            Assert.IsNull(wr.Target);
        }
        public void CanCreateServiceInChildWhenServiceExistsInParent()
        {
            TestableServiceCollection services      = CreateServiceCollection();
            TestableServiceCollection childServices = new TestableServiceCollection(services);

            object parentService = services.AddNew(typeof(MockDataObject));
            object childService  = childServices.AddNew(typeof(MockDataObject));

            Assert.AreSame(parentService, services.Get(typeof(MockDataObject)));
            Assert.AreSame(childService, childServices.Get(typeof(MockDataObject)));
        }
        public void CanCreateServiceInChildWhenServiceExistsInParent_Generic()
        {
            TestableServiceCollection services      = CreateServiceCollection();
            TestableServiceCollection childServices = new TestableServiceCollection(services);

            MockDataObject parentService = services.AddNew <MockDataObject>();
            MockDataObject childService  = childServices.AddNew <MockDataObject>();

            Assert.AreSame(parentService, services.Get <MockDataObject>());
            Assert.AreSame(childService, childServices.Get <MockDataObject>());
        }
        public void RemovingServiceTwiceFiresEventOnce()
        {
            int EventFireCount = 0;
            TestableServiceCollection services = CreateServiceCollection();

            services.Removed += delegate { EventFireCount++; };
            services.AddNew <object>();
            services.Remove(typeof(object));
            services.Remove(typeof(object));

            Assert.AreEqual(1, EventFireCount);
        }
        public void RemovingServiceCausesItToBeTornDown_Generic()
        {
            TestableServiceCollection services = CreateServiceCollection();
            MockTearDownStrategy      strategy = new MockTearDownStrategy();

            services.Builder.Strategies.Add(strategy, WCSFBuilderStage.PreCreation);

            services.AddNew <object>();
            services.Remove <object>();

            Assert.IsTrue(strategy.TearDownCalled);
        }
        public void CreatingAServiceFiresEvent()
        {
            bool   EventFired     = false;
            object ServiceInEvent = null;
            TestableServiceCollection services = CreateServiceCollection();

            services.Added += delegate(object sender, DataEventArgs <object> e) { EventFired = true; ServiceInEvent = e.Data; };

            object obj = services.AddNew <object>();

            Assert.IsTrue(EventFired);
            Assert.AreSame(obj, ServiceInEvent);
        }
Exemple #16
0
        public void RemovingServiceRemovesStrongReferenceToService()
        {
            var wRef2 = CallInItsOwnScope(() =>
            {
                TestableServiceCollection services = CreateServiceCollection();
                WeakReference wr = new WeakReference(services.AddNew <object>());
                services.Remove(typeof(object));
                return(wr);
            });

            GC.Collect();

            Assert.IsNull(wRef2.Target);
        }
        public void CanCreateServiceInChildWhenServiceExistsInParent()
        {
            TestableServiceCollection services = CreateServiceCollection();
            TestableServiceCollection childServices = new TestableServiceCollection(services);

            object parentService = services.AddNew(typeof (MockDataObject));
            object childService = childServices.AddNew(typeof (MockDataObject));

            Assert.AreSame(parentService, services.Get(typeof (MockDataObject)));
            Assert.AreSame(childService, childServices.Get(typeof (MockDataObject)));
        }
        public void CanCreateServiceInChildWhenServiceExistsInParent_Generic()
        {
            TestableServiceCollection services = CreateServiceCollection();
            TestableServiceCollection childServices = new TestableServiceCollection(services);

            MockDataObject parentService = services.AddNew<MockDataObject>();
            MockDataObject childService = childServices.AddNew<MockDataObject>();

            Assert.AreSame(parentService, services.Get<MockDataObject>());
            Assert.AreSame(childService, childServices.Get<MockDataObject>());
        }