private void Run(string[] args)
{
ParseArguments(args);
if (isProcessingVerbose)
{
System.Console.WriteLine("Loading schema: " + schemaFileName);
}
XDocument schema = LoadXDocument(schemaFileName);
Validator validator = CreateValidator(phase, schema);
foreach (var documentFileName in documentFileNames)
{
if (areViolationsVerbose)
{
System.Console.WriteLine();
}
if (isProcessingVerbose)
{
System.Console.WriteLine("Loading document: " + documentFileName);
}
XDocument document = LoadXDocument(documentFileName);
System.Console.WriteLine(string.Format(
"Performing {0} validation of document '{1}'.",
(fullValidationEnabled ? "full" : "partial"),
documentFileName));
ValidatorResults results = validator.Validate(document, fullValidationEnabled);
PrintResults(results);
}
}
public void SimpleValidation()
{
XDocument xSch = Resources.Provider.LoadXmlDocument("basics_sch.xml");
XDocument xIn = Resources.Provider.LoadXmlDocument("basics_xml.xml");
Validator validator = Validator.Create(xSch);
ValidatorResults results = validator.Validate(xIn, true);
Assert.True(results.IsValid);
}
public void SimpleValidation_InvalidInstance()
{
XDocument xSch = Resources.Provider.LoadXmlDocument("absrules_sch.xml");
XDocument xIn = Resources.Provider.LoadXmlDocument("absrules_xml_invalid.xml");
Validator validator = Validator.Create(xSch);
ValidatorResults results = validator.Validate(xIn, true);
Assert.False(results.IsValid);
}
/// <summary>
/// Validates the input XML service configuration file providing
/// detailed validation results.
/// </summary>
/// <param name="xConfig">XML service configuration file</param>
/// <param name="results">Results of validation</param>
public static bool IsValid(XDocument xConfig, out ValidatorResults results)
{
XDocument xSchema = Resources.Provider.LoadConfigSchema();
// validation
Validator validator = Validator.Create(xSchema);
results = validator.Validate(xConfig, true);
return results.IsValid;
}
public void ValidateGoodDocument()
{
XDocument xSchema = Resources.Provider.LoadXmlDocument(BASIC_SCHEMA);
XDocument xDocument = Resources.Provider.LoadXmlDocument(BASIC_DOCUMENT);
Validator validator = Validator.Create(xSchema);
Assert.NotNull(validator);
ValidatorResults results = validator.Validate(xDocument, true);
Assert.True(results.IsValid);
}
public void SimpleValidation()
{
XDocument xSch = Resources.Provider.LoadXmlDocument("inclusions_sch.xml");
XDocument xIn = Resources.Provider.LoadXmlDocument("inclusions_xml.xml");
ValidatorSettings settings = new ValidatorSettings();
settings.InclusionsResolver = new InclusionsEmbededResourceResolver();
Validator validator = Validator.Create(xSch, settings);
ValidatorResults results = validator.Validate(xIn, true);
Assert.True(results.IsValid);
}
public void AddValidationError(string Message, string FieldName, ValidatorResultLevel Level, int errorCode)
{
if (Mode == ErrorMode.OneErrorPerField)
{
foreach (var Error in ValidatorResults)
{
if (Error.FieldName == FieldName)
{
return;
}
}
}
ValidatorResults.Add(new ValidatorResult(Message, FieldName, Level, errorCode));
}
/// ***********************************************************
/// <summary>
/// Add a new validation error to the list of validation errors
/// </summary>
/// <param name="Message"></param>
/// <param name="FieldName"></param>
/// <param name="Level"></param>
/// <param name="errorCode"></param>
public void AddValidationError(string Message, string FieldName, ValidatorResultLevel Level, int errorCode)
{
// Should we only allow one error per fieldname?
if (Mode == ErrorMode.OneErrorPerField)
{
// Check if an error for this fieldname already exists
foreach (var Error in ValidatorResults)
{
if (Error.FieldName == FieldName)
{
return;
}
}
}
// If we get here, add the new item.
ValidatorResults.Add(new ValidatorResult(Message, FieldName, Level, errorCode));
}
public void SimpleValidation_InvalidInstance()
{
XDocument xSch = Resources.Provider.LoadXmlDocument("inclusions_sch.xml");
XDocument xIn = Resources.Provider.LoadXmlDocument("inclusions_xml_invalid.xml");
ValidatorSettings settings = new ValidatorSettings();
settings.InclusionsResolver = new InclusionsEmbededResourceResolver();
Validator validator = Validator.Create(xSch, settings);
// full validation
ValidatorResults results1 = validator.Validate(xIn, true);
// partial validation
ValidatorResults results2 = validator.Validate(xIn, false);
Assert.False(results1.IsValid);
Assert.False(results2.IsValid);
}
private void PrintResults(ValidatorResults results)
{
System.Console.WriteLine("Validation result: the document " + (results.IsValid ? "IS" : "is NOT") + " valid.");
if (!results.IsValid)
{
System.Console.WriteLine(string.Format("Violated assertions ({0}):",
results.ViolatedAssertions.Count()));
int index = 0;
foreach (var assertion in results.ViolatedAssertions
.OrderBy((info) => info.LinePosition)
.OrderBy((info) => info.LineNumber))
{
index++;
if (areViolationsVerbose)
{
System.Console.WriteLine(string.Format(
@"
User message: {0}
Line number: {2}, Line position: {3}
Assertion type: {1}
XPath location: {4}
Pattern id: '{5}'
Rule id: '{7}'
Rule context: {6}",
assertion.UserMessage,
assertion.IsReport ? "report" : "assert",
assertion.LineNumber,
assertion.LinePosition,
assertion.Location,
assertion.PatternId,
assertion.RuleContext,
assertion.RuleId));
}
else
{
System.Console.WriteLine(string.Format("[{0}]: {1}", index, assertion.UserMessage));
}
}
}
}
public void SimpleValidation()
{
XDocument xSch = Resources.Provider.LoadXmlDocument("phases_sch.xml");
XDocument xIn = Resources.Provider.LoadXmlDocument("phases_xml.xml");
// #ALL
ValidatorSettings settings = new ValidatorSettings();
settings.Phase = "#ALL";
Validator validator = Validator.Create(xSch, settings);
ValidatorResults results = validator.Validate(xIn, true);
Assert.True(results.IsValid);
// #DEFAULT
settings = new ValidatorSettings();
settings.Phase = "#DEFAULT";
validator = Validator.Create(xSch, settings);
results = validator.Validate(xIn, true);
Assert.True(results.IsValid);
// A
settings = new ValidatorSettings();
settings.Phase = "A";
validator = Validator.Create(xSch, settings);
results = validator.Validate(xIn, true);
Assert.True(results.IsValid);
// B
settings = new ValidatorSettings();
settings.Phase = "B";
validator = Validator.Create(xSch, settings);
results = validator.Validate(xIn, true);
Assert.True(results.IsValid);
}
private void PrintResults(ValidatorResults results)
{
System.Console.WriteLine("Validation result: the document " + (results.IsValid ? "IS" : "is NOT") + " valid.");
if (!results.IsValid)
{
System.Console.WriteLine(string.Format("Violated assertions ({0}):",
results.ViolatedAssertions.Count()));
int index = 0;
foreach (var assertion in results.ViolatedAssertions
.OrderBy((info) => info.LinePosition)
.OrderBy((info) => info.LineNumber))
{
index++;
if (areViolationsVerbose)
{
System.Console.WriteLine(string.Format(
@"
User message: {0}
Line number: {2}, Line position: {3}
Assertion type: {1}
XPath location: {4}
Pattern id: '{5}'
Rule id: '{7}'
Rule context: {6}",
assertion.UserMessage,
assertion.IsReport ? "report" : "assert",
assertion.LineNumber,
assertion.LinePosition,
assertion.Location,
assertion.PatternId,
assertion.RuleContext,
assertion.RuleId));
}
else
{
System.Console.WriteLine(string.Format("[{0}]: {1}", index, assertion.UserMessage));
}
}
}
}
public int WarningCount()
{
return(ValidatorResults.Where(x => x.Level == ValidatorResultLevel.Warning).Count());
}
public int ErrorCount()
{
return(ValidatorResults.Where(x => x.Level == ValidatorResultLevel.Error).Count());
}
public void Clear()
{
ValidatorResults.Clear();
}
