private void validateInstance(IDiagnosticInstance instance, PluginFamily family, PluginGraph graph)
 {
     if (!instance.CanBePartOfPluginFamily(family))
     {
         graph.Log.RegisterError(104, instance.CreateToken(), family.PluginType);
     }
 }

        public GraphBuilder(PluginGraph pluginGraph)
        {
            _pluginGraph = pluginGraph;
            _assemblyScanner = new AssemblyScanner();

            _instanceReader = new XmlInstanceReader(_pluginGraph.Log, new Registry());
        }

 public PluginGraphBuilder(ConfigurationParser[] parsers, Registry[] registries, GraphLog log)
 {
     _parsers = parsers;
     _registries = registries;
     _graph = new PluginGraph();
     _graph.Log = log;
 }

        public void transient_cache_of_nested_pipeline_graph_is_a_stateful_cache()
        {
            var plugins = new PluginGraph();

            var pipeline = PipelineGraph.BuildRoot(plugins);
            pipeline.ToNestedGraph().Transients.ShouldBeOfType<LifecycleObjectCache>();
        }

        public void Read_in_a_class_with_primitive_arrays()
        {
            string xml = @"
<Instance>
    <numbers Values='1,2,3'/>
    <strings Values='1,2,3'/>
</Instance>
";

            XmlElement element = DataMother.BuildDocument(xml).DocumentElement;
            element.SetAttribute("PluggedType", typeof (ClassWithStringAndIntArray).AssemblyQualifiedName);

            var memento = new XmlAttributeInstanceMemento(element);
            var graph = new PluginGraph();
            Instance instance = memento.ReadInstance(typeof (ClassWithStringAndIntArray));

            Assert.Fail("NWO");

//            var theObject = (ClassWithStringAndIntArray) instance.Build(typeof (ClassWithStringAndIntArray),
//                                                                        BuildSession.ForPluginGraph(graph));
//
//            theObject.Numbers.ShouldEqual(new[] {1, 2, 3});
//            theObject.Strings.ShouldEqual(new[] {"1", "2", "3"});
//
//            Debug.WriteLine(theObject.GetType().AssemblyQualifiedName);
        }

        public void Apply(PluginGraph graph)
        {
            var registry = new Registry();

            _interfaces.Each(@interface =>
            {
                var expression = registry.For(@interface);
                ConfigureFamily(expression);

                var exactMatches = _concretions.Where(x => x.CanBeCastTo(@interface)).ToArray();
                if (exactMatches.Length == 1)
                {
                    expression.Use(exactMatches.Single());
                }
                else
                {
                    exactMatches.Each(type => expression.Add(type));
                }


                if ([email protected]())
                {
                    addConcretionsThatCouldBeClosed(@interface, expression);
                }
            });

            _concretions.Each(t => graph.ConnectedConcretions.Fill(t));
            registry.As<IPluginGraphConfiguration>().Configure(graph);
        }

            public void Process(Type type, PluginGraph graph)
            {
                if (!IsConcrete(type)) return;

                if (type.Name.EndsWith("Actor") && type.Implements<AsyncHttpActor>())
                    graph.AddType(typeof(AsyncHttpActor), type);
            }

        public void build_root_for_tracked_transients()
        {
            var pluginGraph = new PluginGraph { TransientTracking = TransientTracking.ExplicitReleaseMode };
            var graph = PipelineGraph.BuildRoot(pluginGraph);

            graph.Transients.ShouldBeOfType<TrackingTransientCache>();
        }

        public IPipelineGraph NewChild()
        {
            var childGraph = new PluginGraph();
            var instances = new ComplexInstanceGraph(_root, childGraph, ContainerRole.ProfileOrChild);

            return new PipelineGraph(childGraph, instances, _root, _root.Singletons, _root.Transients);
        }

        public void Seal_does_not_throw_an_exception_if_there_are_no_errors()
        {
            var graph = new PluginGraph();
            Assert.AreEqual(0, graph.Log.ErrorCount);

            graph.Seal();
        }

 private static void ThrowIfMarkerInterfaceIsRegistered(PluginGraph graph)
 {
     if (graph.HasFamily<IMarkerInterface>())
     {
         throw new InvalidOperationException("Populate should only be called once per container.");
     }
 }

        public void AssertErrors_throws_StructureMapConfigurationException_if_there_is_an_error()
        {
            var graph = new PluginGraph();
            graph.Log.RegisterError(400, new ApplicationException("Bad!"));

            graph.Log.AssertFailures();
        }

        private void addCloseGenericPolicyTo(PluginGraph graph)
        {
            var policy = new CloseGenericFamilyPolicy(graph);
            graph.AddFamilyPolicy(policy);

            graph.Profiles.Each(addCloseGenericPolicyTo);
        }

    public PluginFamily(Type pluginType, PluginGraph parent)
    {
        _parent = parent;
            _pluginType = pluginType;

            PluginFamilyAttribute.ConfigureFamily(this);
    }

        public void build_root_for_default_tracking_style()
        {
            var pluginGraph = new PluginGraph {TransientTracking = TransientTracking.DefaultNotTrackedAtRoot};
            var graph = PipelineGraph.BuildRoot(pluginGraph);

            graph.Transients.ShouldBeOfType<NulloTransientCache>();
        }

        public void transient_cache_by_default_is_a_nullo()
        {
            var plugins = new PluginGraph();

            var pipeline = new RootPipelineGraph(plugins);
            pipeline.Transients.ShouldBeOfType<NulloTransientCache>();
        }

 public RootPipelineGraph(PluginGraph pluginGraph)
 {
     _pluginGraph = pluginGraph;
     _transientCache = new NulloTransientCache();
     _profiles =
         new Cache<string, IPipelineGraph>(
             name => new ComplexPipelineGraph(this, _pluginGraph.Profile(name), new NulloTransientCache()));
 }

        public void default_lifecycle_is_explicitly_set()
        {
            var graph = new PluginGraph();
            graph.Families[typeof(IGateway)].SetLifecycleTo<SingletonLifecycle>();

            var root = new RootInstanceGraph(graph);
            root.DefaultLifecycleFor(typeof(IGateway)).ShouldBeOfType<SingletonLifecycle>();
        }

        public void default_lifecycle_is_null_if_family_has_no_lifecycle()
        {
            var graph = new PluginGraph();
            graph.Families[typeof (IGateway)].SetDefault(new SmartInstance<StubbedGateway>());

            var root = new RootInstanceGraph(graph);
            root.DefaultLifecycleFor(typeof(IGateway)).ShouldBeNull();
        }

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