/**
* Show a query reading an input document using an XmlReader (the .NET XML parser)
*/
public static void ExampleFromXmlReader(String inputFileName)
{
Processor processor = new Processor();
XmlTextReader reader = new XmlTextReader(inputFileName,
new FileStream(inputFileName, FileMode.Open, FileAccess.Read));
reader.Normalization = true;
// add a validating reader - not to perform validation, but to expand entity references
XmlValidatingReader validator = new XmlValidatingReader(reader);
validator.ValidationType = ValidationType.None;
XdmNode doc = processor.NewDocumentBuilder().Build(validator);
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile("/");
XQueryEvaluator eval = exp.Load();
eval.ContextItem = doc;
Serializer qout = new Serializer();
qout.SetOutputProperty(Serializer.METHOD, "xml");
qout.SetOutputProperty(Serializer.INDENT, "yes");
qout.SetOutputStream(new FileStream("testoutput2.xml", FileMode.Create, FileAccess.Write));
eval.Run(qout);
}
/**
* Static method called as an external function call to evaluate a literal when running in "unfolded" mode.
* The function simply returns the value of its argument - but the optimizer doesn't know that, so it
* can't pre-evaluate the call at compile time.
*
* @param value the value to be returned
* @return the supplied value, unchanged
*/
/*public static Sequence lazyLiteral(Sequence value) {
* return value;
* } */
/**
* Collect together information about all the dependencies of tests that use a given environment
* @param processor the Saxon processor
* @param env the environment for which dependency information is to be gathered
* @
*/
private void buildDependencyDictionary(Processor processor, Environment env)
{
XQueryCompiler xqCompiler = processor.NewXQueryCompiler();
xqCompiler.XQueryLanguageVersion = "3.0";
xqCompiler.BaseUri = testSuiteDir;
XdmValue result = xqCompiler.Compile(
" declare namespace fots = \"http://www.w3.org/2010/09/qt-fots-catalog\";\n" +
" let $testsets := doc('" + testSuiteDir + "/catalog.xml')//fots:test-set/@file/doc(resolve-uri(., exactly-one(base-uri(.))))\n" +
" for $dependencyTS in $testsets//fots:dependency\n" +
" let $name := $dependencyTS/@type\n" +
" let $value := $dependencyTS/@value\n" +
" group by $name, $value\n" +
" order by $name, $value\n" +
" return <dependency type='{$name}' value='{$value}' />").Load().Evaluate();
foreach (XdmItem item in result)
{
XdmNode node = (XdmNode)item;
string type = node.GetAttributeValue(new QName("type"));
string value = node.GetAttributeValue(new QName("value"));
addDependency(type, value, dependencyIsSatisfied(node, env));
}
}
/**
* Show a query producing a sequence as its result and returning the sequence
* to the Java application in the form of an iterator. The sequence is then
* output by serializing each item individually, with each item on a new line.
*/
public static void ExampleToSerializedSequence(String inputFileName)
{
Processor processor = new Processor();
XmlTextReader reader = new XmlTextReader(inputFileName,
new FileStream(inputFileName, FileMode.Open, FileAccess.Read));
reader.Normalization = true;
// add a validating reader - not to perform validation, but to expand entity references
XmlValidatingReader validator = new XmlValidatingReader(reader);
validator.ValidationType = ValidationType.None;
XdmNode doc = processor.NewDocumentBuilder().Build(reader);
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile("//ISBN");
XQueryEvaluator eval = exp.Load();
eval.ContextItem = doc;
foreach (XdmNode node in eval)
{
Console.WriteLine(node.OuterXml);
}
}
// https://www.nuget.org/packages/Saxon-HE/
public string XQuery(string xml, string query)
{
Processor processor = new Processor();
XmlDocument input = new XmlDocument();
input.LoadXml(xml);
XdmNode indoc = processor.NewDocumentBuilder().Build(new XmlNodeReader(input));
DomDestination qout = new DomDestination();
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
eval.ContextItem = indoc;
eval.Run(qout);
XmlDocument outdoc = qout.XmlDocument;
using (var stringWriter = new StringWriter())
using (var xmlTextWriter = XmlWriter.Create(stringWriter))
{
outdoc.WriteTo(xmlTextWriter);
xmlTextWriter.Flush();
return(stringWriter.GetStringBuilder().ToString());
}
}
private void writeModuleReportXQuery(string paperName, string className, StreamWriter sw)
{
Processor pr = new Processor();
XQueryCompiler xqc = pr.NewXQueryCompiler();
string errPath = "Papers\\" + paperName + "\\" + className + "_err.xml";
XmlDocument errdoc = new XmlDocument();
errdoc.Load(errPath);
XmlElement root = errdoc.DocumentElement;
XmlNodeList ruleNodes = root.GetElementsByTagName("err-rule");
foreach (XmlNode xrule in ruleNodes)
{
string rule = xrule.InnerText;
//Console.WriteLine(rule);
XQueryExecutable xqe = xqc.Compile(rule);
XQueryEvaluator xqev = xqe.Load();
XdmValue result = xqev.Evaluate(); //对比结果
foreach (XdmItem rs in result)
{
sw.WriteLine(count + ". " + rs.ToString().Trim());
count++;
}
}
}
public void GenXML()
{
String sourceUri = Server.MapPath("5648.xml");
String xqUri = Server.MapPath("graph.xq");
using (FileStream sXml = File.OpenRead(sourceUri))
{
using (FileStream sXq = File.OpenRead(xqUri))
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.BaseUri = sourceUri;
XQueryExecutable exp = compiler.Compile(sXq);
XQueryEvaluator eval = exp.Load();
DocumentBuilder loader = processor.NewDocumentBuilder();
loader.BaseUri = new Uri(sourceUri);
XdmNode indoc = loader.Build(new FileStream(sourceUri, FileMode.Open, FileAccess.Read));
eval.ContextItem = indoc;
Serializer qout = new Serializer();
qout.SetOutputProperty(Serializer.METHOD, "xml");
qout.SetOutputProperty(Serializer.INDENT, "yes");
qout.SetOutputProperty(Serializer.SAXON_INDENT_SPACES, "1");
qout.SetOutputWriter(Response.Output);
eval.Run(qout);
}
}
}
public XQueryExecutable Compile(TextReader module, XQueryCompileOptions options)
{
XQueryCompiler compiler = CreateCompiler(options);
try {
return(WrapExecutable(compiler.Compile(module.ReadToEnd()), options));
} catch (Exception ex) {
throw WrapCompileException(ex, compiler);
}
}
/**
* Show a query producing a single atomic value as its result and returning the value
* to the Java application
*/
public static void ExampleToSingleton()
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile("avg(for $i in 1 to 10 return $i * $i)");
XQueryEvaluator eval = exp.Load();
XdmAtomicValue result = (XdmAtomicValue)eval.EvaluateSingle();
Console.WriteLine("Result type: " + result.Value.GetType());
Console.WriteLine("Result value: " + (decimal)result.Value);
}
private XQueryExecutable CreateXQueryExecutable(string currentNamespaceURI = "", Processor processor = null)
{
XQueryExecutable xQueryExecutable = null;
if (processor != null && !string.IsNullOrEmpty(XQuery))
{
XQueryCompiler xQueryCompiler = processor.NewXQueryCompiler();
xQueryCompiler.DeclareNamespace(_evaluator.RuleNamespace, currentNamespaceURI);
xQueryExecutable = xQueryCompiler.Compile(XQuery);
}
return(xQueryExecutable);
}
/**
* Show how to run two queries in tandem. The second query is applied to the
* results of the first.
*/
public static void ExampleExtra()
{
// place-holder to add user-defined examples for testing
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile(@"<out>{matches('ABC', '\p{IsBasicLatin}*')}</out>");
XQueryEvaluator eval = exp.Load();
DomDestination dest = new DomDestination();
eval.Run(dest);
Console.WriteLine(dest.XmlDocument.OuterXml);
}
/// <summary>
/// Perform XQuery <paramref name="query"/> on XML document at <paramref name="input"/> using Saxon API.
/// </summary>
/// <param name="input">A valid XML document.</param>
/// <param name="query">An XQuery query.</param>
/// <returns>Returns the results of the <paramref name="query"/> as an XmlDocument.</returns>
public static XmlDocument PerformQuery(XmlDocument input, string query)
{
var processor = new Processor();
XdmNode inputXml = processor.NewDocumentBuilder().Build(new XmlNodeReader(input));
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable executable = compiler.Compile(query);
XQueryEvaluator evaluator = executable.Load();
evaluator.ContextItem = inputXml;
var domOut = new DomDestination();
evaluator.Run(domOut);
return(domOut.XmlDocument);
}
/**
* Show a query producing a sequence as its result and returning the sequence
* to the Java application in the form of an iterator. For each item in the
* result, its string value is output.
*/
public static void ExampleToSequence()
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile("for $i in 1 to 10 return $i * $i");
XQueryEvaluator eval = exp.Load();
XdmValue value = eval.Evaluate();
IEnumerator e = value.GetEnumerator();
while (e.MoveNext())
{
XdmItem item = (XdmItem)e.Current;
Console.WriteLine(item.ToString());
}
}
public void ExecuteQuery(string query, string destination, string dimension, string granularity)
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.BaseUri = BaseUri;
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
if (dimension.Equals("Geo", StringComparison.InvariantCultureIgnoreCase))
{
int id = GetMetaID("Country");
int id1 = GetMetaID("Region");
int id2 = GetMetaID("City");
int id3 = GetMetaID("Street");
eval.SetExternalVariable(new QName("Country"), new XdmAtomicValue(id));
eval.SetExternalVariable(new QName("Region"), new XdmAtomicValue(id1));
eval.SetExternalVariable(new QName("City"), new XdmAtomicValue(id2));
eval.SetExternalVariable(new QName("Street"), new XdmAtomicValue(id3));
//expr.bindInt(new QName("Country"), id, null);
//expr.bindInt(new QName("Region"), id1, null);
//expr.bindInt(new QName("City"), id2, null);
//expr.bindInt(new QName("Street"), id3, null);
}
else if (dimension.Equals("Time", StringComparison.InvariantCultureIgnoreCase))
{
int id = GetMetaID("Date/Time Original");
eval.SetExternalVariable(new QName("id"), new XdmAtomicValue(id));
}
else if (dimension.Equals("Social", StringComparison.InvariantCultureIgnoreCase))
{
int id = GetMetaID("Artist");
eval.SetExternalVariable(new QName("id"), new XdmAtomicValue(id));
}
Serializer qout = new Serializer();
qout.SetOutputProperty(Serializer.METHOD, "xml");
qout.SetOutputProperty(Serializer.INDENT, "yes");
FileStream outStream = new FileStream(BaseUri + destination, FileMode.Create, FileAccess.Write);
qout.SetOutputStream(outStream);
Console.WriteLine("Output written to " + destination);
eval.Run(qout);
outStream.Dispose();
outStream.Close();
qout.Close();
}
/**
* Show a query that takes a parameter (external variable) as input.
* The query produces a single atomic value as its result and returns the value
* to the Java application. For the types of value that may be returned, and
* their mapping to XPath data types, see {@link XPathEvaluator#Evaluate}
*/
public static void ExampleWithParam()
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.DeclareNamespace("p", "http://saxon.sf.net/ns/p");
XQueryExecutable exp = compiler.Compile(
"declare variable $p:in as xs:integer external; $p:in * $p:in");
XQueryEvaluator eval = exp.Load();
eval.SetExternalVariable(new QName("http://saxon.sf.net/ns/p", "p:in"), new XdmAtomicValue(12));
XdmAtomicValue result = (XdmAtomicValue)eval.EvaluateSingle();
Console.WriteLine("Result type: " + result.Value.GetType());
Console.WriteLine("Result value: " + (long)result.Value);
}
public List <MetadataAttributes> GetGeo(string granularity, bool distinct = true)
{
string query = "";
if (granularity.Equals("Country", StringComparison.InvariantCultureIgnoreCase))
{
query = String.Format(distinct ? XQueries.ExtractGeoArray : XQueries.ExtractGeoArray2, "Country");
}
else if (granularity.Equals("Region", StringComparison.InvariantCultureIgnoreCase))
{
query = String.Format(distinct ? XQueries.ExtractGeoArray : XQueries.ExtractGeoArray2, "Region");
}
else if (granularity.Equals("City", StringComparison.InvariantCultureIgnoreCase))
{
query = String.Format(distinct ? XQueries.ExtractGeoArray : XQueries.ExtractGeoArray2, "City");
}
else
{
query = String.Format(distinct ? XQueries.ExtractGeoArray : XQueries.ExtractGeoArray2, "Street");
};
List <MetadataAttributes> ts = new List <MetadataAttributes>();
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.BaseUri = BaseUri;
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
XdmValue value = eval.Evaluate();
IEnumerator e = value.GetEnumerator();
while (e.MoveNext())
{
Interval interval = new Interval();
var current = e.Current.ToString();
if (!current.Equals("")) // a revoir avec elio
{
MetadataAttributes geo = new MetadataAttributes("Geo", "Nominal", current, interval);
ts.Add(geo);
}
}
//ts.Reverse();
return(ts);
}
/**
* Show a query producing a document as its result and serializing this
* to a FileStream
*/
public static void ExampleToStreamResult()
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.BaseUri = "http://www.saxonica.com/";
compiler.DeclareNamespace("saxon", "http://saxon.sf.net/");
XQueryExecutable exp = compiler.Compile("<saxon:example>{static-base-uri()}</saxon:example>");
XQueryEvaluator eval = exp.Load();
Serializer qout = new Serializer();
qout.SetOutputProperty(Serializer.METHOD, "xml");
qout.SetOutputProperty(Serializer.INDENT, "yes");
qout.SetOutputProperty(Serializer.SAXON_INDENT_SPACES, "1");
qout.SetOutputStream(new FileStream("testoutput.xml", FileMode.Create, FileAccess.Write));
eval.Run(qout);
}
///<summary>
/// Demonstrate extensibility using user-written extension functions
///</summary>
public static void ExampleExtensibility()
{
String query =
"declare namespace ext = \"clitype:SampleExtensions.SampleExtensions?asm=SampleExtensions\";" +
"<out>" +
" <addition>{ext:add(2,2)}</addition>" +
" <average>{ext:average((1,2,3,4,5,6))}</average>" +
" <language>{ext:hostLanguage()}</language>" +
"</out>";
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
Serializer qout = new Serializer();
eval.Run(qout);
}
public List <string> GetObjects(string query)
{
List <string> objects = new List <string>();
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.BaseUri = BaseUri;
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
XdmValue value = eval.Evaluate();
IEnumerator e = value.GetEnumerator();
while (e.MoveNext())
{
objects.Add(e.Current.ToString());
}
return(objects);
}
/**
* Show a query taking a DOM as its input and producing a DOM as its output.
*/
public static void ExampleToDOM(String inputFileName)
{
Processor processor = new Processor();
XmlDocument input = new XmlDocument();
input.Load(inputFileName);
XdmNode indoc = processor.NewDocumentBuilder().Build(new XmlNodeReader(input));
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile("<doc>{reverse(/*/*)}</doc>");
XQueryEvaluator eval = exp.Load();
eval.ContextItem = indoc;
DomDestination qout = new DomDestination();
eval.Run(qout);
XmlDocument outdoc = qout.XmlDocument;
Console.WriteLine(outdoc.OuterXml);
}
public string Process(string xml, string xquery)
{
var executable = _compiler.Compile(xquery);
var evaluator = executable.Load();
//set default context node:
var doc = new XmlDocument();
doc.LoadXml(xml);
var root = _builder.Build(doc.DocumentElement);
evaluator.ContextItem = root;
var value = evaluator.Evaluate();
var result = String.Join(Environment.NewLine,
value.Cast <XdmItem>()
.Select(o => o.ToString())
);
return(result);
}
///<summary>
/// ExampleExtra is where you can place your own code for testing
///</summary>
public static void ExampleExtra()
{
// place-holder to add user-defined examples for testing
string xhtml = "<html><head><title>Hello World</title></head></html>";
string query = "data(/html/head/title)";
Processor processor = new Processor();
XmlDocument input = new XmlDocument();
input.LoadXml(xhtml);
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
eval.ContextItem = processor.NewDocumentBuilder().Build(new XmlNodeReader(input));
Serializer qout = new Serializer();
StringWriter sw = new StringWriter();
qout.SetOutputProperty(Serializer.OMIT_XML_DECLARATION, "yes"); qout.SetOutputWriter(sw); eval.Run(qout);
Console.WriteLine(sw);
}
public List <MetadataAttributes> GetSocial(string query)
{
List <MetadataAttributes> ts = new List <MetadataAttributes>();
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.BaseUri = BaseUri;
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
XdmValue value = eval.Evaluate();
IEnumerator e = value.GetEnumerator();
while (e.MoveNext())
{
Interval interval = new Interval();
MetadataAttributes social = new MetadataAttributes("Social", "Nominal", e.Current.ToString(), interval);
ts.Add(social);
}
return(ts);
}
/**
* Show a query taking a Saxon tree as its input and producing a Saxon tree as its output.
*/
public static void ExampleToXDM(String inputFileName)
{
Processor processor = new Processor();
DocumentBuilder loader = processor.NewDocumentBuilder();
loader.BaseUri = new Uri(inputFileName);
XdmNode indoc = loader.Build(
new FileStream(inputFileName, FileMode.Open, FileAccess.Read));
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile("<doc>{reverse(/*/*)}</doc>");
XQueryEvaluator eval = exp.Load();
eval.ContextItem = indoc;
XdmDestination qout = new XdmDestination();
eval.Run(qout);
XdmNode outdoc = qout.XdmNode;
Console.WriteLine(outdoc.OuterXml);
}
public int GetMetaID(String meta)
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
//compiler.DeclareNamespace("fn", "http://www.w3.org/2005/xpath-functions");
compiler.BaseUri = BaseUri;
XQueryExecutable exp = compiler.Compile(XQueries.GetMetaID);
XQueryEvaluator eval = exp.Load();
eval.SetExternalVariable(new QName("meta"), new XdmAtomicValue(meta));
//XdmAtomicValue result = (XdmAtomicValue)eval.EvaluateSingle();
XdmItem value = eval.EvaluateSingle();
IEnumerator e = value.GetEnumerator();
while (e.MoveNext())
{
//XdmItem item = (XdmItem)e.Current;
//Console.WriteLine(item.ToString());
return(Convert.ToInt32(e.Current.ToString()));
}
return(-1);
}
/**
* Show a query consisting of two modules, using a QueryResolver to resolve
* the "import module" declaration
*/
public static void ExampleMultiModule()
{
String mod1 = "import module namespace m2 = 'http://www.example.com/module2';" +
"m2:square(3)";
String mod2 = "module namespace m2 = 'http://www.example.com/module2';" +
"declare function m2:square($p) { $p * $p };";
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
InlineModuleResolver resolver = new InlineModuleResolver();
resolver.AddModule(new Uri("http://www.example.com/module2"), mod2);
compiler.QueryResolver = resolver;
XQueryExecutable exp = compiler.Compile(mod1);
XQueryEvaluator eval = exp.Load();
XdmAtomicValue result = (XdmAtomicValue)eval.EvaluateSingle();
Console.WriteLine("Result type: " + result.Value.GetType());
Console.WriteLine("Result value: " + (long)result.Value);
}
public void go(String[] args)
{
Console.WriteLine("Testing Saxon " + processor.ProductVersion);
testSuiteDir = args[0];
if (testSuiteDir.EndsWith("/"))
{
testSuiteDir = testSuiteDir.Substring(0, testSuiteDir.Length - 1);
}
saxonResultsDir = args[1];
if (saxonResultsDir.EndsWith("/"))
{
saxonResultsDir = saxonResultsDir.Substring(0, testSuiteDir.Length - 1);
}
Hashtable exceptions = new Hashtable();
if (args.Length > 1)
{
testPattern = (args[2]); // TODO: allow a regex
}
for (int i = 0; i < args.Length; i++)
{
if (args[i].Equals("-w"))
{
//showWarnings = true;
}
else if (args[i].Equals("-debug"))
{
debug = true;
}
}
fileComparer = new FileComparer(processor, testSuiteDir);
XPathCompiler xpc = processor.NewXPathCompiler();
xpc.DeclareNamespace("t", testURI);
xpc.DeclareVariable(new QName("", "param"));
findSourcePath = xpc.Compile("//t:test-suite/t:sources/t:source[@ID=$param]");
findCollection = xpc.Compile("//t:test-suite/t:sources/t:collection[@ID=$param]");
xpc = processor.NewXPathCompiler();
xpc.DeclareNamespace("t", testURI);
xpc.DeclareVariable(new QName("", "testcase"));
xpc.DeclareVariable(new QName("", "moduleuri"));
findModule = xpc.Compile("for $m in $testcase/t:module[@namespace=$moduleuri] " +
"return concat('file:///" + testSuiteDir +
"/', root($testcase)/t:test-suite/t:sources/t:module[@ID=string($m)]/@FileName, '.xq')");
//xpc = processor.NewXPathCompiler();
//xpc.DeclareNamespace("saxon", "http://saxon.sf.net/");
//xpc.DeclareVariable(new QName("", "actual"));
//xpc.DeclareVariable(new QName("", "gold"));
//xpc.DeclareVariable(new QName("", "debug"));
//compareDocuments = xpc.Compile("saxon:deep-equal($actual, $gold, (), if ($debug) then 'JNCPS?!' else 'JNCPS')");
QName testCaseNT = new QName(testURI, "test-case");
QName nameNT = new QName(testURI, "name");
QName queryNT = new QName(testURI, "query");
QName inputNT = new QName(testURI, "input");
QName inputFileNT = new QName(testURI, "input-file");
QName inputUriNT = new QName(testURI, "input-URI");
QName defaultCollectionNT = new QName(testURI, "defaultCollection");
QName outputFileNT = new QName(testURI, "output-file");
QName expectedErrorNT = new QName(testURI, "expected-error");
QName schemaNT = new QName(testURI, "schema");
QName contextItemNT = new QName(testURI, "contextItem");
QName inputQueryNT = new QName(testURI, "input-query");
QName sourceDocumentNT = new QName(testURI, "source-document");
QName errorNT = new QName(testURI, "error");
QName validationNT = new QName(testURI, "validation");
QName discretionaryItemsNT = new QName(testURI, "discretionary-items");
QName discretionaryFeatureNT = new QName(testURI, "discretionary-feature");
QName discretionaryChoiceNT = new QName(testURI, "discretionary-choice");
QName initialContextNodeNT = new QName(testURI, "initial-context-node");
QName fileAtt = new QName("", "file");
QName filePathAtt = new QName("", "FilePath");
QName fileNameAtt = new QName("", "FileName");
QName errorIdAtt = new QName("", "error-id");
QName compareAtt = new QName("", "compare");
QName nameAtt = new QName("", "name");
QName behaviorAtt = new QName("", "behavior");
QName qnameAtt = new QName("", "qname");
QName modeAtt = new QName("", "mode");
QName validatesAtt = new QName("", "validates");
QName variableAtt = new QName("", "variable");
QName roleAtt = new QName("", "role");
DocumentBuilder builder = processor.NewDocumentBuilder();
XdmNode exceptionsDoc = builder.Build(new Uri(saxonResultsDir + "/exceptions.xml"));
// The exceptions.xml file contains details of tests that aren't to be run, for example
// because they have known bugs or require special configuration
IEnumerator exceptionTestCases = exceptionsDoc.EnumerateAxis(XdmAxis.Descendant, new QName("", "exception"));
while (exceptionTestCases.MoveNext())
{
XdmNode n = (XdmNode)exceptionTestCases.Current;
String nameAttVal = n.StringValue;
char[] seps = { ' ', '\n', '\t' };
String[] parts = nameAttVal.Split(seps);
foreach (string p in parts)
{
if (!exceptions.ContainsKey(p))
{
exceptions.Add(p, "Exception");
}
}
}
// Hash table containing all source documents. The key is the document name in the
// catalog, the value is the corresponding document node
Hashtable sourceDocs = new Hashtable(50);
// Load the catalog
XdmNode catalog = builder.Build(new Uri(testSuiteDir + "/XQTScatalog.xml"));
// Add all Static Typing test cases to the exceptions list
xpc = processor.NewXPathCompiler();
xpc.DeclareNamespace("t", testURI);
XPathSelector st = xpc.Compile("//t:test-group[@name='StaticTyping']//t:test-case").Load();
st.ContextItem = catalog;
IEnumerator ste = st.GetEnumerator();
while (ste.MoveNext())
{
XdmNode testCase = (XdmNode)ste.Current;
exceptions.Add(testCase.GetAttributeValue(nameAtt), "StaticTypingException");
}
// Create the results file
results = new StreamWriter(saxonResultsDir + "/results"
+ processor.ProductVersion + "n.xml");
results.WriteLine("<test-suite-result xmlns='http://www.w3.org/2005/02/query-test-XQTSResult'>");
// Pre-load all the schemas
SchemaManager mgr = processor.SchemaManager;
IEnumerator se = catalog.EnumerateAxis(XdmAxis.Descendant, schemaNT);
while (se.MoveNext())
{
XdmNode schemaNode = (XdmNode)se.Current;
Console.WriteLine("Loading schema " + schemaNode.GetAttributeValue(fileNameAtt));
Uri location = new Uri(testSuiteDir + "/" + schemaNode.GetAttributeValue(fileNameAtt));
mgr.Compile(location);
}
total = 0;
IEnumerator testCases = catalog.EnumerateAxis(XdmAxis.Descendant, testCaseNT);
while (testCases.MoveNext())
{
total++;
}
// Process the test cases in turn
testCases = catalog.EnumerateAxis(XdmAxis.Descendant, testCaseNT);
while (testCases.MoveNext())
{
XdmNode testCase = (XdmNode)testCases.Current;
String testName = testCase.GetAttributeValue(nameAtt);
if (testPattern != null && !testName.StartsWith(testPattern))
{
continue;
}
if (exceptions.ContainsKey(testName))
{
continue;
}
Console.WriteLine("Test " + testName);
// Compile the query
String errorCode = null;
String filePath = testCase.GetAttributeValue(filePathAtt);
XdmNode query = getChildElement(testCase, queryNT);
String queryName = query.GetAttributeValue(nameAtt);
String queryPath = testSuiteDir + "/Queries/XQuery/" + filePath + queryName + ".xq";
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.BaseUri = new Uri(queryPath).ToString();
compiler.QueryResolver = new XqtsModuleResolver(testCase, findModule);
ArrayList errors = new ArrayList();
compiler.ErrorList = errors;
XQueryEvaluator xqe = null;
FileStream stream = null;
try
{
stream = new FileStream(queryPath, FileMode.Open, FileAccess.Read, FileShare.Read);
xqe = compiler.Compile(stream).Load();
}
catch (Exception e)
{
if (errors.Count > 0 && ((StaticError)errors[0]).ErrorCode != null)
{
errorCode = ((StaticError)errors[0]).ErrorCode.LocalName;
}
else if (e is StaticError && ((StaticError)e).ErrorCode != null)
{
Console.WriteLine(e.Message);
errorCode = ((StaticError)e).ErrorCode.LocalName;
}
else
{
Console.WriteLine(e.Message);
errorCode = "ErrorXXX";
}
}
finally
{
if (stream != null)
{
stream.Close();
}
}
// if the query compiled successfully, try to run it
String outputPath = null;
if (errorCode == null && xqe != null)
{
// Supply any input documents
IEnumerator en = testCase.EnumerateAxis(XdmAxis.Child, inputFileNT);
while (en.MoveNext())
{
XdmNode file = (XdmNode)en.Current;
String var = file.GetAttributeValue(variableAtt);
if (var != null)
{
String sourceName = file.StringValue;
XdmNode sourceDoc;
if (sourceDocs.ContainsKey(sourceName))
{
sourceDoc = (XdmNode)sourceDocs[sourceName];
}
else
{
sourceDoc = buildSource(catalog, builder, sourceName);
sourceDocs.Add(sourceName, sourceDoc);
}
xqe.SetExternalVariable(new QName("", var), sourceDoc);
}
}
// Supply any input URIs
IEnumerator eu = testCase.EnumerateAxis(XdmAxis.Child, inputUriNT);
while (eu.MoveNext())
{
XdmNode file = (XdmNode)eu.Current;
String var = file.GetAttributeValue(variableAtt);
if (var != null)
{
String sourceName = file.StringValue;
if (sourceName.StartsWith("collection"))
{
// Supply a collection URI.
// This seems to be the only way to distinguish a document URI
// from a collection URI.
String uri = "collection:" + sourceName;
XPathSelector xpe = findCollection.Load();
xpe.SetVariable(new QName("", "param"), new XdmAtomicValue(sourceName));
xpe.ContextItem = catalog;
XdmNode collectionNode = (XdmNode)xpe.EvaluateSingle();
if (collectionNode == null)
{
Console.WriteLine("*** Collection " + sourceName + " not found");
}
processor.RegisterCollection(new Uri(uri), getCollection(collectionNode));
xqe.SetExternalVariable(new QName("", var), new XdmAtomicValue(uri));
}
else
{
// Supply a document URI.
// We exploit the fact that the short name of the document is
// always the same as the file name in these tests
String uri = "file:///" + testSuiteDir + "/TestSources/" + sourceName + ".xml";
xqe.SetExternalVariable(new QName("", var), new XdmAtomicValue(uri));
}
}
}
// Supply the default collection if required
XdmNode defaultCollection = getChildElement(testCase, defaultCollectionNT);
if (defaultCollection != null)
{
String sourceName = defaultCollection.StringValue;
XPathSelector xpe = findCollection.Load();
xpe.SetVariable(new QName("", "param"), new XdmAtomicValue(sourceName));
xpe.ContextItem = catalog;
XdmNode collectionNode = (XdmNode)xpe.EvaluateSingle();
if (collectionNode == null)
{
Console.WriteLine("*** Collection " + sourceName + " not found");
}
processor.RegisterCollection(null, getCollection(collectionNode));
}
// Supply any external variables defined as the result of a separate query
IEnumerator ev = testCase.EnumerateAxis(XdmAxis.Child, inputQueryNT);
while (ev.MoveNext())
{
XdmNode inputQuery = (XdmNode)ev.Current;
String fileName = inputQuery.GetAttributeValue(nameAtt);
String subQueryPath = testSuiteDir + "/Queries/XQuery/" + filePath + fileName + ".xq";
XQueryCompiler subCompiler = processor.NewXQueryCompiler();
compiler.BaseUri = new Uri(subQueryPath).ToString();
FileStream subStream = new FileStream(subQueryPath, FileMode.Open, FileAccess.Read, FileShare.Read);
XdmValue value = subCompiler.Compile(subStream).Load().Evaluate();
String var = inputQuery.GetAttributeValue(variableAtt);
xqe.SetExternalVariable(new QName("", var), value);
}
// Supply the context item if required
IEnumerator ci = testCase.EnumerateAxis(XdmAxis.Child, contextItemNT);
while (ci.MoveNext())
{
XdmNode file = (XdmNode)ci.Current;
String sourceName = file.StringValue;
if (!sourceDocs.ContainsKey(sourceName))
{
XdmNode doc = buildSource(catalog, builder, sourceName);
sourceDocs.Add(sourceName, doc);
}
XdmNode sourceDoc = (XdmNode)sourceDocs[sourceName];
xqe.ContextItem = sourceDoc;
}
// Create a serializer for the output
outputPath = saxonResultsDir + "/results.net/" + filePath + queryName + ".out";
Serializer sr = new Serializer();
try
{
sr.SetOutputFile(outputPath);
sr.SetOutputProperty(new QName("", "method"), "xml");
sr.SetOutputProperty(new QName("", "omit-xml-declaration"), "yes");
sr.SetOutputProperty(new QName("", "indent"), "no");
}
catch (DynamicError)
{
// probably means that no output directory exists, which is probably because
// an error is expected
outputPath = saxonResultsDir + "/results.net/" + queryName + ".out";
sr.SetOutputFile(outputPath);
}
// Finally, run the query
try
{
xqe.Run(sr);
}
catch (DynamicError e)
{
Console.WriteLine(e.Message);
QName code = e.ErrorCode;
if (code != null && code.LocalName != null)
{
errorCode = code.LocalName;
}
else
{
errorCode = "ErrYYYYY";
}
}
catch (Exception e2)
{
Console.WriteLine("Unexpected exception: " + e2.Message);
Console.WriteLine(e2.StackTrace);
errorCode = "CRASH!!!";
}
}
// Compare actual results with expected results
if (errorCode != null)
{
// query returned an error at compile time or run-time, check this was expected
string expectedError = "";
bool matched = false;
IEnumerator en = testCase.EnumerateAxis(XdmAxis.Child, expectedErrorNT);
while (en.MoveNext())
{
XdmNode error = (XdmNode)en.Current;
String expectedErrorCode = error.StringValue;
expectedError += (expectedErrorCode + " ");
if (expectedErrorCode.Equals(errorCode))
{
matched = true;
feedback.Feedback(passed++, failed, total);
Console.WriteLine("Error " + errorCode + " as expected");
results.WriteLine("<test-case name='" + testName + "' result='pass'/>");
break;
}
}
if (!matched)
{
if (expectedError.Equals(""))
{
feedback.Feedback(passed, failed++, total);
Console.WriteLine("Error " + errorCode + ", expected success");
results.WriteLine("<test-case name='" + testName + "' result='fail' comment='error " + errorCode + ", expected success'/>");
}
else
{
feedback.Feedback(passed++, failed, total);
Console.WriteLine("Error " + errorCode + ", expected " + expectedError);
results.WriteLine("<test-case name='" + testName + "' result='pass' comment='error " + errorCode + ", expected " + expectedError + "'/>");
}
}
}
else
{
// query returned no error
bool matched = false;
String diag = "";
IEnumerator en = testCase.EnumerateAxis(XdmAxis.Child, outputFileNT);
while (en.MoveNext())
{
XdmNode outputFile = (XdmNode)en.Current;
String fileName = testSuiteDir + "/ExpectedTestResults/" + filePath + outputFile.StringValue;
String comparator = outputFile.GetAttributeValue(compareAtt);
if (comparator.Equals("Inspect"))
{
matched = true;
feedback.Feedback(passed++, failed, total);
results.WriteLine("<test-case name='" + testName + "' result='inspect'/>");
break;
}
else
{
String comparison = fileComparer.compare(outputPath, fileName, comparator);
matched = (comparison == "OK" || comparison.StartsWith("#"));
if (matched)
{
feedback.Feedback(passed++, failed, total);
results.WriteLine("<test-case name='" + testName + "' result='pass'/>");
diag = diag + ("<!-- " + comparison + " -->\n");
break;
}
}
}
if (!matched)
{
string expectedError = "";
IEnumerator ee = testCase.EnumerateAxis(XdmAxis.Child, expectedErrorNT);
while (ee.MoveNext())
{
XdmNode error = (XdmNode)ee.Current;
String expectedErrorCode = error.StringValue;
expectedError += (expectedErrorCode + " ");
}
if (expectedError.Equals(""))
{
feedback.Feedback(passed, failed++, total);
Console.WriteLine("Results differ from expected results");
results.WriteLine("<test-case name='" + testName + "' result='fail'/>");
}
else
{
feedback.Feedback(passed, failed++, total);
Console.WriteLine("Error " + expectedError + "expected but not reported");
results.WriteLine("<test-case name='" + testName + "' result='fail' comment='expected error " + expectedError + "not reported'/>");
}
}
}
}
results.WriteLine("</test-suite-result>");
results.Close();
}
public ViewModel(MainWindow v, Model model)
{
this.view = v;
this.model = model;
// Register the types for hightlighting. C#, VB.NET and TSQL are defined
// internally by the editor, so they do not need to be registered.
HighlightingManager.Instance.RegisterHighlighting("Go", new[] { ".go" }, LoadHighlightDefinition("Go.xshd"));
Properties.Settings.Default.PropertyChanged += (object sender, PropertyChangedEventArgs e) =>
{
// Save all the user's settings
Properties.Settings.Default.Save();
};
ExitCommand = new RelayCommand(
p => { Application.Current.Shutdown(); });
OpenSourceCommand = new RelayCommand(
p =>
{
var(extension, l) = this.Language;
OpenFileDialog dlg = new OpenFileDialog();
dlg.DefaultExt = extension; // Default file extension
dlg.Filter = l + " Files |*" + extension; // Filter files by extension
// Show open file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result.Value)
{
view.SourceEditor.Text = File.ReadAllText(dlg.FileName);
}
}
);
SaveSourceCommand = new RelayCommand(
p =>
{
var(e, l) = this.Language;
SaveFileDialog dlg = new SaveFileDialog
{
FileName = "document", // Default file name
DefaultExt = e, // Default file extension
Filter = l + " Files |*" + e // Filter files by extension
};
// Show save file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result.Value)
{
// Save document
File.WriteAllText(dlg.FileName, view.SourceEditor.Text);
}
}
);
OpenAstCommand = new RelayCommand(
p =>
{
OpenFileDialog dlg = new OpenFileDialog
{
DefaultExt = ".xml", // Default file extension
Filter = "XML Files |*.xml" // Filter files by extension
};
// Show open file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result.Value)
{
view.ResultsEditor.Text = File.ReadAllText(dlg.FileName);
}
}
);
SaveAstCommand = new RelayCommand(
p =>
{
SaveFileDialog dlg = new SaveFileDialog
{
FileName = "document", // Default file name
DefaultExt = ".xml", // Default file extension
Filter = "XML Files |*.xml" // Filter files by extension
};
// Show save file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result.Value)
{
// Save document
File.WriteAllText(dlg.FileName, view.ResultsEditor.Text);
}
}
);
OpenQueryCommand = new RelayCommand(
p =>
{
OpenFileDialog dlg = new OpenFileDialog
{
DefaultExt = ".xq", // Default file extension
Filter = "xq Files |*.xq" // Filter files by extension
};
// Show open file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result.Value)
{
view.QueryEditor.Text = File.ReadAllText(dlg.FileName);
}
}
);
SaveQueryCommand = new RelayCommand(
p =>
{
SaveFileDialog dlg = new SaveFileDialog();
dlg.FileName = "document"; // Default file name
dlg.DefaultExt = ".xq"; // Default file extension
dlg.Filter = "xq Files |*.xq"; // Filter files by extension
// Show save file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result.Value)
{
// Save document
File.WriteAllText(dlg.FileName, view.QueryEditor.Text);
}
}
);
SaveQueryResultsCommand = new RelayCommand(
p =>
{
SaveFileDialog dlg = new SaveFileDialog
{
FileName = "document", // Default file name
DefaultExt = ".xml", // Default file extension
Filter = "XML Files |*.xml" // Filter files by extension
};
// Show save file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result.Value)
{
// Save document
File.WriteAllText(dlg.FileName, view.QueryEditor.Text);
}
}
);
ExecuteExtractionCommand = new RelayCommand(
p =>
{
this.Status = "";
this.Result = "";
// Get the current language extractor from the model
ILanguageExtractor extractor = this.Languages
.Where(l => l.Metadata.Name == Properties.Settings.Default.CurrentLanguage)
.Select(l => l.Value).FirstOrDefault();
XDocument doc = null;;
IEnumerable <IDiagnosticItem> diagnostics = null;
try
{
(doc, diagnostics) = extractor.Extract(this.view.SourceEditor.Text);
}
catch (Exception e)
{
// Nothing.
}
this.Result = doc != null ? doc.ToString() : "";
// Remove all the entries in the error list and the squigglies
this.DiagnosticItems.Clear();
this.view.SourceEditorTextMarkerService.RemoveAll(m => true);
if (diagnostics != null)
{
foreach (var d in diagnostics)
{
this.DiagnosticItems.Add(d);
int startOffset = this.view.SourceEditor.Document.GetOffset(d.Line, d.Column);
int endOffset = this.view.SourceEditor.Document.GetOffset(d.EndLine, d.EndColumn);
int length = endOffset - startOffset;
ITextMarker marker = this.view.SourceEditorTextMarkerService.Create(startOffset, length);
marker.MarkerTypes = TextMarkerTypes.SquigglyUnderline;
marker.MarkerColor = d.Severity == "Error" ? Colors.Red : Colors.Green;
}
}
}
);
view.InputBindings.Add(new InputBinding(OpenSourceCommand, new KeyGesture(Key.O, ModifierKeys.Control)));
view.InputBindings.Add(new InputBinding(SaveSourceCommand, new KeyGesture(Key.S, ModifierKeys.Control)));
view.InputBindings.Add(new InputBinding(ExecuteExtractionCommand, new KeyGesture(Key.E, ModifierKeys.Control)));
this.executeQueryCommand = new RelayCommand(
p =>
{
Processor processor = new Processor();
StringReader sr = new StringReader(this.view.ResultsEditor.Text);
XmlReader reader = XmlReader.Create(sr, new XmlReaderSettings()
{
ValidationFlags = System.Xml.Schema.XmlSchemaValidationFlags.None
});
XdmNode doc = null;
try
{
doc = processor.NewDocumentBuilder().Build(reader);
}
catch (Exception)
{
}
XQueryCompiler compiler = processor.NewXQueryCompiler();
// Add any namespaces needed...
// compiler.DeclareNamespace("saxon", "http://saxon.sf.net/");
try
{
XQueryExecutable exp = compiler.Compile(this.view.QueryEditor.Text);
XQueryEvaluator eval = exp.Load();
// The context node is always the root document.
if (doc != null)
{
eval.ContextItem = doc;
}
Serializer qout = processor.NewSerializer();
qout.SetOutputProperty(Serializer.METHOD, "xml");
qout.SetOutputProperty(Serializer.OMIT_XML_DECLARATION, "yes");
// Not available: qout.SetOutputProperty(Serializer.SAXON_INDENT_SPACES, "2");
// Do not put attributes on separate lines:
qout.SetOutputProperty(Serializer.INDENT, "no");
// Put the result of the XQuery query into a memory stream:
var output = new MemoryStream();
qout.SetOutputStream(output);
// Run the query:
eval.Run(qout);
// Harvest the result
output.Position = 0;
StreamReader resultReader = new StreamReader(output);
string result = resultReader.ReadToEnd();
// Normalize the strange looking output generated by the serializer
// if it is XML
try
{
var d = XDocument.Parse(result);
this.view.QueryResultsEditor.Text = d.ToString(SaveOptions.None);
}
catch
{
this.view.QueryResultsEditor.Text = result;
}
}
catch (Exception e)
{
this.view.QueryResultsEditor.Text = e.Message;
}
},
p => { return(true); });
}
/**
* Run a test case
*
*
* @param testCase the test case element in the catalog
* @param xpc the XPath compiler to be used for compiling XPath expressions against the catalog
* @
*/
protected override void runTestCase(XdmNode testCase, XPathCompiler xpc)
{
bool run = true;
bool xpDependency = false;
string hostLang;
string langVersion;
Spec specOpt = Spec.NULL;
XPathCompiler xpath = driverProc.NewXPathCompiler();
string testCaseName = testCase.GetAttributeValue(new QName("name"));
string testSetName = testCase.Parent.GetAttributeValue(new QName("name"));
bool needSerializedResult = ((XdmAtomicValue)xpc.EvaluateSingle(
"exists(./result//assert-serialization-error) or exists(./result//serialization-matches)", testCase)).GetBooleanValue();
bool needResultValue = true;
if (needSerializedResult)
{
needResultValue = ((XdmAtomicValue)xpc.EvaluateSingle(
"exists(./result//*[not(self::serialization-matches or self::assert-serialization-error or self::any-of or self::all-of)])", testCase)).GetBooleanValue();
}
XdmNode alternativeResult = null;
XdmNode optimization = null;
hostLang = ((SpecAttr)spec.GetAttr()).sname;
langVersion = ((SpecAttr)spec.GetAttr()).version;
Environment env = getEnvironment(testCase, xpc);
if (env == null)
{
notrun++;
return;
}
env.xpathCompiler.BackwardsCompatible = false;
env.processor.XmlVersion = (decimal)1.0;
//test
bool icuColCheck = net.sf.saxon.Version.platform.hasICUCollator();
bool icuNumCheck = net.sf.saxon.Version.platform.hasICUNumberer();
Console.WriteLine("ICUCol: " + (icuColCheck ? "true" : "false"));
Console.WriteLine("ICUNum: " + (icuNumCheck ? "true" : "false"));
//end of test
foreach (XdmItem dependency in xpc.Evaluate("/*/dependency, ./dependency", testCase))
{
string type = ((XdmNode)dependency).GetAttributeValue(new QName("type"));
if (type == null)
{
// throw new IllegalStateException("dependency/@type is missing"); //TODO
}
string value = ((XdmNode)dependency).GetAttributeValue(new QName("value"));
if (value == null)
{
//throw new IllegalStateException("dependency/@value is missing"); //TODO
}
if (type.Equals("spec"))
{
bool applicable = false;
if (!value.Contains(((SpecAttr)spec.GetAttr()).sname))
{
applicable = false;
}
else if (value.Contains(((SpecAttr)spec.GetAttr()).svname))
{
applicable = true;
}
else if (((SpecAttr)spec.GetAttr()).svname.Equals("XQ30") && value.Contains("XQ10+"))
{
applicable = true;
}
else if (((SpecAttr)spec.GetAttr()).svname.Equals("XP30") && value.Contains("XP20+"))
{
applicable = true;
}
if (!applicable)
{
writeTestcaseElement(testCaseName, "n/a", "not" + ((SpecAttr)spec.GetAttr()).svname, spec);
notrun++;
return;
}
}
if (langVersion.Equals("3.0"))
{
/* 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);
}
if (type.Equals("feature") && value.Equals("xpath-1.0-compatibility"))
{
hostLang = "XP";
langVersion = "3.0";
xpDependency = true;
specOpt = Spec.XP30;
}
if (type.Equals("feature") && value.Equals("namespace-axis"))
{
hostLang = "XP";
langVersion = "3.0";
xpDependency = true;
specOpt = Spec.XP30;
}
if (!dependencyIsSatisfied((XdmNode)dependency, env))
{
println("*** Dependency not satisfied: " + ((XdmNode)dependency).GetAttributeValue(new QName("type")));
writeTestcaseElement(testCaseName, "n/a", "Dependency not satisfied", spec);
run = false;
notrun++;
return;
}
}
XdmNode exceptionElement;
try{
exceptionElement = exceptionsMap[testCaseName];
} catch (Exception) {
exceptionElement = null;
}
if (exceptionElement != null)
{
XdmItem config = xpath.EvaluateSingle("configuration", exceptionElement);
string runAtt = exceptionElement.GetAttributeValue(new QName("run"));
string reasonMsg = xpath.EvaluateSingle("reason", exceptionElement).ToString();
string reportAtt = exceptionElement.GetAttributeValue(new QName("report"));
if (config != null)
{
XdmItem paramValue = xpath.EvaluateSingle("param[@name='not-unfolded' and @value='yes']/@name", config);
if (unfolded && paramValue != null)
{
writeTestcaseElement(testCaseName, "notRun", reasonMsg, spec);
notrun++;
return;
}
}
if ("false".Equals(runAtt))
{
writeTestcaseElement(testCaseName, reportAtt, reasonMsg, spec);
notrun++;
return;
}
alternativeResult = (XdmNode)xpc.EvaluateSingle("result", exceptionElement);
optimization = (XdmNode)xpc.EvaluateSingle("optimization", exceptionElement);
}
if (run && (specOpt == Spec.NULL || specOpt == spec))
{
TestOutcome outcome = new TestOutcome(this);
string exp = null;
try
{
exp = xpc.Evaluate("if (test/@file) then unparsed-text(resolve-uri(test/@file, base-uri(.))) else string(test)", testCase).ToString();
}
catch (Exception err)
{
println("*** Failed to read query: " + err.Message);
outcome.SetException((DynamicError)err);
}
//noinspection ThrowableResultOfMethodCallIgnored
if (outcome.GetException() == null)
{
if (hostLang.Equals("XP") || hostLang.Equals("XT"))
{
XPathCompiler testXpc = env.xpathCompiler;
testXpc.XPathLanguageVersion = langVersion;
testXpc.DeclareNamespace("fn", "http://www.w3.org/2005/xpath-functions");
testXpc.DeclareNamespace("xs", "http://www.w3.org/2001/XMLSchema");
testXpc.DeclareNamespace("map", "http://www.w3.org/2005/xpath-functions/map");
//testXpc.DeclareNamespace("math", NamespaceConstant.MATH);
//testXpc.DeclareNamespace("Dictionary", NamespaceConstant.Dictionary_FUNCTIONS);
try
{
XPathSelector selector = testXpc.Compile(exp).Load();
foreach (QName varName in env.params1.Keys)
{
selector.SetVariable(varName, env.params1[varName]);
}
if (env.contextItem != null)
{
selector.ContextItem = env.contextItem;
}
selector.InputXmlResolver = new TestUriResolver(env);
if (env.unparsedTextResolver != null)
{
//selector.getUnderlyingXPathContext().setUnparsedTextURIResolver(env.unparsedTextResolver); //TODO
}
XdmValue result = selector.Evaluate();
outcome.SetPrincipalResult(result);
}
catch (Exception err)
{
println(err.Message);
outcome.SetException(err);
}
}
else if (hostLang.Equals("XQ"))
{
XQueryCompiler testXqc = env.xqueryCompiler;
testXqc.XQueryLanguageVersion = langVersion;
testXqc.DeclareNamespace("fn", "http://www.w3.org/2005/xpath-functions");
testXqc.DeclareNamespace("xs", "http://www.w3.org/2001/XMLSchema");
//testXqc.DeclareNamespace("math", NamespaceConstant.MATH);
testXqc.DeclareNamespace("map", "http://www.w3.org/2005/xpath-functions/map");
// ErrorCollector errorCollector = new ErrorCollector();
testXqc.ErrorList = new ArrayList();
string decVars = env.paramDecimalDeclarations.ToString();
if (decVars.Length != 0)
{
int x = (exp.IndexOf("(:%DECL%:)"));
if (x < 0)
{
exp = decVars + exp;
}
else
{
exp = exp.Substring(0, x) + decVars + exp.Substring(x + 13);
}
}
string vars = env.paramDeclarations.ToString();
if (vars.Length != 0)
{
int x = (exp.IndexOf("(:%VARDECL%:)"));
if (x < 0)
{
exp = vars + exp;
}
else
{
exp = exp.Substring(0, x) + vars + exp.Substring(x + 13);
}
}
ModuleResolver mr = new ModuleResolver(xpc);
mr.setTestCase(testCase);
// testXqc.QueryResolver = mr;// .setModuleURIResolver(mr); //TODO
testXqc.QueryResolver = mr;
try
{
XQueryExecutable q = testXqc.Compile(exp);
if (optimization != null)
{
// Test whether required optimizations have been performed
XdmDestination expDest = new XdmDestination();
JConfiguration config = driverProc.Implementation;
//ExpressionPresenter presenter = new ExpressionPresenter(config, expDest.getReceiver(config));
//q.getUnderlyingCompiledQuery().explain(presenter);
//presenter.close();
XdmNode explanation = expDest.XdmNode;
XdmItem optResult = xpc.EvaluateSingle(optimization.GetAttributeValue(new QName("assert")), explanation);
if (((XdmAtomicValue)optResult).GetBooleanValue())
{
println("Optimization result OK");
}
else
{
println("Failed optimization test");
Serializer ser = new Serializer();
ser.SetOutputStream((Stream)System.Console.OpenStandardError());
driverProc.WriteXdmValue(explanation, ser);
writeTestcaseElement(testCaseName, "fail", "Failed optimization assertions", spec);
failures++;
return;
}
}
XQueryEvaluator selector = q.Load();
foreach (QName varName in env.params1.Keys)
{
selector.SetExternalVariable(varName, env.params1[varName]);
}
if (env.contextItem != null)
{
selector.ContextItem = env.contextItem;
}
selector.InputXmlResolver = env;
//selector.InputXmlResolver = .SetURIResolver(new TestURIResolver(env)); //TODO
if (env.unparsedTextResolver != null)
{
selector.Implementation.setUnparsedTextURIResolver(env.unparsedTextResolver);// TODO
}
if (needSerializedResult)
{
StringWriter sw = new StringWriter();
Serializer serializer = new Serializer(); //env.processor.NewSerializer(sw); //TODO
serializer.SetOutputWriter(sw);
selector.Run(serializer);
outcome.SetPrincipalSerializedResult(sw.ToString());
}
if (needResultValue)
{
XdmValue result = selector.Evaluate();
outcome.SetPrincipalResult(result);
}
}
catch (Exception err)
{
println("in TestSet " + testSetName + err.StackTrace);
println(err.Message);
outcome.SetException(err);
outcome.SetErrorsReported((IList)testXqc.ErrorList);
}
}
else
{
writeTestcaseElement(testCaseName, "notRun", "No processor found", spec);
notrun++;
return;
}
}
if (env.resetAction != null)
{
env.resetAction.reset(env);
}
XdmNode assertion;
if (alternativeResult != null)
{
assertion = (XdmNode)xpc.EvaluateSingle("*[1]", alternativeResult);
}
else
{
assertion = (XdmNode)xpc.EvaluateSingle("result/*[1]", testCase);
}
if (assertion == null)
{
println("*** No assertions found for test case " + testCaseName);
writeTestcaseElement(testCaseName, "disputed", "No assertions in test case", spec);
feedback.Feedback(successes, failures++, total);
return;
}
XPathCompiler assertXpc = env.processor.NewXPathCompiler();
assertXpc.XPathLanguageVersion = "3.1";
assertXpc.DeclareNamespace("fn", "http://www.w3.org/2005/xpath-functions");
assertXpc.DeclareNamespace("xs", "http://www.w3.org/2001/XMLSchema");
assertXpc.DeclareNamespace("math", "http://www.w3.org/2005/xpath-functions/math");
assertXpc.DeclareNamespace("MAP_FUNCTIONS", "http://www.w3.org/2005/xpath-functions/map");
assertXpc.DeclareVariable(new QName("result"));
bool b = outcome.TestAssertion(assertion, outcome.GetPrincipalResultDoc(), assertXpc, xpc, debug);
if (b)
{
//println("OK");
writeTestcaseElement(testCaseName, "pass", null, spec);
feedback.Feedback(successes++, failures, total);
}
else
{
if (outcome.IsException())
{
XdmItem expectedError = xpc.EvaluateSingle("result//error/@code", testCase);
if (expectedError == null)
{
// if (debug) {
// outcome.getException().printStackTrace(System.out);
// }
writeTestcaseElement(testCaseName, "fail", "Expected success, got ", spec);
println("*** fail, result " + outcome.GetException() +
" Expected success.");
feedback.Feedback(successes, failures++, total);
}
else
{
writeTestcaseElement(testCaseName, "wrongError",
"Expected error:" + expectedError.ToString() + ", got " + outcome.GetErrorCode().LocalName, spec);
println("*** fail, result " + outcome.GetErrorCode().LocalName +
" Expected error:" + expectedError.ToString());
wrongErrorResults++;
feedback.Feedback(successes++, failures, total);
}
}
else
{
writeTestcaseElement(testCaseName, "fail", "Wrong results, got " +
truncate(outcome.Serialize(assertXpc.Processor, outcome.GetPrincipalResultDoc())), spec);
feedback.Feedback(successes, failures++, total);
if (debug)
{
try
{
println("Result:");
driverProc.WriteXdmValue(outcome.GetPrincipalResult(), driverSerializer);
println("<=======");
}
catch (Exception err)
{
}
//println(outcome.getResult());
}
else
{
println("*** fail (use -debug to show actual result)");
//failures++;
}
}
}
}
}
/**
* Method main. First argument is the Saxon samples directory.
*/
public static void Main(String[] argv)
{
String samplesDir;
if (argv.Length > 0)
{
samplesDir = argv[0];
}
else
{
String home = Environment.GetEnvironmentVariable("SAXON_HOME");
if (home == null)
{
Console.WriteLine("No input directory supplied, and SAXON_HOME is not set");
return;
}
else
{
if (home.EndsWith("/") || home.EndsWith("\\"))
{
samplesDir = home + "samples/";
}
else
{
samplesDir = home + "/samples/";
}
}
}
UriBuilder ub = new UriBuilder();
ub.Scheme = "file";
ub.Host = "";
ub.Path = samplesDir;
Uri baseUri = ub.Uri;
Console.WriteLine("Base URI: " + baseUri.ToString());
// Create a schema-aware Processor
Processor saxon = new Processor(true);
// Load a schema
SchemaManager manager = saxon.SchemaManager;
manager.ErrorList = new ArrayList();
Uri schemaUri = new Uri(baseUri, "data/books.xsd");
try {
manager.Compile(schemaUri);
} catch (Exception e) {
Console.WriteLine("Schema compilation failed with " + manager.ErrorList.Count + " errors");
foreach (StaticError error in manager.ErrorList)
{
Console.WriteLine("At line " + error.LineNumber + ": " + error.Message);
}
return;
}
// Use this to validate an instance document
SchemaValidator validator = manager.NewSchemaValidator();
Uri instanceUri = new Uri(baseUri, "data/books.xml");
validator.SetSource(instanceUri);
validator.ErrorList = new ArrayList();
XdmDestination psvi = new XdmDestination();
validator.SetDestination(psvi);
try {
validator.Run();
} catch (Exception e) {
Console.WriteLine("Instance validation failed with " + validator.ErrorList.Count + " errors");
foreach (StaticError error in validator.ErrorList)
{
Console.WriteLine("At line " + error.LineNumber + ": " + error.Message);
}
}
// Run a query on the result to check that it has type annotations
XQueryCompiler xq = saxon.NewXQueryCompiler();
XQueryEvaluator xv = xq.Compile("data((//PRICE)[1]) instance of xs:decimal").Load();
xv.ContextItem = psvi.XdmNode;
Console.WriteLine("Price is decimal? " + xv.EvaluateSingle().ToString());
}
private void compareModule(string paperName, string compareName)
{
Processor pr = new Processor();
XQueryCompiler xqc = pr.NewXQueryCompiler();
string comparePath = "Papers\\" + paperName + "\\" + compareName + "_rule.xml";
string curPath = Directory.GetCurrentDirectory();
string configPath = curPath + "\\Config\\" + compareName + ".config";
string errPath = "Papers\\" + paperName + "\\" + compareName + "_err.xml";
XmlDocument doc = new XmlDocument();
doc.Load(comparePath);
XmlElement root = doc.DocumentElement;
XmlNodeList ruleNodes = root.GetElementsByTagName("rule");
XmlDocument errDoc = new XmlDocument();
XmlNode node = errDoc.CreateXmlDeclaration("1.0", "utf-8", "");//创建类型声明节点
errDoc.AppendChild(node);
XmlNode err = errDoc.CreateElement("error");//创建根节点
foreach (XmlNode xrule in ruleNodes)
{
string rule = xrule.InnerText;
XQueryExecutable xqe = xqc.Compile(rule);
XQueryEvaluator xqev = xqe.Load();
if (!paperName.Contains("#"))
{
XdmValue result = xqev.Evaluate(); //对比结果
foreach (XdmItem r in result)
{
string rstr = r.ToString();
string[] rarr = rstr.Split('/');
string errstr = "for $x in doc(\"" + configPath + "\")/conf/";
if (rarr.Length == 3)
{
errstr += "module[@tag=" + "\"" + rarr[0] + "\"]/";
errstr += "section[@tag=" + "\"" + rarr[1] + "\"]/";
errstr += "item[@tag=" + "\"" + rarr[2] + "\"]/error-msg/text() return $x";
}
else
{
errstr += "module[@tag=" + "\"" + rarr[0] + "\"]/";
errstr += "section[@tag=" + "\"" + rarr[1] + "\"]/";
errstr += "part[@tag=" + "\"" + rarr[2] + "\"]/";
errstr += "item[@tag=" + "\"" + rarr[3] + "\"]/error-msg/text() return $x";
}
XmlElement err_rule = errDoc.CreateElement("err-rule");
//string errstr = rstr;
err_rule.InnerText = errstr;
err.AppendChild(err_rule);
}
errDoc.AppendChild(err);
errDoc.Save(errPath);
}
else
{
errDoc.AppendChild(err);
errDoc.Save(errPath);
}
}
}