virtual public void Serialize(Stream stream, Encoding encoding)
{
XmlWriter xw = null;
try
{
if (XmlDocProvider != null)
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.CloseOutput = false;
settings.ConformanceLevel = ConformanceLevel.Document;
settings.Encoding = encoding;
settings.Indent = true;
settings.IndentChars = " ";
settings.NewLineChars = "\r\n";
settings.NewLineOnAttributes = true;
xw = XmlWriter.Create(stream, settings);
XmlDocument doc = new XmlDocument();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable);
nsmgr.AddNamespace("i", "http://icalvalid.wikidot.com/validation");
// FIXME: add a schema!
// doc.Schemas.Add("http://icalvalid.wikidot.com/validation", "schema.xsd");
DateTime now = DateTime.Now;
XmlElement results = doc.CreateElement("results", "http://icalvalid.wikidot.com/validation");
results.SetAttribute("language", ResourceManager.CurrentLanguageIdentifier);
results.SetAttribute("datetime", now.ToString("yyyy-MM-dd") + "T" + now.ToString("hh:mm:ss"));
if (TestResults != null &&
TestResults.Length > 0)
{
XmlElement testResults = doc.CreateElement("testResults", "http://icalvalid.wikidot.com/validation");
testResults.SetAttribute("ruleset", Ruleset.Name);
foreach (ITestResult result in TestResults)
{
XmlElement testResult = doc.CreateElement("testResult", "http://icalvalid.wikidot.com/validation");
testResult.SetAttribute("rule", result.Rule);
testResult.SetAttribute("expected", result.Test.Type == TestType.Pass ? "pass" : "fail");
if (result.Passed != null && result.Passed.HasValue)
{
string pass = (result.Test.Type == TestType.Pass ? "pass" : "fail");
string fail = (result.Test.Type == TestType.Pass ? "fail" : "pass");
testResult.SetAttribute("actual", BoolUtil.IsTrue(result.Passed) ? pass : fail);
}
else
{
testResult.SetAttribute("actual", "none");
}
if (!string.IsNullOrEmpty(result.Test.ExpectedError))
{
testResult.SetAttribute("errorName", result.Test.ExpectedError);
}
if (result.Error != null)
{
testResult.SetAttribute("error", result.Error.ToString());
}
testResults.AppendChild(testResult);
}
results.AppendChild(testResults);
}
if (ValidationResults != null &&
ValidationResults.Length > 0)
{
XmlElement validationResults = doc.CreateElement("validationResults", "http://icalvalid.wikidot.com/validation");
validationResults.SetAttribute("ruleset", Ruleset.Name);
foreach (IValidationResult result in ValidationResults)
{
XmlElement validationResult = doc.CreateElement("validationResult", "http://icalvalid.wikidot.com/validation");
validationResult.SetAttribute("rule", result.Rule);
if (result.Passed != null && result.Passed.HasValue)
{
validationResult.SetAttribute("result", result.Passed.Value ? "pass" : "fail");
}
else
{
validationResult.SetAttribute("result", "none");
}
if (result.Errors != null &&
result.Errors.Length > 0)
{
XmlElement validationErrors = doc.CreateElement("errors", "http://icalvalid.wikidot.com/validation");
foreach (IValidationError error in result.Errors)
{
XmlElement validationError = doc.CreateElement("error", "http://icalvalid.wikidot.com/validation");
validationError.SetAttribute("name", error.Name);
validationError.SetAttribute("type", error.Type.ToString().ToLower());
validationError.SetAttribute("message", error.Message);
validationError.SetAttribute("isFatal", error.IsFatal.ToString().ToLower());
if (error.Line != default(int))
{
validationError.SetAttribute("line", error.Line.ToString());
}
if (error.Col != default(int))
{
validationError.SetAttribute("col", error.Col.ToString());
}
validationErrors.AppendChild(validationError);
}
validationResult.AppendChild(validationErrors);
}
validationResults.AppendChild(validationResult);
}
results.AppendChild(validationResults);
}
doc.AppendChild(results);
doc.Save(xw);
}
}
finally
{
if (xw != null)
{
xw.Close();
xw = null;
}
}
}
virtual public void Serialize(Stream stream, Encoding encoding)
{
using (StreamWriter sw = new StreamWriter(stream, encoding))
{
if (Ruleset != null)
{
if (TestResults != null &&
TestResults.Length > 0)
{
int numTests = TestResults.Length;
int numTestsRun = 0;
foreach (ITestResult result in TestResults)
{
if (result.Passed != null && result.Passed.HasValue)
{
numTestsRun++;
}
}
if (!object.Equals(numTests, numTestsRun))
{
sw.WriteLine(string.Format(
ResourceManager.GetString("notAllTestsPerformed"),
numTests,
numTestsRun,
numTests - numTestsRun
));
}
int passed = 0;
foreach (ITestResult result in TestResults)
{
if (BoolUtil.IsTrue(result.Passed))
{
passed++;
}
sw.WriteLine(result.ToString());
}
sw.WriteLine(string.Format(
ResourceManager.GetString("passVsFail"),
passed,
numTestsRun,
string.Format("{0:0.0}", ((double)passed / (double)numTestsRun) * 100)
));
}
else if (TestResults != null)
{
sw.WriteLine(ResourceManager.GetString("noTestsPerformed"));
}
if (ValidationResults != null &&
ValidationResults.Length > 0)
{
foreach (IValidationResult result in ValidationResults)
{
if (!BoolUtil.IsTrue(result.Passed))
{
foreach (IValidationError error in result.Errors)
{
sw.WriteLine(error.ToString());
}
}
}
}
else if (ValidationResults != null)
{
sw.WriteLine(ResourceManager.GetString("calendarValid"));
}
}
else
{
sw.WriteLine(ResourceManager.GetString("noValidationRuleset"));
}
}
}
public ITestResult[] Test()
{
if (Ruleset != null)
{
List <ITestResult> results = new List <ITestResult>();
foreach (IValidationRule rule in Ruleset.Rules)
{
foreach (ITest test in rule.Tests)
{
RulesetValidator validator = new RulesetValidator(Ruleset, test.iCalendarText);
List <IValidationResult> validationResults = new List <IValidationResult>();
validationResults.AddRange(validator.Validate());
TestResult result = new TestResult(rule.Name, test, false);
if (test.Type == TestType.Fail)
{
List <IValidationResult> badResults = validationResults.FindAll(
delegate(IValidationResult r)
{
return(!BoolUtil.IsTrue(r.Passed));
});
// On a failing test, there should always be bad results.
if (badResults.Count > 0)
{
// Get a list of errors from our results
List <IValidationError> errors = new List <IValidationError>();
foreach (IValidationResult r in badResults)
{
// If we encounter a fatal error, then we cannot continue processing
// other errors. In other words, even though a single error was caused,
// the fact that it was fatal may have side effects and cause errors
// in almost every validator (i.e. a calendar with parsing errors).
bool fatal = false;
foreach (IValidationError error in r.Errors)
{
errors.Add(error);
if (error.IsFatal)
{
fatal = true;
break;
}
}
if (fatal)
{
break;
}
}
if (errors.Count == 1 && !string.Equals(errors[0].Name, test.ExpectedError))
{
result.Error = new TestError("failWithIncorrectError", rule.Name, validationResults.ToArray());
}
else if (errors.Count == 0)
{
result.Error = new TestError("failExpectedError", rule.Name, validationResults.ToArray());
}
else if (errors.Count > 1)
{
result.Error = new TestError("failWithMoreThanOneError", rule.Name, validationResults.ToArray());
}
else
{
result.Passed = true;
}
}
}
else
{
result.Passed = true;
if (validationResults.FindIndex(
delegate(IValidationResult r)
{
return(!BoolUtil.IsTrue(r.Passed));
}) >= 0)
{
result.Passed = false;
result.Error = new TestError("passExpectedError", rule.Name, validationResults.ToArray());
}
}
results.Add(result);
}
}
return(results.ToArray());
}
// FIXME: else throw exception?
else
{
return(new ITestResult[0]);
}
}
