public void Can_NOT_be_plugged_in_if_plugged_type_cannot_be_cast_to_the_plugin_type()
        {
            var instance = new ConfiguredInstance(typeof (ColorRule));
            var family = new PluginFamily(typeof (IWidget));

            instance.As<IDiagnosticInstance>().CanBePartOfPluginFamily(family).ShouldBeFalse();
        }

 public void can_build_a_simple_class_type()
 {
     var instance = new ConfiguredInstance(typeof (Rule1));
     var rule = instance.Build<Rule>(_session);
     rule.ShouldNotBeNull();
     rule.ShouldBeOfType<Rule1>();
 }

        public void get_the_default_instance_when_it_exists()
        {
            var instance = new ConfiguredInstance(typeof (Service<>));
            family.SetDefault(instance);

            configuration.Default.ConcreteType.ShouldEqual(typeof (Service<>));
        }

        /// <summary>
        /// Convenience method that sets the default concrete type of the PluginType.  The "concreteType"
        /// can only accept types that do not have any primitive constructor arguments.
        /// StructureMap has to know how to construct all of the constructor argument types.
        /// </summary>
        /// <param name="concreteType"></param>
        /// <returns></returns>
        public ConfiguredInstance Use(Type concreteType)
        {
            var instance = new ConfiguredInstance(concreteType);
            Use(instance);

            return instance;
        }

        public void can_set_scope_directly_on_the_instance()
        {
            var i1 = new ConfiguredInstance(GetType()).Named("foo");
            i1.SetLifecycleTo(Lifecycles.ThreadLocal);

            i1.Lifecycle.ShouldBeOfType<ThreadLocalStorageLifecycle>();
        }

        public void can_use_a_configured_instance_with_generic_template_type_and_arguments()
        {
            var instance = new ConfiguredInstance(typeof (Service2<>), typeof (string));
            var container = new Container();

            container.GetInstance<IService<string>>(instance).ShouldBeOfType(typeof (Service2<string>));
        }

 public static void LoadAppropriateStoreRegistry(IContainer initContainer)
 {
     var store = initContainer.GetInstance<IRRConfiguration>().ContentStore;
     if (store == Configuration.Store.SqlServerStore)
     {
         var sqlAssembly = Assembly.Load("RequestReduce.SqlServer");
         initContainer.Configure(x =>
                                     {
                                         x.For(sqlAssembly.GetType("RequestReduce.SqlServer.IFileRepository"))
                                             .Use(
                                                 sqlAssembly.GetType(
                                                     "RequestReduce.SqlServer.FileRepository"));
                                         var diskStore =
                                             new ConfiguredInstance(
                                                 sqlAssembly.GetType("RequestReduce.SqlServer.SqlServerStore"));
                                         var diskCache =
                                             new ConfiguredInstance(
                                                 sqlAssembly.GetType("RequestReduce.SqlServer.DbDiskCache"));
                                         x.For<LocalDiskStore>().Singleton()
                                             .Use(diskCache);
                                         diskStore.CtorDependency<LocalDiskStore>("fileStore").Is(
                                             initContainer.GetInstance<LocalDiskStore>());
                                         diskStore.CtorDependency<IUriBuilder>("uriBuilder").Is(
                                             initContainer.GetInstance<IUriBuilder>());
                                         diskStore.CtorDependency<IReductionRepository>("reductionRepository").Is(
                                             initContainer.GetInstance<IReductionRepository>());
                                         x.For<IStore>().LifecycleIs(new RRHybridLifecycle())
                                             .Use(diskStore);
                                     });
     }
     else
         initContainer.Configure(x => x.AddRegistry<RRLocalStoreRegistry>());
 }

 public InstanceMementoPropertyReader(ConfiguredInstance instance, InstanceMemento memento,
     PluginGraph pluginGraph, Type pluginType)
 {
     _instance = instance;
     _memento = memento;
     _pluginGraph = pluginGraph;
     _pluginType = pluginType;
 }

        public void get_settable_properties()
        {
            IConfiguredInstance instance
                = new ConfiguredInstance(typeof(GuyWithProperties));

            instance.SettableProperties()
                .Single().Name.ShouldBe("Widget");
        }

        public void BuildRule1()
        {
            var instance = new ConfiguredInstance(typeof (Rule1));

            var rule = (Rule) instance.Build(typeof (Rule), _session);
            Assert.IsNotNull(rule);
            Assert.IsTrue(rule is Rule1);
        }

        public void Can_be_plugged_in_if_there_is_a_plugged_type_and_the_plugged_type_can_be_cast_to_the_plugintype()
        {
            var instance = new ConfiguredInstance(typeof (ColorWidget));
            var family = new PluginFamily(typeof (IWidget));

            IDiagnosticInstance diagnosticInstance = instance;
            Assert.IsTrue(diagnosticInstance.CanBePartOfPluginFamily(family));
        }

        /// <summary>
        /// Shortcut method to add an additional Instance to this Plugin Type
        /// as just a Concrete Type.  This will only work if the Concrete Type
        /// has no primitive constructor or mandatory Setter arguments.
        /// </summary>
        /// <param name="concreteType"></param>
        /// <returns></returns>
        public ConfiguredInstance Add(Type concreteType)
        {
            var instance = new ConfiguredInstance(concreteType);

            alterAndContinue(family => family.AddInstance(instance));

            return instance;
        }

        public void instance_key_is_predictable()
        {
            var i1 = new ConfiguredInstance(GetType()).Named("foo");
            var i2 = new ConfiguredInstance(GetType()).Named("bar");

            i1.InstanceKey(GetType()).ShouldEqual(i1.InstanceKey(GetType()));
            i2.InstanceKey(GetType()).ShouldEqual(i2.InstanceKey(GetType()));
            i1.InstanceKey(GetType()).ShouldNotEqual(i2.InstanceKey(GetType()));
            i1.InstanceKey(typeof(InstanceUnderTest)).ShouldNotEqual(i1.InstanceKey(GetType()));
        }

        public void still_chooses_PerRequest_if_nothing_is_selected_on_either_family_or_instance()
        {
            var family = new PluginFamily(GetType());

            var i1 = new ConfiguredInstance(GetType()).Named("foo");

            family.AddInstance(i1);

            i1.Lifecycle.ShouldBeOfType<TransientLifecycle>();
        }

        public void build_fails_with_StructureMapException_adds_context()
        {
            var instance = new ConfiguredInstance(typeof(ClassThatBlowsUp));

            var actual =
                Exception<StructureMapBuildException>.ShouldBeThrownBy(() => { instance.Build<ClassThatBlowsUp>(); });

            actual.Message.ShouldContain(instance.Description);
            actual.ShouldBeOfType<StructureMapBuildException>();
        }

        public void set_to_singleton()
        {
            // SAMPLE: set-iconfigured-instance-to-SingletonThing
            IConfiguredInstance instance 
                = new ConfiguredInstance(typeof (WidgetHolder));

            instance.Singleton();

            instance.Lifecycle.ShouldBeOfType<SingletonLifecycle>();
            // ENDSAMPLE
        }

        public void get_instance_if_the_object_does_not_already_exist()
        {
            var instance = new ConfiguredInstance(typeof (Foo));

            var foo = new Foo();

            theResolver.Stub(x => x.ResolveFromLifecycle(typeof (IFoo), instance)).Return(foo);


            theCache.GetObject(typeof (IFoo), instance, new TransientLifecycle()).ShouldBeTheSameAs(foo);
        }

        public void Import_an_instance_from_the_default_profile()
        {
            var source = new ProfileManager();
            var sourceInstance = new ConfiguredInstance(typeof (AWidget));
            source.SetDefault(PROFILE, typeof (IWidget), sourceInstance);

            var destination = new ProfileManager();
            destination.DefaultProfileName = PROFILE;
            destination.ImportFrom(source);

            Assert.AreSame(sourceInstance, destination.GetDefault(typeof (IWidget)));
        }

        public void Import_the_default_does_not_impact_the_source()
        {
            var source = new ProfileManager();
            var sourceInstance = new ConfiguredInstance(typeof (AWidget));
            source.SetDefault(typeof (IWidget), sourceInstance);

            var destination = new ProfileManager();
            destination.ImportFrom(source);
            destination.SetDefault(typeof (IWidget), new ObjectInstance(new AWidget()));

            Assert.AreSame(sourceInstance, source.GetDefault(typeof (IWidget)));
        }

        public void get_default_if_it_does_not_already_exist()
        {
            var instance = new ConfiguredInstance(typeof (Foo));
            thePipeline.Stub(x => x.GetDefault(typeof (IFoo))).Return(instance);

            var foo = new Foo();

            theResolver.Stub(x => x.ResolveFromLifecycle(typeof (IFoo), instance)).Return(foo);

            theCache.GetDefault(typeof (IFoo), thePipeline)
                    .ShouldBeTheSameAs(foo);
        }