/// <summary>
/// Run the transformation
/// </summary>
/// <param name="testName"></param>
/// <param name="xml"></param>
/// <param name="xsl"></param>
/// <param name="initialMode"></param>
/// <param name="initialTemplate"></param>
/// <param name="outfile"></param>
/// <param name="paramTable"></param>
/// <param name="initialContextPath"></param>
/// <param name="useAssociated"></param>
/// <param name="schemaAware"></param>
/// <param name="validationMode"></param>
/// <param name="recoverRecoverable"></param>
/// <returns>Either null, indicating success, or an Exception object with information about the failure</returns>
protected Exception runXSLT(String testName, String xml, String xsl, QName initialMode,
QName initialTemplate, String outfile, Hashtable paramTable, String initialContextPath,
bool useAssociated, bool schemaAware,
String validationMode, bool recoverRecoverable)
{
Serializer sr = new Serializer();
sr.SetOutputFile(outfile);
Processor f;
if (noCacheTests.ContainsKey(testName))
{
//create a custom Processor to avoid schema caching
f = new Processor(true);
}
else if (schemaAware)
{
f = schemaAwareProcessor;
if (f == null)
{
return(new DynamicError("Saxon-SA not available"));
}
}
else if (xml11)
{
f = processor;
// Use an Xml 1.1 processor
}
else
{
f = processor;
}
XdmNode source = null;
IList errors = new ArrayList();
XsltCompiler compiler = f.NewXsltCompiler();
compiler.SchemaAware = schemaAware;
compiler.ErrorList = errors;
XsltExecutable sheet = null;
XsltTransformer inst;
if (useAssociated)
{
try
{
source = buildSource(f.NewDocumentBuilder(), xml, validationMode);
}
catch (Exception e)
{
Console.WriteLine("Failed to build source document: " + e.Message);
return(e);
}
try
{
sheet = compiler.CompileAssociatedStylesheet(source);
}
catch (Exception e)
{
Console.WriteLine("Failed to compile stylesheet: " + e.Message);
if (errors.Count > 0)
{
return((Exception)errors[0]);
//QName code = ((StaticError)errors[0]).ErrorCode;
//(code == null ? "Failed to compile stylesheet: " + e.Message : code.LocalName);
}
else
{
return(e);
}
}
}
else
{
Stream stream = new FileStream(xsl, FileMode.Open, FileAccess.Read);
compiler.BaseUri = new Uri(xsl);
try
{
sheet = compiler.Compile(stream);
}
catch (Exception e)
{
if (errors.Count > 0)
{
return((StaticError)errors[0]);
}
else
{
Console.WriteLine(e.Message);
return(e);
}
}
finally
{
stream.Close();
}
}
if (initialContextPath != null)
{
if (source == null && xml != null)
{
try
{
source = buildSource(f.NewDocumentBuilder(), xml, validationMode);
}
catch (Exception e)
{
Console.WriteLine("Failed to build source document: " + e.Message);
return(e);
}
}
XPathCompiler xc = f.NewXPathCompiler();
XPathExecutable exp = xc.Compile(initialContextPath);
XPathSelector xpe = exp.Load();
xpe.ContextItem = source;
XdmNode node = (XdmNode)xpe.EvaluateSingle();
source = node;
}
inst = sheet.Load();
if (source != null)
{
inst.InitialContextNode = source;
}
if (source == null && xml != null)
{
Stream stream = new FileStream(xml, FileMode.Open, FileAccess.Read);
inst.SetInputStream(stream, new Uri(xml));
}
if (initialMode != null)
{
inst.InitialMode = initialMode;
}
if (initialTemplate != null)
{
try
{
inst.InitialTemplate = initialTemplate;
}
catch (DynamicError e)
{
return(e);
}
}
if (paramTable != null)
{
foreach (DictionaryEntry de in paramTable)
{
inst.SetParameter((QName)de.Key, new XdmAtomicValue(de.Value.ToString()));
}
}
inst.BaseOutputUri = new Uri(outfile);
inst.RecoveryPolicy = recoverRecoverable ? RecoveryPolicy.RecoverSilently : RecoveryPolicy.DoNotRecover;
if ("strict" == validationMode)
{
inst.SchemaValidationMode = SchemaValidationMode.Strict;
}
else
{
inst.SchemaValidationMode = SchemaValidationMode.None;
}
//inst.setURIResolver(factory.getURIResolver());
//inst.setErrorListener(errorListener);
//((Controller)inst).setRecoveryPolicy(recoverRecoverable ? Configuration.RECOVER_SILENTLY : Configuration.DO_NOT_RECOVER);
// To avoid test results being dependent on the date and time (and timezone), set a fixed
// date and time for the run
//((Controller)inst).setCurrentDateTime(new DateTimeValue("2005-01-01T12:49:30.5+01:00"));
try
{
inst.Run(sr);
}
catch (DynamicError e)
{
Console.WriteLine(e.Message);
return(e);
}
return(null); // indicating success
}
/////// <summary>
/////// Schematron validates a document.
///////
/////// If the validation process fails it throws a SchematronValidationFailedException If the
/////// document has any schematron errors it throws a SchematronErrorException
/////// </summary>
/////// <param name="document">The document to be validated</param>
/////// <param name="schematronStylesheet"></param>
////public void SchematronValidateXmlDocument(XmlDocument document, CompiledXslt compiledXsltEntry)
////{
//// if (this.errorXPath == null)
//// {
//// throw new Exception("No error XPath is set");
//// }
//// if (this.errorMessageXPath == null)
//// {
//// throw new Exception("No error message XPath is set");
//// }
//// XmlDocument result = null;
//// PrefixedNamespace[] prefixedNamespaces;
//// bool hasAnyErrors;
//// try
//// {
//// // this is fast and ugly...
//// result = xlstUtil.TransformXml(document, schematronStylesheet);
//// byte[] schematronResultBytes = Encoding.Default.GetBytes(result.OuterXml);
//// using (MemoryStream schematronResultMemoryStream = new MemoryStream(schematronResultBytes))
//// {
//// XmlTextReader schematronResultXmlTextReader = new XmlTextReader(schematronResultMemoryStream);
//// prefixedNamespaces = this.CreateDefaultNamespaceManager(schematronResultXmlTextReader);
//// hasAnyErrors = DocumentXPathResolver.HasAnyElementsByXpath(result, this.errorXPath, prefixedNamespaces);
//// }
//// }
//// catch (Exception ex)
//// {
//// throw new SchematronValidationFailedException(document, ex);
//// }
//// if (hasAnyErrors)
//// {
//// string firstErrorMessage = DocumentXPathResolver.GetFirstElementValueByXPath(result, this.errorMessageXPath, prefixedNamespaces);
//// throw new SchematronErrorException(result, firstErrorMessage);
//// }
//// else
//// {
//// // no schematron error
//// }
////}
/// <summary>
/// Schematron validates a document.
///
/// If the validation process fails it throws a SchematronValidationFailedException If the
/// document has any schematron errors it throws a SchematronErrorException
/// </summary>
/// <param name="documentAsString">The document to be validated</param>
/// <param name="compiledXslt"></param>
public void SchematronValidateXmlDocument(string documentAsString, CompiledXslt compiledXslt)
{
if (this.errorXPath == null)
{
throw new Exception("No error XPath is set");
}
if (this.errorMessageXPath == null)
{
throw new Exception("No error message XPath is set");
}
XmlDocument schematronResultXmlDocument = null;
PrefixedNamespace[] prefixedNamespaces = null;
bool hasAnyErrors = false;
bool documentValidated = false;
//// try
////{
//// result = xlstUtil.TransformXml(documentAsString, schematronStylesheet);
//// hasAnyErrors = DocumentXPathResolver.HasAnyElementsByXpath(result, this.errorXPath, prefixedNamespaces);
////}
////catch (Exception ex)
////{
//// XmlDocument xmlDoc = new XmlDocument();
//// xmlDoc.LoadXml(documentAsString);
//// throw new SchematronValidationFailedException(xmlDoc, ex);
////}
////if (hasAnyErrors)
////{
//// string firstErrorMessage = DocumentXPathResolver.GetFirstElementValueByXPath(result, this.errorMessageXPath, prefixedNamespaces);
//// throw new SchematronErrorException(result, firstErrorMessage);
////}
////else
////{
//// // no schematron error
////}
// ---------
try
{
// .Net build in xslt pserser - only xslt 1.0
if (compiledXslt != null && compiledXslt.XslCompiledTransform != null)
{
schematronResultXmlDocument = xlstUtil.TransformXml(documentAsString, compiledXslt.XslCompiledTransform);
byte[] schematronResultBytes = Encoding.Default.GetBytes(schematronResultXmlDocument.OuterXml);
using (MemoryStream schematronResultMemoryStream = new MemoryStream(schematronResultBytes))
{
XmlTextReader schematronResultXmlTextReader = new XmlTextReader(schematronResultMemoryStream);
prefixedNamespaces = this.CreateDefaultNamespaceManager(schematronResultXmlTextReader);
hasAnyErrors = DocumentXPathResolver.HasAnyElementsByXpath(schematronResultXmlDocument, this.errorXPath, prefixedNamespaces);
documentValidated = true;
}
}
}
catch (Exception ex)
{
Debug.Fail(ex.Message);
}
if (documentValidated == false)
{
// Not xslt 1.0, or complex xslt 1.0 - so try Saxon xslt
try
{
using (MemoryStream schematronResultMemoryStream = new MemoryStream())
{
using (MemoryStream xmlSchematronStylesheetMemoryStream = compiledXslt.Stream)
{
xmlSchematronStylesheetMemoryStream.Flush();//Adjust this if you want read your data
xmlSchematronStylesheetMemoryStream.Position = 0;
Processor processor = new Processor();
XsltCompiler compiler = processor.NewXsltCompiler();
Uri uri = new Uri("file://" + compiledXslt.FileInfo.Directory.FullName);
compiler.ErrorList = new List <object>();
compiler.BaseUri = uri;
Serializer serializer = new Serializer();
try
{
XsltTransformer saxonTransformer = compiler.Compile(xmlSchematronStylesheetMemoryStream).Load();
// Load the XML document. Input to the build method is the document.
DocumentBuilder docBuilder = processor.NewDocumentBuilder();
if (docBuilder.BaseUri == null)
{
docBuilder.BaseUri = uri;
}
XdmNode docXdmNode = docBuilder.Build(documentAsString.ToStream());
// Set the root node of the source document to be the initial
// context node
saxonTransformer.InitialContextNode = docXdmNode;
// Init. the result object
serializer.SetOutputProperty(Serializer.INDENT, "yes");
serializer.SetOutputProperty(Serializer.ENCODING, Encoding.UTF8.BodyName);
serializer.SetOutputStream(schematronResultMemoryStream);
// Run the transformation with result object as input param.
saxonTransformer.Run(serializer);
}
catch (Exception)
{
// easy debugging
throw;
}
finally
{
// close/dispose
serializer.Close();
}
}
// convert the schematronResultMemoryStream, into a xmlDocument
schematronResultMemoryStream.Position = 0;
schematronResultXmlDocument = new XmlDocument();
schematronResultXmlDocument.Load(schematronResultMemoryStream);
schematronResultMemoryStream.Position = 0;
XmlTextReader schematronResultXmlTextReader = new XmlTextReader(schematronResultMemoryStream);
prefixedNamespaces = this.CreateDefaultNamespaceManager(schematronResultXmlTextReader);
hasAnyErrors = DocumentXPathResolver.HasAnyElementsByXpath(schematronResultXmlDocument, this.errorXPath, prefixedNamespaces);
documentValidated = true;
}
}
catch (Exception ex)
{
Debug.Fail(ex.Message);
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(documentAsString.ToStream());
throw new SchematronValidationFailedException(xmlDocument, ex);
}
}
if (documentValidated == false)
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(documentAsString.ToStream());
throw new SchematronValidationFailedException(xmlDocument, new Exception("Failed to validate the document."));
}
if (hasAnyErrors)
{
string firstErrorMessage = DocumentXPathResolver.GetFirstElementValueByXPath(schematronResultXmlDocument, this.errorMessageXPath, prefixedNamespaces);
throw new SchematronErrorException(schematronResultXmlDocument, firstErrorMessage);
}
else
{
// no schematron error
}
}
public static string TransformXml(string xmlData, string xslData)
{
string results = "";
try
{
// Saxon Transformation Start
Processor xsltProcessor = new Processor();
DocumentBuilder documentBuilder = xsltProcessor.NewDocumentBuilder();
documentBuilder.BaseUri = new Uri("file://");
XdmNode xdmNode = documentBuilder.Build(new StringReader(xmlData));
XsltCompiler xsltCompiler = xsltProcessor.NewXsltCompiler();
XsltExecutable xsltExecutable = xsltCompiler.Compile(new StringReader(xslData));
XsltTransformer xsltTransformer = xsltExecutable.Load();
xsltTransformer.InitialContextNode = xdmNode;
XdmDestination xdmDest = new XdmDestination();
xsltTransformer.Run(xdmDest);
// Saxon Transformation End
// Handle XML Declaration
string version = "1.0";
string encoding = "UTF-8";
string standalone = null;
string declaration = new XDeclaration(version, encoding, standalone).ToString() + Environment.NewLine;
try
{
XDocument xslt = XDocument.Parse(xslData);
XNamespace xsl = "http://www.w3.org/1999/XSL/Transform";
XElement elem = xslt.Root.Element(xsl + "output");
if (elem != null)
{
if (elem.Attribute("version") != null)
{
version = elem.Attribute("version").Value;
}
if (elem.Attribute("encoding") != null)
{
encoding = elem.Attribute("encoding").Value;
}
if (elem.Attribute("standalone") != null)
{
standalone = elem.Attribute("standalone").Value;
}
declaration = new XDeclaration(version, encoding, standalone).ToString() + Environment.NewLine;
// Clear Declaration
if (elem.Attribute("omit-xml-declaration") != null && elem.Attribute("omit-xml-declaration").Value == "yes")
{
declaration = "";
}
if (elem.Attribute("method") != null && elem.Attribute("method").Value != "xml")
{
declaration = "";
}
}
// Attempt to prevent duplicate declaration
if (xdmDest.XdmNode.OuterXml.StartsWith("<?"))
{
declaration = "";
}
}
catch
{
// ignore exception
}
results = declaration + xdmDest.XdmNode.OuterXml;
}
catch (Exception e)
{
throw e;
}
return(results);
}
static bool[] FunctionsAvailable(QName[] names, Processor processor, XPathItemFactory itemFactory)
{
const string xsltNs = "http://www.w3.org/1999/XSL/Transform";
IXPathNavigable stylesheetDoc = itemFactory.BuildNode();
XmlWriter builder = stylesheetDoc.CreateNavigator().AppendChild();
builder.WriteStartElement("stylesheet", xsltNs);
builder.WriteAttributeString("version", "2.0");
for (int i = 0; i < names.Length; i++)
{
QName item = names[i];
builder.WriteAttributeString("xmlns", "p" + i.ToStringInvariant(), null, item.Uri);
}
builder.WriteStartElement("output", xsltNs);
builder.WriteAttributeString("method", "text");
builder.WriteEndElement();
builder.WriteStartElement("template", xsltNs);
builder.WriteAttributeString("name", "main");
for (int i = 0; i < names.Length; i++)
{
QName item = names[i];
if (i > 0)
{
builder.WriteElementString("text", xsltNs, "|");
}
builder.WriteStartElement("value-of", xsltNs);
builder.WriteAttributeString("select", "function-available('{0}:{1}')".FormatInvariant("p" + i.ToStringInvariant(), item.LocalName));
builder.WriteEndElement();
}
builder.WriteEndElement(); // template
builder.WriteEndElement(); // stylesheet
builder.Close();
XsltCompiler compiler = processor.NewXsltCompiler();
compiler.BaseUri = new Uri("foo:bar");
compiler.XmlResolver = null;
XsltTransformer transform = compiler.Compile(stylesheetDoc.CreateNavigator().ReadSubtree()).Load();
transform.InitialTemplate = new QName("main");
using (var output = new StringWriter(CultureInfo.InvariantCulture)) {
var serializer = new Serializer();
serializer.SetOutputWriter(output);
transform.Run(serializer);
return(output.ToString().Trim().Split('|').Select(s => XmlConvert.ToBoolean(s)).ToArray());
}
}
/// <summary>
/// Validates a document
/// </summary>
/// <param name="xmlDocument">document to validate</param>
/// <param name="compiledXslt">stylesheet to use</param>
public void SchematronValidateXmlDocument(XmlDocument xmlDocument, CompiledXslt compiledXslt)
{
if (this.errorXPath == null)
{
throw new Exception("No error XPath is set");
}
if (this.errorMessageXPath == null)
{
throw new Exception("No error message XPath is set");
}
bool documentValidated = false;
PrefixedNamespace[] prefixedNamespaces = null;// = this.CreateDefaultNamespaceManager(xmlTextReader);
bool hasAnyErrors = false;
XmlDocument schematronResultXmlDocument = null;
// First we try windows build in transformer. It handle xslt 1.0, but not xslt 2.0. Any
// stylesheet in xslt 2.0 will fail, and some xslt 1.0, as they is too complex for the parser.
try
{
// .Net build in xslt parser - only xslt 1.0
if (compiledXslt != null && compiledXslt.XslCompiledTransform != null)
{
schematronResultXmlDocument = xlstUtil.TransformXml(xmlDocument, compiledXslt.XslCompiledTransform);
byte[] schematronResultBytes = Encoding.Default.GetBytes(schematronResultXmlDocument.OuterXml);
using (MemoryStream schematronResultMemoryStream = new MemoryStream(schematronResultBytes))
{
XmlTextReader schematronResultXmlTextReader = new XmlTextReader(schematronResultMemoryStream);
prefixedNamespaces = this.CreateDefaultNamespaceManager(schematronResultXmlTextReader);
hasAnyErrors = DocumentXPathResolver.HasAnyElementsByXpath(schematronResultXmlDocument, this.errorXPath, prefixedNamespaces);
documentValidated = true;
}
}
}
catch (Exception ex)
{
Debug.Fail(ex.Message);
}
if (documentValidated == false)
{
// Not xslt 1.0, or complex xslt 1.0 - so try Saxon xslt
try
{
using (MemoryStream schematronResultMemoryStream = new MemoryStream())
{
using (MemoryStream xmlSchematronStylesheetMemoryStream = compiledXslt.Stream)
{
xmlSchematronStylesheetMemoryStream.Flush();//Adjust this if you want read your data
xmlSchematronStylesheetMemoryStream.Position = 0;
Processor processor = new Processor();
XsltCompiler compiler = processor.NewXsltCompiler();
Serializer serializer = new Serializer();
try
{
XsltTransformer saxonTransformer = compiler.Compile(xmlSchematronStylesheetMemoryStream).Load();
// Load the XML document. Input to the build method is the document.
XdmNode docXdmNode = processor.NewDocumentBuilder().Build(xmlDocument);
// Set the root node of the source document to be the initial
// context node
saxonTransformer.InitialContextNode = docXdmNode;
// Init. the result object
serializer.SetOutputProperty(Serializer.INDENT, "yes");
serializer.SetOutputProperty(Serializer.ENCODING, Encoding.UTF8.BodyName);
serializer.SetOutputStream(schematronResultMemoryStream);
// Run the transformation with result object as input param.
saxonTransformer.Run(serializer);
}
catch (Exception)
{
// easy debugging
throw;
}
finally
{
// close/dispose
serializer.Close();
}
}
// convert the schematronResultMemoryStream, into a xmlDocument
schematronResultMemoryStream.Position = 0;
schematronResultXmlDocument = new XmlDocument();
schematronResultXmlDocument.Load(schematronResultMemoryStream);
schematronResultMemoryStream.Position = 0;
XmlTextReader schematronResultXmlTextReader = new XmlTextReader(schematronResultMemoryStream);
prefixedNamespaces = this.CreateDefaultNamespaceManager(schematronResultXmlTextReader);
hasAnyErrors = DocumentXPathResolver.HasAnyElementsByXpath(schematronResultXmlDocument, this.errorXPath, prefixedNamespaces);
documentValidated = true;
}
}
catch (Exception ex)
{
Debug.Fail(ex.Message);
throw new SchematronValidationFailedException(xmlDocument, ex);
}
}
if (documentValidated == false)
{
throw new SchematronValidationFailedException(xmlDocument, new Exception("Failed to validate the document."));
}
if (hasAnyErrors)
{
string firstErrorMessage = DocumentXPathResolver.GetFirstElementValueByXPath(schematronResultXmlDocument, this.errorMessageXPath, prefixedNamespaces);
throw new SchematronErrorException(schematronResultXmlDocument, firstErrorMessage);
}
else
{
// no schematron error
}
}
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());
}
}
}
static ProcessorException WrapCompileException(Exception ex, XsltCompiler compiler)
{
return(WrapCompileException(ex, compiler.ErrorList));
}
private void Transform()
{
var processor = new Processor();
XsltCompiler compiler = processor.NewXsltCompiler();
XMLForm frmXML = null;
XSLForm frmXSL = null;
try
{
Cursor.Current = Cursors.WaitCursor;
// Find the XSL form and XML forms
foreach (Form frm in this.MdiChildren)
{
if (frm.Tag == null)
{
if (frm.Name == "XMLForm")
{
frmXML = (XMLForm)frm;
}
else if (frm.Name == "XSLForm")
{
frmXSL = (XSLForm)frm;
}
}
}
if (frmXML == null)
{
throw new ApplicationException("No XML form found");
}
if (frmXSL == null)
{
throw new ApplicationException("No XSL form found");
}
if (frmXSL.TextEditor.Text == "")
{
throw new ApplicationException("XSL form is empty");
}
if (frmXML.TextEditor.Text == "")
{
throw new ApplicationException("XML form is empty");
}
TextReader xslReader = new StringReader(frmXSL.TextEditor.Text);
// Compile stylesheet
XsltExecutable executable = compiler.Compile(xslReader);
// Do transformation to a destination
RawDestination destination = new RawDestination();
using (MemoryStream xmlStream = new MemoryStream(Encoding.UTF8.GetBytes(frmXML.TextEditor.Text ?? "")))
{
Xslt30Transformer transformer = executable.Load30();
transformer.ApplyTemplates(xmlStream, destination);
}
string result;
if (this.indentResultToolStripMenuItem.Checked)
{
// Indent the XML
var stringBuilder = new StringBuilder();
var element = XElement.Parse(destination.XdmValue.ToString());
var settings = new XmlWriterSettings();
settings.OmitXmlDeclaration = false;
settings.Indent = true;
settings.NewLineOnAttributes = false;
using (var xmlWriter = XmlWriter.Create(stringBuilder, settings))
{
element.Save(xmlWriter);
}
result = stringBuilder.ToString();
}
else
{
result = destination.XdmValue.ToString();
}
// Get / create the form
XMLForm frmResult = null;
if (this.overwriteOutputToolStripMenuItem.Checked)
{
foreach (Form frm in this.MdiChildren)
{
if (frm.Tag != null)
{
if (frm.Tag.ToString() == "Output")
{
frmResult = (XMLForm)frm;
break;
}
}
}
}
// If form has not been got then create it
if (frmResult == null)
{
frmResult = new XMLForm();
frmResult.Owner = this;
}
else
{
frmResult.TopMost = true;
frmResult.BringToFront();
}
frmResult.MdiParent = this;
frmResult.TextEditor.Text = result;
frmResult.Tag = "Output";
frmResult.Show();
}
catch (Exception ex)
{
string err = ex.Message + "\n";
err += ex.GetType().ToString() + "\n";
foreach (StaticError staticErr in compiler.ErrorList)
{
err += staticErr.Message + " (line no : " + staticErr.LineNumber + ")\n";
}
MessageBox.Show(err);
}
finally
{
Cursor.Current = Cursors.Default;
}
}
public SaxonEEDriver()
{
processor = new Processor(true);
compiler = processor.NewXsltCompiler();
// Console.WriteLine(processor.ProductTitle + " Version:"+ processor.ProductVersion);
}
private static string TransformSAXON(string document, string xslt, string tmpDir)
{
try
{
Processor processor = new Processor();
XsltCompiler xsltCompiler = processor.NewXsltCompiler();
if (!Directory.Exists(tmpDir))
{
tmpDir = Path.GetTempPath();
}
string tmpXsltFile = tmpDir + "tmp.xslt";
File.WriteAllText(tmpXsltFile, xslt, Encoding.UTF8);
XsltExecutable xsltExecutable = xsltCompiler.Compile(new Uri(@"file://" + tmpXsltFile));
int si = document.IndexOf("xmlns:xsi=\"");
int ei = document.IndexOf("\"", si + "xmlns:xsi=\"".Length) + 1;
string text = document.Remove(si, ei - si);
si = text.IndexOf("xmlns=\"");
ei = text.IndexOf("\"", si + "xmlns=\"".Length) + 1;
string xmlns = text.Substring(si, ei - si);
text = text.Remove(si, ei - si);
string tmpDoc = tmpDir + "tmp.xml";
File.WriteAllText(tmpDoc, text.Replace("utf-16", "utf-8"), Encoding.UTF8);
//StringBuilder outputBuilder = new StringBuilder();
//XmlWriterSettings outputWriterSettings = new XmlWriterSettings { Indent = true, CheckCharacters = false, NewLineOnAttributes = true};
//XmlWriter outputWriter = XmlWriter.Create(outputBuilder, outputWriterSettings);
//Debug.Assert(outputWriter != null);
//XsltArgumentList xsltArgumentList = new XsltArgumentList();
FileStream fs = null;
try
{
XsltTransformer xsltTransformer = xsltExecutable.Load();
fs = new FileStream(tmpDoc, FileMode.Open);
xsltTransformer.SetInputStream(fs, new Uri(@"file://" + tmpDoc));
XdmDestination destination = new XdmDestination();
xsltTransformer.Run(destination);
StringBuilder outputBuilder = new StringBuilder();
outputBuilder.Append(destination.XdmNode.OuterXml);
//outputWriter.Flush();
int pos1 = outputBuilder.ToString().IndexOf(">");
int pos2 = outputBuilder.ToString().IndexOf("/>");
int pos;
if (pos1 == -1)
{
pos = pos2;
}
else if (pos2 == -1)
{
pos = pos1;
}
else
{
pos = Math.Min(pos1, pos2);
}
outputBuilder.Insert(pos,
Environment.NewLine + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " + xmlns);
XmlDocument d = new XmlDocument();
StringReader outputReader = new StringReader(outputBuilder.ToString());
d.Load(outputReader);
outputReader.Close();
return(d.PrettyPrintXML());
}
finally
{
if (fs != null)
{
fs.Close();
}
}
}
catch (Exception e)
{
System.Windows.MessageBox.Show(e.Message);
return(string.Empty);
}
}
private static string TransformSAXON(string document, string xslt, string tmpDir, PSMSchema psmSchema = null, bool schemaAware = false)
{
Processor processor = new Processor();
XsltCompiler xsltCompiler = processor.NewXsltCompiler();
//xsltCompiler.SchemaAware = true;
xsltCompiler.Processor.SetProperty(FeatureKeys.GENERATE_BYTE_CODE, "false");
if (!Directory.Exists(tmpDir))
{
tmpDir = Path.GetTempPath();
}
using (StringReader sr = new StringReader(xslt))
{
XsltExecutable xsltExecutable = xsltCompiler.Compile(sr);
string text;
if (!schemaAware)
{
int si = document.IndexOf("xmlns:xsi=\"");
int ei = document.IndexOf("\"", si + "xmlns:xsi=\"".Length) + 1;
text = si != -1 ? document.Remove(si, ei - si) : document;
si = text.IndexOf("xmlns=\"");
ei = text.IndexOf("\"", si + "xmlns=\"".Length) + 1;
string xmlns = si != -1 ? text.Substring(si, ei - si) : string.Empty;
text = si != -1 ? text.Remove(si, ei - si) : text;
}
else
{
text = document;
}
string tmpDoc = tmpDir + "tmp.xml";
if (schemaAware)
{
XsdSchemaGenerator xsdGen = new XsdSchemaGenerator();
xsdGen.Initialize(psmSchema);
xsdGen.GenerateXSDStructure();
XDocument schema = xsdGen.GetXsd();
string schemaLoc = tmpDir + "LastSchema.xsd";
schema.Save(schemaLoc);
}
File.WriteAllText(tmpDoc, text.Replace("utf-16", "utf-8"), Encoding.UTF8);
StringBuilder outputBuilder = new StringBuilder();
//XmlWriterSettings outputWriterSettings = new XmlWriterSettings { Indent = true, CheckCharacters = false, NewLineOnAttributes = true };
//XmlWriter outputWriter = XmlWriter.Create(outputBuilder, outputWriterSettings);
//Debug.Assert(outputWriter != null);
XsltArgumentList xsltArgumentList = new XsltArgumentList();
FileStream fs = null;
try
{
XsltTransformer xsltTransformer = xsltExecutable.Load();
if (schemaAware)
{
xsltTransformer.SchemaValidationMode = SchemaValidationMode.Strict;
}
fs = new FileStream(tmpDoc, FileMode.Open);
xsltTransformer.SetInputStream(fs, new Uri(@"file://" + tmpDoc));
XdmDestination destination = new XdmDestination();
xsltTransformer.Run(destination);
outputBuilder.Append(destination.XdmNode.OuterXml);
//outputWriter.Flush();
int pos1 = outputBuilder.ToString().IndexOf(">");
int pos2 = outputBuilder.ToString().IndexOf("/>");
int pos;
if (pos1 == -1)
{
pos = pos2;
}
else if (pos2 == -1)
{
pos = pos1;
}
else
{
pos = Math.Min(pos1, pos2);
}
//outputBuilder.Insert(pos,
// Environment.NewLine + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " + xmlns);
StringReader outputReader = new StringReader(outputBuilder.ToString());
XDocument d = XDocument.Load(outputReader);
outputReader.Close();
return(d.PrettyPrintXML());
}
finally
{
if (fs != null)
{
fs.Close();
}
}
}
}
public void OneTimeTearDown()
{
_compiler = null;
_processor = null;
}
public void OneTimeSetUp()
{
_processor = new Processor();
_compiler = _processor.NewXsltCompiler();
}
public SaxonHEDriver()
{
processor = new Processor(false);
compiler = processor.NewXsltCompiler();
}
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);
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();
XmlUrlResolver res = new XmlUrlResolver();
if (stylesheet != null)
{
XsltCompiler compiler = env.xsltCompiler;
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");
try
{
sheet = compiler.Compile(stream);
} catch (Exception err) {
outcome.SetException(err);
//outcome.SetErrorsReported(collector.GetErrorCodes);
}
// compiler.setErrorListener(collector);
}
if (sheet != null)
{
XdmItem contextItem = env.contextItem;
QName initialMode = getQNameAttribute(xpath, testInput, "initial-mode/@name");
QName initialTemplate = getQNameAttribute(xpath, testInput, "initial-template/@name");
try {
XsltTransformer transformer = sheet.Load();
//transformer.SetURIResolver(env); //TODO
if (env.unparsedTextResolver != null)
{
transformer.Implementation.setUnparsedTextURIResolver(env.unparsedTextResolver);
}
if (initialTemplate != null)
{
transformer.InitialTemplate = initialTemplate;
}
if (initialMode != null)
{
transformer.InitialMode = initialMode;
}
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());
}
}
public bool validate(EA.Repository Repository, string maxFile, string schFile, string svrlFile)
{
string iso_sch_xsl_file = Main.getAppDataFullPath(@"Schematron\iso_svrl_for_xslt2.xsl");
string sch_xsl_file = Path.Combine(Filters.CurrentOutputPath, "max-tmp.sch.xsl");
// Create a Processor instance.
Processor processor = new Processor();
XsltCompiler compiler = processor.NewXsltCompiler();
compiler.ErrorList = new List <StaticError>();
DocumentBuilder builder = processor.NewDocumentBuilder();
// First transform the Schematron to XSLT
try
{
// Create a transformer for the stylesheet.
XsltTransformer transformer = compiler.Compile(new Uri(iso_sch_xsl_file)).Load();
// Load the source document
XdmNode input = builder.Build(new Uri(schFile));
// Set the root node of the source document to be the initial context node
transformer.InitialContextNode = input;
// Create a serializer, with output to the standard output stream
Serializer serializer = new Serializer();
//StringWriter output = new StringWriter();
//serializer.SetOutputWriter(output);
serializer.SetOutputFile(sch_xsl_file);
// Transform the source XML and serialize the result document
transformer.Run(serializer);
}
catch (Exception ex)
{
if (Repository == null)
{
Console.WriteLine(ex);
StringBuilder sb = new StringBuilder();
foreach (var error in compiler.ErrorList)
{
sb.AppendLine(error.ToString());
}
Console.WriteLine(sb);
}
else
{
Main.LogMessage(Repository, ex.Message, 0);
foreach (var error in compiler.ErrorList)
{
Main.LogMessage(Repository, error.ToString(), 0);
}
}
return(true);
}
// Now run the Schematron XSLT on the XML
try
{
// Create a transformer for the stylesheet.
XsltTransformer transformer = compiler.Compile(new Uri(sch_xsl_file)).Load();
// Load the source document
XdmNode input = builder.Build(new Uri(maxFile));
// Set the root node of the source document to be the initial context node
transformer.InitialContextNode = input;
// Create a serializer, with output to the standard output stream
Serializer serializer = new Serializer();
serializer.SetOutputFile(svrlFile);
// Transform the source XML and serialize the result document
transformer.Run(serializer);
// Show messages in Output Tab
XmlReader xReader = XmlReader.Create(svrlFile);
using (xReader)
{
XElement svrl = XElement.Load(xReader);
XmlNamespaceManager nsmgr = new XmlNamespaceManager(xReader.NameTable);
nsmgr.AddNamespace("svrl", "http://purl.oclc.org/dsdl/svrl");
appendSvrlMessagesToOutputTab(Repository, svrl.XPathSelectElements("//svrl:successful-report", nsmgr), nsmgr);
appendSvrlMessagesToOutputTab(Repository, svrl.XPathSelectElements("//svrl:failed-assert", nsmgr), nsmgr);
}
return(false);
}
catch (Exception ex)
{
if (Repository == null)
{
Console.WriteLine(ex);
StringBuilder sb = new StringBuilder();
foreach (var error in compiler.ErrorList)
{
sb.AppendLine(error.ToString());
}
Console.WriteLine(sb);
}
else
{
Main.LogMessage(Repository, ex.Message, 0);
foreach (var error in compiler.ErrorList)
{
Main.LogMessage(Repository, error.ToString(), 0);
}
}
return(true);
}
}
