public void Configure_should_update_table_name_when_base_type_is_null()
        {
            var entityMappingConfiguration
                = new EntityMappingConfiguration
                      {
                          TableName = new DatabaseName("Foo")
                      };

            var entityTypeMapping = new EntityTypeMapping(null);

            entityTypeMapping.AddType(new EntityType("E", "N", DataSpace.CSpace));

            var databaseMapping =
                new DbDatabaseMapping().Initialize(new EdmModel(DataSpace.CSpace), new EdmModel(DataSpace.SSpace));

            var table = databaseMapping.Database.AddTable("foo");
            var entitySet = databaseMapping.Database.GetEntitySet(table);

            entityTypeMapping.AddFragment(new MappingFragment(entitySet, entityTypeMapping, false));
            
            entityMappingConfiguration.Configure(
                databaseMapping, databaseMapping.Model.Container.EntitySets,
                ProviderRegistry.Sql2008_ProviderManifest, entityTypeMapping.EntityType,
                ref entityTypeMapping, false, 0, 1,
                new Dictionary<string, object>());

            Assert.Equal("Foo", table.GetTableName().Name);
        }

        private static void GenerateForeignKeyAssociationType(
            AssociationType associationType, DbDatabaseMapping databaseMapping)
        {
            DebugCheck.NotNull(associationType);
            DebugCheck.NotNull(databaseMapping);
            Debug.Assert(associationType.Constraint != null);

            var dependentEnd = associationType.Constraint.DependentEnd;
            var principalEnd = associationType.GetOtherEnd(dependentEnd);
            var principalEntityTypeMapping = GetEntityTypeMappingInHierarchy(databaseMapping, principalEnd.GetEntityType());
            var dependentEntityTypeMapping = GetEntityTypeMappingInHierarchy(databaseMapping, dependentEnd.GetEntityType());

            var foreignKeyConstraint
                = new ForeignKeyBuilder(databaseMapping.Database, associationType.Name)
                    {
                        PrincipalTable =
                            principalEntityTypeMapping.MappingFragments.Single().Table,
                        DeleteAction = principalEnd.DeleteBehavior != OperationAction.None
                                           ? principalEnd.DeleteBehavior
                                           : OperationAction.None
                    };

            dependentEntityTypeMapping
                .MappingFragments
                .Single()
                .Table
                .AddForeignKey(foreignKeyConstraint);

            foreignKeyConstraint.DependentColumns = associationType.Constraint.ToProperties.Select(
                dependentProperty => dependentEntityTypeMapping.GetPropertyMapping(dependentProperty).ColumnProperty);

            foreignKeyConstraint.SetAssociationType(associationType);
        }

        public void Serialize(DbDatabaseMapping databaseMapping, XmlWriter xmlWriter)
        {
            DebugCheck.NotNull(xmlWriter);
            DebugCheck.NotNull(databaseMapping);
            Debug.Assert(databaseMapping.Model != null);
            Debug.Assert(databaseMapping.Database != null);

            _xmlWriter = xmlWriter;
            _databaseMapping = databaseMapping;
            _version = databaseMapping.Model.SchemaVersion;
            _namespace = Equals(_version, XmlConstants.EdmVersionForV3)
                             ? EdmXmlNamespaceV3
                             : (Equals(_version, XmlConstants.EdmVersionForV2) ? EdmXmlNamespaceV2 : EdmXmlNamespaceV1);

            _xmlWriter.WriteStartDocument();

            using (Element("Edmx", "Version", string.Format(CultureInfo.InvariantCulture, "{0:F1}", _version)))
            {
                WriteEdmxRuntime();
                WriteEdmxDesigner();
            }

            _xmlWriter.WriteEndDocument();
            _xmlWriter.Flush();
        }

        private static bool RemapsInheritedProperties(
            DbDatabaseMapping databaseMapping, StorageEntityTypeMapping entityTypeMapping)
        {
            var inheritedProperties = entityTypeMapping.EntityType.Properties
                                                       .Except(entityTypeMapping.EntityType.DeclaredProperties)
                                                       .Except(entityTypeMapping.EntityType.GetKeyProperties());

            foreach (var property in inheritedProperties)
            {
                var fragment = GetFragmentForPropertyMapping(entityTypeMapping, property);

                if (fragment != null)
                {
                    // find if this inherited property is mapped to another table by a base type
                    var baseType = (EntityType)entityTypeMapping.EntityType.BaseType;
                    while (baseType != null)
                    {
                        if (databaseMapping.GetEntityTypeMappings(baseType)
                                           .Select(baseTypeMapping => GetFragmentForPropertyMapping(baseTypeMapping, property))
                                           .Any(
                                               baseFragment => baseFragment != null
                                                               && baseFragment.Table != fragment.Table))
                        {
                            return true;
                        }
                        baseType = (EntityType)baseType.BaseType;
                    }
                }
            }
            return false;
        }

        public static void SyncNullabilityCSSpace(
            this ColumnMappingBuilder propertyMappingBuilder,
            DbDatabaseMapping databaseMapping,
            IEnumerable<EntitySet> entitySets,
            EntityType toTable)
        {
            DebugCheck.NotNull(propertyMappingBuilder);

            var property = propertyMappingBuilder.PropertyPath.Last();

            EntitySetMapping setMapping = null;

            var baseType = (EntityType)property.DeclaringType.BaseType;
            if (baseType != null)
            {
                setMapping = GetEntitySetMapping(databaseMapping, baseType, entitySets);
            }

            while (baseType != null)
            {
                if (toTable == setMapping.EntityTypeMappings.First(m => m.EntityType == baseType).GetPrimaryTable())
                {
                    // CodePlex 2254: If current table is part of TPH mapping below the TPT mapping we are processing, then
                    // don't change the nullability because the TPH nullability calculated previously is still correct.
                    return;
                }

                baseType = (EntityType)baseType.BaseType;
            }

            propertyMappingBuilder.ColumnProperty.Nullable = property.Nullable;
        }

        internal void WriteSchema(DbDatabaseMapping databaseMapping)
        {
            DebugCheck.NotNull(databaseMapping);

            WriteSchemaElementHeader();
            WriteDbModelElement(databaseMapping);
            WriteEndElement();
        }

        // <summary>
        // Initializes a new instance of the <see cref="DbModel" /> class.
        // </summary>
        internal DbModel(DbDatabaseMapping databaseMapping, DbModelBuilder modelBuilder)
        {
            DebugCheck.NotNull(databaseMapping);
            DebugCheck.NotNull(modelBuilder);

            _databaseMapping = databaseMapping;
            _cachedModelBuilder = modelBuilder;
        }

        private void WriteDbModelElement(DbDatabaseMapping databaseMapping)
        {
            DebugCheck.NotNull(databaseMapping);

            _entityTypeNamespace = databaseMapping.Model.NamespaceNames.SingleOrDefault();
            _dbSchemaName = databaseMapping.Database.Containers.Single().Name;

            WriteEntityContainerMappingElement(databaseMapping.EntityContainerMappings.First());
        }

        private static DbDatabaseMapping InitializeDatabaseMapping(EdmModel model)
        {
            DebugCheck.NotNull(model);

            var databaseMapping
                = new DbDatabaseMapping()
                    .Initialize(model, new EdmModel(DataSpace.SSpace, model.SchemaVersion));

            return databaseMapping;
        }

        public void Can_set_and_get_Model()
        {
            var mapping = new DbDatabaseMapping();
            
            Assert.Null(mapping.Model);

            var model = new EdmModel(DataSpace.CSpace);
            mapping.Model = model;

            Assert.Same(model, mapping.Model);
        }

        public void Can_set_and_get_Database()
        {
            var mapping = new DbDatabaseMapping();

            Assert.Null(mapping.Database);

            var storeModel = new EdmModel(DataSpace.SSpace);
            mapping.Database = storeModel;

            Assert.Same(storeModel, mapping.Database);
        }

        public void Can_add_container_mappings()
        {
            var mapping = new DbDatabaseMapping();

            Assert.Empty(mapping.EntityContainerMappings);

            var containerMapping = new EntityContainerMapping(new EntityContainer());
            mapping.AddEntityContainerMapping(containerMapping);

            Assert.Same(containerMapping, mapping.EntityContainerMappings.Single());
        }

        /// <summary>
        ///     Serialize the <see cref="DbModel" /> to the XmlWriter
        /// </summary>
        /// <param name="databaseMapping"> The DbModel to serialize </param>
        /// <param name="xmlWriter"> The XmlWriter to serialize to </param>
        public virtual bool Serialize(DbDatabaseMapping databaseMapping, XmlWriter xmlWriter)
        {
            Check.NotNull(databaseMapping, "databaseMapping");
            Check.NotNull(xmlWriter, "xmlWriter");

            var schemaWriter = new MslXmlSchemaWriter(xmlWriter, databaseMapping.Model.SchemaVersion);

            schemaWriter.WriteSchema(databaseMapping);

            return true;
        }

        void IDbMappingConvention.Apply(DbDatabaseMapping databaseMapping)
        {
            Check.NotNull(databaseMapping, "databaseMapping");

            databaseMapping.EntityContainerMappings
                           .SelectMany(ecm => ecm.AssociationSetMappings)
                           .Where(
                               asm => asm.AssociationSet.ElementType.IsManyToMany()
                                      && !asm.AssociationSet.ElementType.IsSelfReferencing())
                           .SelectMany(asm => asm.Table.ForeignKeyBuilders)
                           .Each(fk => fk.DeleteAction = OperationAction.Cascade);
        }

        // <summary>
        // Builds and stores the workspace based on the given code first configuration.
        // </summary>
        // <param name="databaseMapping"> The code first EDM model. </param>
        public CodeFirstCachedMetadataWorkspace(DbDatabaseMapping databaseMapping)
        {
            DebugCheck.NotNull(databaseMapping);

            _providerInfo = databaseMapping.ProviderInfo;
            _metadataWorkspace = databaseMapping.ToMetadataWorkspace();
            _assemblies = databaseMapping.Model.GetClrTypes().Select(t => t.Assembly()).Distinct().ToList();

            Debug.Assert(databaseMapping.Model.Containers.Count() == 1, "Expecting Code First to create only one container.");

            _defaultContainerName = databaseMapping.Model.Containers.First().Name;
        }

 internal static string SerializeToString(DbDatabaseMapping databaseMapping)
 {
     var edmx = new StringBuilder();
     new EdmxSerializer().Serialize(
         databaseMapping, 
         XmlWriter.Create(
             edmx, new XmlWriterSettings
                       {
                           Indent = true
                       }));
     return edmx.ToString();
 }

        private void GenerateEntityTypes(DbDatabaseMapping databaseMapping)
        {
            DebugCheck.NotNull(databaseMapping);

            foreach (var entityType in databaseMapping.Model.EntityTypes)
            {
                if (!entityType.Abstract)
                {
                    new TableMappingGenerator(_providerManifest).
                        Generate(entityType, databaseMapping);
                }
            }
        }

        public void UpdateEdmxFromModel_updates_csdl_ssdl_msl()
        {
            var inputXml = XDocument.Parse("<root />");
            var databaseMapping =
                new DbDatabaseMapping
                    {
                        Model = new EdmModel(DataSpace.CSpace),
                        Database = new EdmModel(DataSpace.SSpace)
                    };
            var model = new DbModel(databaseMapping, new DbModelBuilder());

            var mockEdmxHelper = new Mock<EdmxHelper>(inputXml);
            mockEdmxHelper.Setup(
                h => h.UpdateStorageModels(
                    It.Is<EdmModel>(m => m == databaseMapping.Database),
                    It.Is<string>(n => n == "storeNamespace"),
                    It.Is<DbProviderInfo>(i => i == model.ProviderInfo),
                    It.IsAny<List<EdmSchemaError>>()))
                .Returns(true);
            mockEdmxHelper.Setup(
                h => h.UpdateConceptualModels(
                    It.Is<EdmModel>(m => m == databaseMapping.Model),
                    It.Is<string>(n => n == "entityModelNamespace")))
                .Returns(true);
            mockEdmxHelper.Setup(
                h => h.UpdateMapping(
                    It.Is<DbModel>(m => m == model)))
                .Returns(true);
            mockEdmxHelper.Object.UpdateEdmxFromModel(
                model, "storeNamespace", "entityModelNamespace", new List<EdmSchemaError>());

            mockEdmxHelper
                .Verify(
                    h => h.UpdateStorageModels(
                        It.Is<EdmModel>(m => m == databaseMapping.Database),
                        It.Is<string>(n => n == "storeNamespace"),
                        It.Is<DbProviderInfo>(i => i == model.ProviderInfo),
                        It.IsAny<List<EdmSchemaError>>()), Times.Once());

            mockEdmxHelper
                .Verify(
                    h => h.UpdateConceptualModels(
                        It.Is<EdmModel>(m => m == databaseMapping.Model),
                        It.Is<string>(n => n == "entityModelNamespace")), Times.Once());

            mockEdmxHelper
                .Verify(
                    h => h.UpdateMapping(
                        It.Is<DbModel>(m => m == model)), Times.Once());
        }

        public static DbModel Build(SimpleMappingContext mappingContext)
        {
            Debug.Assert(mappingContext != null, "mappingContext != null");

            var databaseMapping =
                new DbDatabaseMapping
                    {
                        Database = mappingContext.StoreModel,
                        Model = BuildEntityModel(mappingContext)
                    };

            databaseMapping.AddEntityContainerMapping(BuildEntityContainerMapping(mappingContext));

            return new DbModel(databaseMapping, new DbModelBuilder());
        }

        private static void GenerateEntityTypes(DbDatabaseMapping databaseMapping)
        {
            DebugCheck.NotNull(databaseMapping);

            foreach (var entityType in databaseMapping.Model.EntityTypes)
            {
                if (entityType.Abstract
                    && databaseMapping.Model.EntityTypes.All(e => e.BaseType != entityType))
                {
                    throw new InvalidOperationException(Strings.UnmappedAbstractType(entityType.GetClrType()));
                }

                new TableMappingGenerator(databaseMapping.ProviderManifest).
                    Generate(entityType, databaseMapping);
            }
        }