protected IEnumerable <string> GetSerializerResult(IEdmModel edmModel, EdmVersion edmVersion, out IEnumerable <EdmError> errors)
{
// TODO: figure out the best way for multiple schemas
List <StringBuilder> stringBuilders = new List <StringBuilder>();
List <XmlWriter> xmlWriters = new List <XmlWriter>();
edmModel.SetEdmVersion(this.toProductVersionlookup[edmVersion]);
edmModel.TryWriteCsdl(
s =>
{
stringBuilders.Add(new StringBuilder());
xmlWriters.Add(XmlWriter.Create(stringBuilders.Last()));
return(xmlWriters.Last());
}, out errors);
for (int i = 0; i < stringBuilders.Count; i++)
{
xmlWriters[i].Close();
}
List <string> strings = new List <string>();
foreach (var sb in stringBuilders)
{
strings.Add(sb.ToString());
}
return(strings);
}
protected void VerifySemanticValidation(IEdmModel testModel, ValidationRuleSet ruleset, IEnumerable <EdmError> expectedErrors)
{
// Compare the actual errors of the test models to the expected errors.
IEnumerable <EdmError> actualErrors = null;
var validationResult = testModel.Validate(ruleset, out actualErrors);
Assert.IsTrue(actualErrors.Any() ? !validationResult : validationResult, "The return value of the Validate method does not match the reported validation errors.");
this.CompareErrors(actualErrors, expectedErrors);
// Compare the round-tripped immutable model through the CSDL serialized from the original test model against the expected errors.
Func <EdmVersion> GetEdmVersionFromRuleSet = () =>
{
EdmVersion result = EdmVersion.Latest;
foreach (var edmVersion in new EdmVersion[] { EdmVersion.V40 })
{
var versionRuleSet = ValidationRuleSet.GetEdmModelRuleSet(toProductVersionlookup[edmVersion]);
if (versionRuleSet.Count() == ruleset.Count() && !ruleset.Except(versionRuleSet).Any())
{
result = edmVersion;
break;
}
}
return(result);
};
IEnumerable <EdmError> serializationErrors;
var serializedCsdls = this.GetSerializerResult(testModel, GetEdmVersionFromRuleSet(), out serializationErrors).Select(n => XElement.Parse(n));
if (!serializedCsdls.Any())
{
Assert.AreNotEqual(0, serializationErrors.Count(), "Empty models should have associated errors");
return;
}
if (!actualErrors.Any())
{
// if the original test model is valid, the round-tripped model should be well-formed and valid.
IEnumerable <EdmError> parserErrors = null;
IEdmModel roundtrippedModel = null;
var isWellformed = CsdlReader.TryParse(serializedCsdls.Select(e => e.CreateReader()), out roundtrippedModel, out parserErrors);
Assert.IsTrue(isWellformed && !parserErrors.Any(), "The model from valid CSDLs should be generated back to well-formed CSDLs.");
IEnumerable <EdmError> validationErrors = null;
var isValid = roundtrippedModel.Validate(out validationErrors);
Assert.IsTrue(!validationErrors.Any() && isValid, "The model from valid CSDLs should be generated back to valid CSDLs.");
}
else
{
// if the originl test model is not valid, the serializer should still generate CSDLs that parser can handle, but the round trip-ability is not guarantted.
IEnumerable <EdmError> parserErrors = null;
IEdmModel roundtrippedModel = null;
var isWellformed = CsdlReader.TryParse(serializedCsdls.Select(e => e.CreateReader()), out roundtrippedModel, out parserErrors);
Assert.IsTrue(isWellformed, "The parser cannot handle the CSDL that the serializer generated:" + Environment.NewLine + String.Join(Environment.NewLine, parserErrors));
}
}
protected void VerifySemanticValidation(IEnumerable <XElement> testCsdls, EdmVersion edmVersion, IEnumerable <EdmError> expectedErrors)
{
this.VerifySemanticValidation(this.GetParserResult(testCsdls), edmVersion, expectedErrors);
}
protected void VerifySemanticValidation(IEdmModel testModel, EdmVersion edmVersion, IEnumerable <EdmError> expectedErrors)
{
VerifySemanticValidation(testModel, ValidationRuleSet.GetEdmModelRuleSet(toProductVersionlookup[edmVersion]), expectedErrors);
}
public Version GetProductVersion(EdmVersion edmVersion)
{
return(this.toProductVersionlookup[EdmVersion]);
}
