Exemplo n.º 1
0
        internal static XQueryInvoker WithQuery(string query, IXQueryProcessor processor, Assembly callingAssembly, out int hashCode)
        {
            if (query == null)
            {
                throw new ArgumentNullException("query");
            }

            if (processor == null)
            {
                processor = Processors.XQuery.DefaultProcessor;
            }

            hashCode = query.GetHashCode();

            ConcurrentDictionary <int, XQueryExecutable> cache =
                inlineCache.GetOrAdd(processor, p => new ConcurrentDictionary <int, XQueryExecutable>());

            XQueryExecutable exec = cache.GetOrAdd(hashCode, i => {
                var resolver = new XmlDynamicResolver(callingAssembly);

                return(processor.Compile(new StringReader(query), new XQueryCompileOptions {
                    XmlResolver = resolver
                }));
            });

            return(new XQueryInvoker(exec, callingAssembly));
        }
Exemplo n.º 2
0
        static XQueryInvoker With(Uri queryUri, IXQueryProcessor processor, Assembly callingAssembly)
        {
            if (queryUri == null)
            {
                throw new ArgumentNullException("queryUri");
            }

            var resolver = new XmlDynamicResolver(callingAssembly);

            if (!queryUri.IsAbsoluteUri)
            {
                queryUri = resolver.ResolveUri(null, queryUri.OriginalString);
            }

            if (processor == null)
            {
                processor = Processors.XQuery.DefaultProcessor;
            }

            ConcurrentDictionary <Uri, XQueryExecutable> cache =
                uriCache.GetOrAdd(processor, p => new ConcurrentDictionary <Uri, XQueryExecutable>());

            XQueryExecutable executable = cache.GetOrAdd(queryUri, u => {
                using (var stylesheetSource = (Stream)resolver.GetEntity(queryUri, null, typeof(Stream))) {
                    return(processor.Compile(stylesheetSource, new XQueryCompileOptions {
                        BaseUri = queryUri,
                        XmlResolver = resolver
                    }));
                }
            });

            return(new XQueryInvoker(executable, callingAssembly));
        }
Exemplo n.º 3
0
    /**
     * 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);
    }
Exemplo n.º 4
0
        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++;
                }
            }
        }
Exemplo n.º 5
0
    /**
     * 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());
                }
        }
Exemplo n.º 7
0
    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);
            }
        }
    }
Exemplo n.º 8
0
    /**
     * 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);
    }
Exemplo n.º 9
0
    /**
     * 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);
    }
Exemplo n.º 10
0
        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);
        }
Exemplo n.º 11
0
        /// <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);
        }
Exemplo n.º 12
0
    /**
     * 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());
        }
    }
Exemplo n.º 13
0
        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();
        }
Exemplo n.º 14
0
    /**
     * 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);
    }
Exemplo n.º 15
0
        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);
        }
Exemplo n.º 16
0
    /**
     * 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);
    }
Exemplo n.º 17
0
        /**
         * Saxon: Safe when Whitelisting on XQuery Expression Example
         * Proves that Saxon is safe from injection when whitelisting the XQuery expression
         */
        protected void Page_Load(object sender, EventArgs e)
        {
            bool expectedSafe = false;

            try
            {
                // parse the XML
                Processor       processor = new Processor(false);
                DocumentBuilder doc       = processor.newDocumentBuilder();
                XdmNode         node      = doc.build(new StreamSource(appPath + "/resources/students.xml"));

                // query the XML
                string query;
                if (Request.QueryString["payload"].Contains("\"") || Request.QueryString["payload"].Contains(";"))
                {
                    PrintResults(expectedSafe, new List <string>());
                    throw new InvalidParameterException("First Name parameter must not contain quotes or semicolons");
                }
                else
                {
                    query = "for $s in //Students/Student " +
                            "where $s/FirstName = \"" + Request.QueryString["payload"] + "\" " +
                            "return $s";    // safe in here!
                }
                XQueryCompiler   xqComp = processor.newXQueryCompiler();
                XQueryExecutable xqExec = xqComp.compile(query);
                XQueryEvaluator  xqEval = xqExec.load();
                xqEval.setContextItem(node);
                xqEval.evaluate();

                // interpret the result of the query
                List <string> resultList = new List <string>();
                foreach (XdmValue value in xqEval)
                {
                    resultList.Add(value.ToString());
                }

                // print the results on the query
                PrintResults(expectedSafe, resultList);
            }
            catch (Exception ex)
            {
                Response.Write(ex.ToString());
            }
        }
Exemplo n.º 18
0
    ///<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);
    }
Exemplo n.º 19
0
        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);
        }
Exemplo n.º 20
0
    /**
     * 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);
    }
Exemplo n.º 21
0
            /// <summary>
            /// This application uses the xslt file created from the
            /// original Word 2007 template document to transform xml data
            /// into a valid Open XML 2.0 Wordprocessing format.
            /// The application then updates the output document with the
            /// new content using the Open XML SDK version 2.0.
            /// </summary>
            static void Main(string[] args)
            {
                //Declare variables for file locations.
                string xmlDocxFile = @".\mydoc.xml";
                string xmlResult   = @".\mydoc1.xml";

                FileStream fs = new FileStream(xmlDocxFile, FileMode.OpenOrCreate);

                XQueryCompiler compiler = new Processor().NewXQueryCompiler();

                //bug on saxon's end... sounds stupid but force add base URI for the current location
                string directory = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName + '\\';
                string uri       = new Uri(directory).AbsoluteUri;

                compiler.BaseUri = uri;

                XQueryExecutable executable = compiler.Compile(fs);
                XQueryEvaluator  evaluator  = executable.Load();
                XdmValue         result     = evaluator.Evaluate();

                FileStream        fStream  = System.IO.File.Open(xmlResult, FileMode.OpenOrCreate, FileAccess.ReadWrite);
                XmlWriterSettings settings = new XmlWriterSettings
                {
                    ConformanceLevel = ConformanceLevel.Fragment,
                    Indent           = true
                };
                XmlWriter writer = XmlWriter.Create(fStream, settings);

                try
                {
                    writer.WriteRaw(result.ToString());
                } catch (Exception e)
                {
                    writer.Close();
                    throw e;
                } finally
                {
                    writer.Close();
                }
            }
Exemplo n.º 22
0
    ///<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);
    }
Exemplo n.º 23
0
        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);
        }
Exemplo n.º 24
0
    /**
     * 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);
    }
Exemplo n.º 25
0
        /**
         * Saxon: Safe when Using Bind Variables on XQuery Expression Example
         * Proves that Saxon is safe from injection when using bind variables on the XQuery expression
         */
        protected void Page_Load(object sender, EventArgs e)
        {
            bool expectedSafe = true;

            try
            {
                // parse the XML
                Processor       processor = new Processor(false);
                DocumentBuilder doc       = processor.newDocumentBuilder();
                XdmNode         node      = doc.build(new StreamSource(appPath + "/resources/students.xml"));

                // query the XML
                string query = "declare variable $name as xs:string external; " +
                               "for $s in //Students/Student " +
                               "where $s/FirstName = $name " +
                               "return $s";   // safe!
                XQueryCompiler   xqComp = processor.newXQueryCompiler();
                XQueryExecutable xqExec = xqComp.compile(query);
                XQueryEvaluator  xqEval = xqExec.load();
                xqEval.setContextItem(node);
                xqEval.setExternalVariable(new QName("name"), new XdmAtomicValue(Request.QueryString["payload"]));
                xqEval.evaluate();

                // interpret the result of the query
                List <string> resultList = new List <string>();
                foreach (XdmValue value in xqEval)
                {
                    resultList.Add(value.ToString());
                }

                // print the results on the query
                PrintResults(expectedSafe, resultList);
            }
            catch (Exception ex)
            {
                Response.Write(ex.ToString());
            }
        }
Exemplo n.º 26
0
    /**
     * 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);
    }
Exemplo n.º 27
0
        public EFileCERuleExecutionElement(string codeEffectsRuleXML, Func <FieldService> fieldServiceFactory, Func <RuleService> ruleServiceFactory, Guid ruleId, int precision, Func <IValuesDictionary> valuesDictionaryProvider, ICache <int, Field> fieldsCache, string xQuery, string currentNamespaceURI = "", Processor processor = null)
        {
            if (!string.IsNullOrEmpty(codeEffectsRuleXML))
            {
                MidpointRounding midpointRounding = MidpointRounding.ToEven;
                if (precision > -1)
                {
                    midpointRounding = MidpointRounding.AwayFromZero;
                }

                Evaluator = new Evaluator <EFileDocument>(codeEffectsRuleXML, new EvaluationParameters {
                    MidpointRounding = midpointRounding, Precision = precision
                });
                _evaluator           = new EFileCERuleEvaluator(codeEffectsRuleXML, fieldServiceFactory, ruleServiceFactory, valuesDictionaryProvider, ruleId, fieldsCache: fieldsCache);
                _evaluator.Evaluator = Evaluator;
                XQuery = xQuery;
                CompiledXQueryExecutable = CreateXQueryExecutable(currentNamespaceURI, processor);
            }
            else
            {
                throw new InvalidOperationException("Error in EFileCERuleExecutionElement constructor");
            }
        }
Exemplo n.º 28
0
        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);
        }
        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); });
        }
Exemplo n.º 30
0
        /**
         * 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++;
                        }
                    }
                }
            }
        }