public void ProducesExpectedXml()
{
var destination = new XmlDestination(PathToXslt, PathToResultXml);
DataTable table = TestDataHelper.GetWidgetsTable();
destination.Receive(table);
string expectedXmlPath = "xmldestinaton_result_expected.xml";
string intermediateXmlPath = "xmldestination_result_intermediate.xml";
table.WriteXml(intermediateXmlPath);
XslCompiledTransform transform = new XslCompiledTransform();
transform.Load(PathToXslt);
transform.Transform(intermediateXmlPath, expectedXmlPath);
XmlDocument expectedXml = new XmlDocument();
expectedXml.Load(expectedXmlPath);
XmlDocument actualXml = new XmlDocument();
actualXml.Load(PathToResultXml);
Assert.Equal(expectedXml.OuterXml, actualXml.OuterXml);
}
private void Transform(XdmNode input, string xsltPath, XmlDestination output)
{
var xsltExecutable = _loadedTransformers.GetOrAdd(xsltPath, path =>
{
var errors = new List <StaticError>();
try
{
var compiler = _xsltCompiler.Value;
compiler.ErrorList = errors;
var compiled = compiler.Compile(new Uri(path));
return(compiled);
}
catch (Exception)
{
if (errors.Count == 0)
{
throw;
}
var exception = new XsltException(errors[0].ToString());
for (var i = 1; i < errors.Count; i++)
{
exception = new XsltException(errors[i].ToString(), exception);
}
throw exception;
}
});
var xsltTransformer = xsltExecutable.Load();
xsltTransformer.InitialContextNode = input;
xsltTransformer.Run(output);
}
static Network CreateNetwork(string targetFileName)
{
var source = new MemorySource <MyLinkingRow>();
for (int i = 0; i <= 5; i++)
{
source.DataAsList.Add(new MyLinkingRow()
{
Col1 = i, Col2 = $"Test{i}"
});
}
var row = new RowTransformation <MyLinkingRow>();
row.TransformationFunc = row => {
Console.WriteLine($"Sending row {row.Col1}|{row.Col2} into {targetFileName}");
Task.Delay(10).Wait();
return(row);
};
var dest = new XmlDestination <MyLinkingRow>(targetFileName, ResourceType.File);
source.LinkTo(row).LinkTo(dest);
return(new Network(source));
}
void Run(XmlDestination destination, XQueryRuntimeOptions options)
{
XQueryEvaluator eval = GetEvaluator(options);
try {
eval.Run(destination);
} catch (DynamicError ex) {
throw new SaxonException(ex);
} catch (Exception ex) {
throw new SaxonException(ex.Message, ex);
}
}
public void SimpleFlowWithObject()
{
//Arrange
TwoColumnsTableFixture s2C = new TwoColumnsTableFixture("XmlDestDynamic");
s2C.InsertTestDataSet3();
DbSource <ExpandoObject> source = new DbSource <ExpandoObject>(SqlConnection, "XmlDestDynamic");
//Act
XmlDestination <ExpandoObject> dest = new XmlDestination <ExpandoObject>("./SimpleWithDynamicObject.xml", ResourceType.File);
source.LinkTo(dest);
source.Execute();
dest.Wait();
//Assert
Assert.Equal(File.ReadAllText("res/XmlDestination/TwoColumnsSet3DynamicObject.xml"),
File.ReadAllText("./SimpleWithDynamicObject.xml"));
}
public void SimpleOnlyAttributes()
{
//Arrange
TwoColumnsTableFixture s2C = new TwoColumnsTableFixture("XmlDestOnlyAttributes");
s2C.InsertTestDataSet3();
DbSource <MyAttributeRow> source = new DbSource <MyAttributeRow>("XmlDestOnlyAttributes", SqlConnection);
//Act
XmlDestination <MyAttributeRow> dest = new XmlDestination <MyAttributeRow>("./SimpleOnlyAttributes.xml", ResourceType.File);
source.LinkTo(dest);
source.Execute();
dest.Wait();
//Assert
Assert.Equal(File.ReadAllText("res/XmlDestination/TwoColumnsAttributesSet3.xml")
, File.ReadAllText("./SimpleOnlyAttributes.xml"));
}
void Run(XmlDestination destination, XsltRuntimeOptions options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
XsltTransformer transformer = executable.Load();
transformer.RecoveryPolicy = RecoveryPolicy.DoNotRecover;
if (options.InputXmlResolver != null)
{
XmlDynamicResolver dynamicResolver = options.InputXmlResolver as XmlDynamicResolver;
if (dynamicResolver != null &&
dynamicResolver.DefaultBaseUri == null)
{
dynamicResolver.DefaultBaseUri = this.StaticBaseUri;
}
transformer.InputXmlResolver = options.InputXmlResolver;
}
// XsltTransformer.BaseOutputUri doesn't accept null
if (options.BaseOutputUri != null)
{
transformer.BaseOutputUri = options.BaseOutputUri;
}
// TODO: Bug in Saxon 9.3
//else if (this.StaticBaseUri != null && this.StaticBaseUri.IsFile)
// transformer.BaseOutputUri = new Uri(Path.GetDirectoryName(this.StaticBaseUri.LocalPath), UriKind.Absolute);
try {
if (options.InitialTemplate != null)
{
transformer.InitialTemplate = new QName(options.InitialTemplate);
}
} catch (DynamicError err) {
throw new SaxonException(err);
}
if (options.InitialMode != null)
{
transformer.InitialMode = new QName(options.InitialMode);
}
if (options.InitialContextNode != null)
{
XdmNode node = options.InitialContextNode.ToXdmNode(this.Processor.ItemFactory);
BugHandler.ThrowIfBug1675(node);
transformer.InitialContextNode = node;
}
foreach (var pair in options.Parameters)
{
var qname = new QName(pair.Key);
XdmValue xdmValue = pair.Value.ToXdmValue(this.Processor.ItemFactory);
transformer.SetParameter(qname, xdmValue);
}
transformer.MessageListener = new TraceMessageListener();
try {
transformer.Run(destination);
} catch (DynamicError ex) {
throw new SaxonException(ex);
} catch (Exception ex) {
throw new SaxonException(ex.Message, ex);
}
}
static void Main(string[] args)
{
var scraper = new Scraper();
var terms = scraper.GetTerms().ToList();
Console.Clear();
Console.WriteLine("Select a term to Scrape:");
int t = ChooseOptions(terms.Select(x => x.Name).ToArray());
var term = terms[t - 1];
Console.Clear();
Console.WriteLine("Will scrape " + term.Name);
Console.WriteLine("Select a data destination:");
int d = ChooseOptions(
"Scrape to Blank SQL Database",
"Scrape to JSON file",
"Scrape to XML file",
"Scrape to CSV");
ISectionDestination dest;
string path = null;
if (d > 1)
{
Console.Write("Enter Output File Path: ");
path = Console.ReadLine();
}
switch (d)
{
case 1:
dest = new DatabaseContext();
break;
case 2:
dest = new JsonDestination(path);
break;
case 3:
dest = new XmlDestination(path);
break;
case 4:
dest = new CsvDestination(path);
break;
default:
throw new Exception("Invalid Option");
}
Console.Clear();
var watch = Stopwatch.StartNew();
double prog = 0;
var schools = scraper.GetSchools(term).ToList();
double progPerSchool = 1.0 / schools.Count;
foreach (var school in schools)
{
var subjects = scraper.GetSubjects(school).ToList();
double progPerSubject = progPerSchool / subjects.Count;
foreach (var subject in subjects)
{
var crns = scraper.GetCrns(subject).ToList();
double progPerCrn = progPerSubject / crns.Count;
foreach (var crn in crns)
{
var cd = scraper.GetDetailedClass(crn);
var cs = new ClassSection(cd)
{
School = school.Name,
Term = term.Name,
Subject = subject.Name
};
dest.Add(cs);
prog += progPerCrn;
Console.Write("{0:P2} ({1:F2}s)\r", prog, watch.ElapsedMilliseconds / 1000.0);
}
dest.CommitChanges();
}
}
Console.WriteLine("\nClosing...");
dest.Close();
watch.Stop();
Console.WriteLine("Finished ({0}ms)", watch.ElapsedMilliseconds);
}
protected override void runTestCase(XdmNode testCase, XPathCompiler xpath)
{
TestOutcome outcome = new TestOutcome(this);
string testName = testCase.GetAttributeValue(new QName("name"));
string testSetName = testCase.Parent.GetAttributeValue(new QName("name"));
////
if (testName.Equals("type-0174"))
{
int num = 0;
System.Console.WriteLine("Test driver" + num);
}
///
if (exceptionsMap.ContainsKey(testName))
{
notrun++;
resultsDoc.writeTestcaseElement(testName, "notRun", exceptionsMap[testName].GetAttributeValue(new QName("reason")));
return;
}
if (exceptionsMap.ContainsKey(testName) || isSlow(testName))
{
notrun++;
resultsDoc.writeTestcaseElement(testName, "notRun", "requires excessive resources");
return;
}
XdmValue specAtt = (XdmValue)(xpath.EvaluateSingle("(/test-set/dependencies/spec/@value, ./dependencies/spec/@value)[last()]", testCase));
string spec = specAtt.ToString();
Environment env = getEnvironment(testCase, xpath);
if (env == null)
{
resultsDoc.writeTestcaseElement(testName, "notRun", "test catalog error");
return;
}
/*if(testName("environment-variable")) {
* EnvironmentVariableResolver resolver = new EnvironmentVariableResolver() {
* public Set<string> getAvailableEnvironmentVariables() {
* Set<string> strings = new HashSet<string>();
* strings.add("QTTEST");
* strings.add("QTTEST2");
* strings.add("QTTESTEMPTY");
* return strings;
* }
*
* public string getEnvironmentVariable(string name) {
* if (name.Equals("QTTEST")) {
* return "42";
* } else if (name.Equals("QTTEST2")) {
* return "other";
* } else if (name.Equals("QTTESTEMPTY")) {
* return "";
* } else {
* return null;
* }
* }
* }; //TODO
* } */
// env.processor.SetProperty(JFeatureKeys.ENVIRONMENT_VARIABLE_RESOLVER, resolver); //TODO
XdmNode testInput = (XdmNode)xpath.EvaluateSingle("test", testCase);
XdmNode stylesheet = (XdmNode)xpath.EvaluateSingle("stylesheet", testInput);
XdmNode pack = (XdmNode)xpath.EvaluateSingle("package", testInput);
foreach (XdmItem dep in xpath.Evaluate("(/test-set/dependencies/*, ./dependencies/*)", testCase))
{
if (!dependencyIsSatisfied((XdmNode)dep, env))
{
notrun++;
resultsDoc.writeTestcaseElement(testName, "notRun", "dependency not satisfied");
return;
}
}
XsltExecutable sheet = env.xsltExecutable;
//ErrorCollector collector = new ErrorCollector();
string baseOutputURI = resultsDir + "/results/output.xml";
ErrorCollector collector = new ErrorCollector(outcome);
IList errorList = new List <StaticError> ();
XmlUrlResolver res = new XmlUrlResolver();
string xsltLanguageVersion = spec.Contains("XSLT30") || spec.Contains("XSLT20+") ? "3.0" : "2.0";
if (stylesheet != null)
{
XsltCompiler compiler = env.xsltCompiler;
compiler.ErrorList = errorList;
Uri hrefFile = res.ResolveUri(stylesheet.BaseUri, stylesheet.GetAttributeValue(new QName("file")));
Stream stream = new FileStream(hrefFile.AbsolutePath, FileMode.Open, FileAccess.Read);
compiler.BaseUri = hrefFile;
compiler.XsltLanguageVersion = (spec.Contains("XSLT30") || spec.Contains("XSLT20+") ? "3.0" : "2.0");
foreach (XdmItem param in xpath.Evaluate("param[@static='yes']", testInput))
{
String name = ((XdmNode)param).GetAttributeValue(new QName("name"));
String select = ((XdmNode)param).GetAttributeValue(new QName("select"));
XdmValue value;
try {
value = xpath.Evaluate(select, null);
} catch (Exception e) {
Console.WriteLine("*** Error evaluating parameter " + name + ": " + e.Message);
//throw e;
continue;
}
compiler.SetParameter(new QName(name), value);
}
try
{
sheet = compiler.Compile(stream);
} catch (Exception err) {
Console.WriteLine(err.Message);
//Console.WriteLine(err.StackTrace);
IEnumerator enumerator = errorList.GetEnumerator();
bool checkCur = enumerator.MoveNext();
/*if (checkCur && enumerator.Current != null) {
* outcome.SetException ((Exception)(enumerator.Current));
* } else {
* Console.WriteLine ("Error: Unknown exception thrown");
* }*/
outcome.SetErrorsReported(errorList);
//outcome.SetErrorsReported(collector.GetErrorCodes);
}
// compiler.setErrorListener(collector);
}
else if (pack != null)
{
Uri hrefFile = res.ResolveUri(pack.BaseUri, pack.GetAttributeValue(new QName("file")));
Stream stream = new FileStream(hrefFile.AbsolutePath, FileMode.Open, FileAccess.Read);
XsltCompiler compiler = env.xsltCompiler;
compiler.ErrorList = errorList;
compiler.XsltLanguageVersion = (spec.Contains("XSLT30") || spec.Contains("XSLT20+") ? "3.0" : "2.0");
//compiler.setErrorListener(collector);
try {
XsltPackage xpack = compiler.CompilePackage(stream);
sheet = xpack.Link();
} catch (Exception err) {
Console.WriteLine(err.Message);
IEnumerator enumerator = errorList.GetEnumerator();
enumerator.MoveNext();
outcome.SetException((Exception)(enumerator.Current));
outcome.SetErrorsReported(errorList);
}
}
if (sheet != null)
{
XdmItem contextItem = env.contextItem;
XdmNode initialMode = (XdmNode)xpath.EvaluateSingle("initial-mode", testInput);
XdmNode initialFunction = (XdmNode)xpath.EvaluateSingle("initial-function", testInput);
XdmNode initialTemplate = (XdmNode)xpath.EvaluateSingle("initial-template", testInput);
QName initialModeName = GetQNameAttribute(xpath, testInput, "initial-mode/@name");
QName initialTemplateName = GetQNameAttribute(xpath, testInput, "initial-template/@name");
if (useXslt30Transformer)
{
try {
bool assertsSerial = xpath.Evaluate("result//(assert-serialization|assert-serialization-error|serialization-matches)", testCase).Count > 0;
bool resultAsTree = env.outputTree;
bool serializationDeclared = env.outputSerialize;
XdmNode needsTree = (XdmNode)xpath.EvaluateSingle("output/@tree", testInput);
if (needsTree != null)
{
resultAsTree = needsTree.StringValue.Equals("yes");
}
XdmNode needsSerialization = (XdmNode)xpath.EvaluateSingle("output/@serialize", testInput);
if (needsSerialization != null)
{
serializationDeclared = needsSerialization.StringValue.Equals("yes");
}
bool resultSerialized = serializationDeclared || assertsSerial;
if (assertsSerial)
{
String comment = outcome.GetComment();
comment = (comment == null ? "" : comment) + "*Serialization " + (serializationDeclared ? "declared* " : "required* ");
outcome.SetComment(comment);
}
Xslt30Transformer transformer = sheet.Load30();
transformer.InputXmlResolver = env;
if (env.unparsedTextResolver != null)
{
transformer.GetUnderlyingController.setUnparsedTextURIResolver(env.unparsedTextResolver);
}
Dictionary <QName, XdmValue> caseGlobalParams = GetNamedParameters(xpath, testInput, false, false);
Dictionary <QName, XdmValue> caseStaticParams = GetNamedParameters(xpath, testInput, true, false);
Dictionary <QName, XdmValue> globalParams = new Dictionary <QName, XdmValue>(env.params1);
foreach (KeyValuePair <QName, XdmValue> entry in caseGlobalParams)
{
globalParams.Add(entry.Key, entry.Value);
}
foreach (KeyValuePair <QName, XdmValue> entry in caseStaticParams)
{
globalParams.Add(entry.Key, entry.Value);
}
transformer.SetStylesheetParameters(globalParams);
if (contextItem != null)
{
transformer.GlobalContextItem = contextItem;
}
transformer.MessageListener = collector;
transformer.BaseOutputURI = baseOutputURI;
transformer.MessageListener = new TestOutcome.MessageListener(outcome);
XdmValue result = null;
TextWriter sw = new StringWriter();
Serializer serializer = env.processor.NewSerializer();
serializer.SetOutputWriter(sw);
//serializer.setOutputProperty(Serializer.Property.OMIT_XML_DECLARATION, "yes");
OutputResolver serializingOutput = new OutputResolver(env.processor, outcome, true);
net.sf.saxon.Controller controller = transformer.GetUnderlyingController;
controller.setOutputURIResolver(serializingOutput);
XmlDestination dest = null;
if (resultAsTree)
{
// If we want non-serialized, we need to accumulate any result documents as trees too
controller.setOutputURIResolver(
new OutputResolver(env.processor, outcome, false));
dest = new XdmDestination();
}
if (resultSerialized)
{
dest = serializer;
}
Stream src = null;
Uri srcBaseUri = new Uri("http://uri");
XdmNode srcNode = null;
DocumentBuilder builder2 = env.processor.NewDocumentBuilder();
if (env.streamedPath != null)
{
src = new FileStream(env.streamedPath, FileMode.Open, FileAccess.Read);
srcBaseUri = new Uri(env.streamedPath);
}
else if (env.streamedContent != null)
{
byte[] byteArray = Encoding.UTF8.GetBytes(env.streamedContent);
src = new MemoryStream(byteArray); //, "inlineDoc");
builder2.BaseUri = new Uri("http://uri");
}
else if (initialTemplate == null && contextItem != null)
{
srcNode = (XdmNode)(contextItem);
}
if (initialMode != null)
{
QName name = GetQNameAttribute(xpath, initialMode, "@name");
try {
if (name != null)
{
transformer.InitialMode = name;
}
else
{
controller.getInitialMode(); /// has the side effect of setting to the unnamed
}
} catch (Exception e) {
if (e.InnerException is net.sf.saxon.trans.XPathException)
{
Console.WriteLine(e.Message);
outcome.SetException(e);
//throw new SaxonApiException(e.getCause());
}
else
{
throw e;
}
}
}
if (initialMode != null || initialTemplate != null)
{
XdmNode init = (XdmNode)(initialMode == null ? initialTemplate : initialMode);
Dictionary <QName, XdmValue> params1 = GetNamedParameters(xpath, init, false, false);
Dictionary <QName, XdmValue> tunnelledParams = GetNamedParameters(xpath, init, false, true);
if (xsltLanguageVersion.Equals("2.0"))
{
if (!(params1.Count == 0 && tunnelledParams.Count == 0))
{
Console.WriteLine("*** Initial template parameters ignored for XSLT 2.0");
}
}
else
{
transformer.SetInitialTemplateParameters(params1, false);
transformer.SetInitialTemplateParameters(tunnelledParams, true);
}
}
if (initialTemplate != null)
{
QName name = GetQNameAttribute(xpath, initialTemplate, "@name");
transformer.GlobalContextItem = contextItem;
if (dest == null)
{
result = transformer.CallTemplate(name);
}
else
{
transformer.CallTemplate(name, dest);
}
}
else if (initialFunction != null)
{
QName name = getQNameAttribute(xpath, initialFunction, "@name");
XdmValue[] params2 = getParameters(xpath, initialFunction);
if (dest == null)
{
result = transformer.CallFunction(name, params2);
}
else
{
transformer.CallFunction(name, params2, dest);
}
}
else
{
if (dest == null)
{
if (src != null)
{
result = transformer.ApplyTemplates(src, srcBaseUri);
}
else
{
result = transformer.ApplyTemplates(srcNode);
}
}
else
{
if (src != null)
{
transformer.ApplyTemplates(src, dest);
}
else
{
transformer.ApplyTemplates(srcNode, dest);
}
}
}
//outcome.SetWarningsReported(collector.getFoundWarnings());
if (resultAsTree && !resultSerialized)
{
result = ((XdmDestination)(dest)).XdmNode;
}
if (resultSerialized)
{
outcome.SetPrincipalSerializedResult(sw.ToString());
}
outcome.SetPrincipalResult(result);
if (saveResults)
{
String s = sw.ToString();
// If a transform result is entirely xsl:result-document, then result will be null
if (!resultSerialized && result != null)
{
StringWriter sw2 = new StringWriter();
Serializer se = env.processor.NewSerializer(sw2);
se.SetOutputProperty(Serializer.OMIT_XML_DECLARATION, "yes");
env.processor.WriteXdmValue(result, se);
se.Close();
s = sw2.ToString();
}
// currently, only save the principal result file in the result directory
saveResultsToFile(s, resultsDir + "/results/" + testSetName + "/" + testName + ".out");
Dictionary <Uri, TestOutcome.SingleResultDoc> xslResultDocuments = outcome.GetSecondaryResultDocuments();
foreach (KeyValuePair <Uri, TestOutcome.SingleResultDoc> entry in xslResultDocuments)
{
Uri key = entry.Key;
String path = key.AbsolutePath;
String serialization = outcome.Serialize(env.processor, entry.Value);
saveResultsToFile(serialization, path);
}
}
} catch (Exception err) {
//if (err.getCause() is XPathException &&
//!((XPathException) err.getCause()).hasBeenReported()) {
//System.err.println("Unreported ERROR: " + err.getCause());
//}
outcome.SetException(err);
if (collector.getErrorCodes().Count > 0)
{
outcome.SetErrorsReported((IList)collector.getErrorCodes());
}
//Console.WriteLine(err.StackTrace);
/*if(err.getErrorCode() == null) {
* int b = 3 + 4; }
* if(err.getErrorCode() != null)
* outcome.AddReportedError(err.getErrorCode().getLocalName());
* } else {
* outcome.SetErrorsReported(collector.getErrorCodes());
* }*/
} /*catch (Exception err) {
* err.printStackTrace();
* failures++;
* resultsDoc.writeTestcaseElement(testName, "fail", "*** crashed " + err.getClass() + ": " + err.getMessage());
* return;
* }*/
}
else
{
try {
XsltTransformer transformer = sheet.Load();
//transformer.SetURIResolver(env); //TODO
if (env.unparsedTextResolver != null)
{
transformer.Implementation.setUnparsedTextURIResolver(env.unparsedTextResolver);
}
if (initialTemplate != null)
{
transformer.InitialTemplate = initialTemplateName;
}
if (initialMode != null)
{
transformer.InitialMode = initialModeName;
}
foreach (XdmItem param in xpath.Evaluate("param", testInput))
{
string name = ((XdmNode)param).GetAttributeValue(new QName("name"));
string select = ((XdmNode)param).GetAttributeValue(new QName("select"));
XdmValue value = xpath.Evaluate(select, null);
transformer.SetParameter(new QName(name), value);
}
if (contextItem != null)
{
transformer.InitialContextNode = (XdmNode)contextItem;
}
if (env.streamedPath != null)
{
transformer.SetInputStream(new FileStream(env.streamedPath, FileMode.Open, FileAccess.Read), testCase.BaseUri);
}
foreach (QName varName in env.params1.Keys)
{
transformer.SetParameter(varName, env.params1[varName]);
}
//transformer.setErrorListener(collector);
transformer.BaseOutputUri = new Uri(resultsDir + "/results/output.xml");
/*transformer.MessageListener = (new MessageListener() {
* public void message(XdmNode content, bool terminate, SourceLocator locator) {
* outcome.addXslMessage(content);
* }
* });*/
// Run the transformation twice, once for serialized results, once for a tree.
// TODO: we could be smarter about this and capture both
// run with serialization
StringWriter sw = new StringWriter();
Serializer serializer = env.processor.NewSerializer(sw);
transformer.Implementation.setOutputURIResolver(new OutputResolver(driverProc, outcome, true));
transformer.Run(serializer);
outcome.SetPrincipalSerializedResult(sw.ToString());
if (saveResults)
{
// currently, only save the principal result file
saveResultsToFile(sw.ToString(),
resultsDir + "/results/" + testSetName + "/" + testName + ".out");
}
transformer.MessageListener = new TestOutcome.MessageListener(outcome);
// run without serialization
if (env.streamedPath != null)
{
transformer.SetInputStream(new FileStream(env.streamedPath, FileMode.Open, FileAccess.Read), testCase.BaseUri);
}
XdmDestination destination = new XdmDestination();
transformer.Implementation.setOutputURIResolver(
new OutputResolver(env.processor, outcome, false));
transformer.Run(destination);
//transformer. .transform();
outcome.SetPrincipalResult(destination.XdmNode);
//}
} catch (Exception err) {
outcome.SetException(err);
//outcome.SetErrorsReported(collector.getErrorCodes());
// err.printStackTrace();
// failures++;
//resultsDoc.writeTestcaseElement(testName, "fail", "*** crashed " + err.Message);
//return;
}
}
XdmNode assertion = (XdmNode)xpath.EvaluateSingle("result/*", testCase);
if (assertion == null)
{
failures++;
resultsDoc.writeTestcaseElement(testName, "fail", "No test assertions found");
return;
}
XPathCompiler assertionXPath = env.processor.NewXPathCompiler();
//assertionXPath.setLanguageVersion("3.0");
bool success = outcome.TestAssertion(assertion, outcome.GetPrincipalResultDoc(), assertionXPath, xpath, debug);
if (success)
{
if (outcome.GetWrongErrorMessage() != null)
{
outcome.SetComment(outcome.GetWrongErrorMessage());
wrongErrorResults++;
}
else
{
successes++;
}
resultsDoc.writeTestcaseElement(testName, "pass", outcome.GetComment());
}
else
{
failures++;
resultsDoc.writeTestcaseElement(testName, "fail", outcome.GetComment());
}
}
}
