private void CsdlXElementComparer(IEnumerable<XElement> expectedCsdls, IEnumerable<XElement> actualCsdls, EdmVersion version)
        {
            var updatedExpectedCsdls = ModelBuilderHelpers.ReplaceCsdlNamespacesForEdmVersion(expectedCsdls.ToArray(), version);
            var updatedActualCsdls = ModelBuilderHelpers.ReplaceCsdlNamespacesForEdmVersion(actualCsdls.ToArray(), version);

            new ConstructiveApiCsdlXElementComparer().Compare(updatedExpectedCsdls.ToList(), updatedActualCsdls.ToList());
        }

        public static XElement[] InvalidEntitySetNameReference(EdmVersion edmVersion)
        {
            const string csdl =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""Bork"" Alias=""Self"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
  <EntityType Name=""Entity1"">
    <Key>
        <PropertyRef Name=""Id"" />
    </Key>
    <Property Name=""Id"" Type=""Int32"" Nullable=""false""/>
    <Property Name=""OtherId"" Type=""Int32"" />
    <NavigationProperty Name=""Navigation"" Type=""Bork.Entity2"" Nullable=""false"" Partner=""Navigation"" /> 
  </EntityType>
  <EntityType Name=""Entity2"">
    <Key>
        <PropertyRef Name=""Id"" />
    </Key>
    <Property Name=""Id"" Type=""Int32"" Nullable=""false""/>
    <Property Name=""OtherId"" Type=""Int32"" Nullable=""false""/> 
    <NavigationProperty Name=""Navigation"" Type=""Collection(Bork.Entity1)"" Partner=""Navigation"" /> 
  </EntityType>
  <EntityContainer Name=""Container"">
    <EntitySet Name=""Entity1_a"" EntityType=""Bork.Entity1"">
      <NavigationPropertyBinding Path=""Navigation"" Target=""Entity2_b"" />
    </EntitySet>
    <EntitySet Name=""Entity2_a"" EntityType=""Bork.Entity2"">
      <NavigationPropertyBinding Path=""Navigation"" Target=""Entity1_b"" />
    </EntitySet>
  </EntityContainer>
</Schema>";
            return FixUpWithEdmVersion(csdl, edmVersion);
        }

        /// <summary>
        /// Serializes the <paramref name="schema"/> in the specified <paramref name="csdlVersion"/> and returns it.
        /// </summary>
        /// <param name="csdlVersion">The CSDL version to use for serializing the entity model schema.</param>
        /// <param name="schema">The schema to serialize.</param>
        /// <returns>The serialized <paramref name="schema"/>.</returns>
        public IEnumerable<FileContents<XElement>> Serialize(EdmVersion csdlVersion, EntityModelSchema schema)
        {
            ExceptionUtilities.Assert(schema != null, "schema != null");

            // TODO: Can we inherit from the default implemenation of the CSDL content generator instead of doing this in a separate step?
            schema = this.ODataAnnotationConverter.ConvertToProductAnnotations(schema);
            return this.BaseEntityModelSchemaSerializer.Generate(csdlVersion, schema);
        }

 public void ParserSimpleIdentifierTypeReferenceCsdlSchemaCompliantTest()
 {
     var edmVersions = new EdmVersion[] { EdmVersion.V40 };
     foreach (var edmVersion in edmVersions)
     {
         this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ConcurrencyModeTypes(edmVersion), edmVersion);
         this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.CollectionTypeTypeRefSimpleTypeCanHaveFacets(edmVersion), edmVersion);
     }
 }

 public void ParserOpenTypeSupportCsdlSchemaCompliantTest()
 {
     var edmVersions = new EdmVersion[] { EdmVersion.V40 };
     foreach (var edmVersion in edmVersions)
     {
         this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.OpenTypeSupportInV40(edmVersion), edmVersion);
         this.BasicXsdValidationTestForParserInputCsdl(ODataTestModelBuilder.ODataTestModelWithOpenType, edmVersion);
     }
 }

        public static IEdmModel OperationsWithReturnTypeOfPrimitiveDataTypeSchemasEdm(EdmVersion edmVersion)
        {
            var model = new EdmModel();
            foreach (var function in OperationTestModelBuilder.EdmFunctionsWithReturnTypePrimitiveDataType(edmVersion))
            {
                model.AddElement(function);
            }

            return model;
        }

        public static IEnumerable<IEdmPrimitiveTypeReference> AllPrimitiveEdmTypes(EdmVersion edmVersion, bool isNullable)
        {
            IEnumerable<IEdmPrimitiveTypeReference> primitiveTypes = AllNonSpatialPrimitiveEdmTypes(isNullable);
            if (edmVersion >= EdmVersion.V40)
            {
                primitiveTypes = primitiveTypes.Concat(AllSpatialEdmTypes(isNullable));
            }

            return primitiveTypes;
        }

        public static IEdmModel OperationsWith2ParametersSchemasEdm(EdmVersion edmVersion)
        {
            var model = new EdmModel();
            foreach (var operation in OperationTestModelBuilder.EdmOperationsWith2Parameters(edmVersion))
            {
                model.AddElement(operation);
            }

            return model;
        }

 public void ParserComplexTypeWithBaseTypeAbstractCsdlSchemaCompliantTest()
 {
     var edmVersions = new EdmVersion[] { EdmVersion.V40 };
     foreach (var edmVersion in edmVersions)
     {
         this.BasicXsdValidationTestForParserInputCsdl(ModelBuilder.ComplexTypeWithBaseType(edmVersion), edmVersion);
         this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ComplexTypeBaseTypeSupportInV11(edmVersion), edmVersion);
         this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.EdmComplexTypeInvalidIsPolymorphic(edmVersion), edmVersion);
         this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ComplexTypeIsAbstractSupportInV40(edmVersion), edmVersion);
     }
 }

 public static XNamespace GetCsdlFullNamespace(EdmVersion csdlVersion)
 {
     if (csdlVersion == EdmVersion.V40)
     {
         return EdmConstants.EdmOasisNamespace;
     }
     else
     {
         throw new ArgumentOutOfRangeException("CSDL Schema Version is not supported: " + csdlVersion.ToString());
     }
 }

 public static IEnumerable<XElement> ReplaceCsdlNamespacesForEdmVersion(XElement[] csdls, EdmVersion edmVersion)
 {
     var edmNamespace = EdmLibCsdlContentGenerator.GetCsdlFullNamespace(edmVersion);
     for (int i = 0; i < csdls.Count(); ++i)
     {
         if (edmNamespace != csdls[i].Name.Namespace)
         {
             csdls[i] = XElement.Parse(csdls[i].ToString().Replace(csdls[i].Name.Namespace.NamespaceName, edmNamespace.NamespaceName));
         }
     }
     return csdls;
 }

 public static EdmVersion GetEdmVersion(XNamespace edmNamespace)
 {
     var edmVersions = new EdmVersion[] { EdmVersion.V40 };
     foreach (var edmVersion in edmVersions)
     {
         if (GetCsdlFullNamespace(edmVersion) == edmNamespace)
         {
             return edmVersion;
         }
     }
     throw new ArgumentOutOfRangeException("The namespace is not a EDM namespace " + edmNamespace.NamespaceName);
 }

        public static XElement[] SystemNamespace(EdmVersion edmVersion)
        {
            const string csdl =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""Edm"" Alias=""Self"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
  <EntityType Name=""Clod"">
    <Key>
        <PropertyRef Name=""Id"" />
    </Key>
    <Property Name=""Id"" Type=""Int32"" Nullable=""false""/>
    <Property Name=""Bar"" Type=""Int32"" />
  </EntityType>
</Schema>";
            return FixUpWithEdmVersion(csdl, edmVersion);
        }

        private void GenerateContentsWithoutDefinition(EdmVersion edmVersion, IEdmModel definitionModel)
        {
            IEnumerable<EdmError> errors;
            var contentsWithoutDefinition = this.GetSerializerResult(definitionModel, edmVersion, out errors).Select(XElement.Parse);

            var stripTheseElements = new[] { "Term", "Annotations", "Annotation"};

            foreach (var contents in contentsWithoutDefinition)
            {
                contents.Descendants().Where(e => stripTheseElements.Contains(e.Name.LocalName)).Remove();

                string namespaceName = contents.Attribute("Namespace").Value;
                this.namespaceToContents.Add(namespaceName, contents);
            }
        }

 public static string ReplaceCsdlNamespaceForEdmVersion(string csdl, EdmVersion edmVersion)
 {
     var edmNamespace = EdmLibCsdlContentGenerator.GetCsdlFullNamespace(edmVersion);
     var xmlReader = XmlReader.Create(new StringReader(csdl));
     while (xmlReader.Read())
     {
         if (xmlReader.Name == "Schema")
         {
             break;
         }
     }
     if (xmlReader.EOF)
     {
         throw new ArgumentException("{0} is not a well formed CSDL.");
     }
     return csdl.Replace(xmlReader.NamespaceURI, edmNamespace.NamespaceName);
 }

        public IEnumerable<XElement> GenerateDefinitionCsdl(EdmVersion edmVersion, IEdmModel definitionModel)
        {
            this.namespaceToContents = new Dictionary<string, XElement>();

            this.GenerateContentsWithoutDefinition(edmVersion, definitionModel);

            XNamespace ns = this.namespaceToContents.First().Value.Name.Namespace;
            foreach (var valueTerm in definitionModel.SchemaElements.OfType<IEdmValueTerm>())
            {
                XElement schema = this.FindOrCreateCorrespondingSchema(valueTerm.Namespace, ns);

                schema.Add(new XElement(ns + "Term",
                                        new XAttribute("Name", valueTerm.Name),
                                        this.GenerateTypeAttributes(valueTerm.Type)));
            }

            return this.namespaceToContents.Values.Where(fc => fc.HasElements);
        }

        public static XElement[] OkayPrimitiveTerm(EdmVersion edmVersion)
        {
            var csdl1 =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""Vocab"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
  <Term Name=""IntegerTerm"" Type=""Edm.Int64"" />
</Schema>
";
            var csdl2 =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""CSDL"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
  <ComplexType Name=""MyComplex"">
    <Property Name=""ID"" Type=""Edm.Int32"" />
    <Annotation Term=""Vocab.IntegerTerm"" Int=""32"" />
  </ComplexType>
</Schema>";
            return FixUpWithEdmVersion(new string[] { csdl1, csdl2 }, edmVersion);
        }

        public XElement GenerateApplicationCsdl(EdmVersion edmVerion, IEdmModel applicationModel)
        {
            XNamespace ns = this.DetermineXmlNamespace(edmVerion);
            var schema = new XElement(ns + "Schema", new XAttribute("Namespace", "Application.NS1"));

            IEnumerable<IEdmVocabularyAnnotatable> possiblyAnnotated = applicationModel.SchemaElements.OfType<IEdmEntityType>().Cast<IEdmVocabularyAnnotatable>()
                .Concat(applicationModel.SchemaElements.OfType<IEdmEntityContainer>().Cast<IEdmVocabularyAnnotatable>())
                .Concat(applicationModel.SchemaElements.OfType<IEdmEntityContainer>().SelectMany(c => c.EntitySets()).Cast<IEdmVocabularyAnnotatable>());

            foreach (var annotated in possiblyAnnotated.Where(e => e.VocabularyAnnotations(applicationModel).Any()))
            {
                var valueAnnotations = annotated.VocabularyAnnotations(applicationModel).OfType<IEdmValueAnnotation>();
                schema.Add(new XElement(
                                ns + "Annotations",
                                new XAttribute("Target", this.GetTargetPathFor(annotated, applicationModel)),
                                this.GenerateValueAnnotations(ns, valueAnnotations)));
            }

            return schema;
        }

        public static XElement[] DuplicatePropertyName(EdmVersion edmVersion)
        {
            var csdl =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""CollectionAtomic"" Alias=""Self"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
  <ComplexType Name=""ComplexTypeA"">
    <Property Name=""Id"" Type=""Int32""/>
    <Property Name=""Collection"" Type=""Collection(Int32)""/>
    <Property Name=""Collection"" Type=""Collection(Int32)""/>
  </ComplexType>
  <EntityType Name=""ComplexTypeE"">
    <Key>
      <PropertyRef Name=""Id"" />
    </Key>
    <Property Name=""Id"" Type=""Edm.Int32"" Nullable=""false"" />
    <Property Name=""Collection"" Type=""Collection(Int32)""/>
    <Property Name=""Collection"" Type=""Collection(Int32)""/>
  </EntityType>
</Schema>";
            return FixUpWithEdmVersion(csdl, edmVersion);
        }

        private void SerializeAndVerifyAgainst(IEdmModel model, IEnumerable<XElement> expectedCsdls, EdmVersion version)
        {
            IEnumerable<XElement> actualCsdls = this.GetSerializerResult(model).Select(s => XElement.Load(new StringReader(s)));
            var updatedExpectedCsdls = ModelBuilderHelpers.ReplaceCsdlNamespacesForEdmVersion(expectedCsdls.ToArray(), version);
            var updatedActualCsdls = ModelBuilderHelpers.ReplaceCsdlNamespacesForEdmVersion(actualCsdls.ToArray(), version);

            this.CompareCsdls(updatedExpectedCsdls, updatedActualCsdls);
        }