| |
| /******************************************************************************* |
| * Copyright (c) 2009, 2017 Standards for Technology in Automotive Retail and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * David Carver - STAR - initial api and implementation bug 262765 |
| *******************************************************************************/ |
| package org.eclipse.wst.xml.xpath2.processor.testsuite.core; |
| |
| import java.net.URL; |
| |
| import org.apache.xerces.xs.XSModel; |
| import org.eclipse.wst.xml.xpath2.processor.DynamicError; |
| import org.eclipse.wst.xml.xpath2.processor.ResultSequence; |
| import org.eclipse.wst.xml.xpath2.processor.StaticError; |
| import org.eclipse.wst.xml.xpath2.processor.XPathParserException; |
| import org.eclipse.wst.xml.xpath2.processor.test.AbstractPsychoPathTest; |
| |
| |
| public class GenCompLTEQTest extends AbstractPsychoPathTest { |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Empty sequence <= Empty sequence. |
| public void test_generalexpression298() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression298.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression298.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Empty sequence <= Atomic Value. |
| public void test_generalexpression299() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression299.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression299.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Empty sequence <= Sequence of single atomic value. |
| public void test_generalexpression300() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression300.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression300.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Empty sequence <= Sequence of single atomic values. |
| public void test_generalexpression301() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression301.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression301.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Empty sequence <= Sequence of single element nodes. |
| public void test_generalexpression305() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression305.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression305.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Empty sequence <= Sequence of multiple element nodes (single source). |
| public void test_generalexpression306() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression306.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression306.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Empty sequence <= Sequence of multiple element nodes (multiple sources). |
| public void test_generalexpression307() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression307.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression307.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Atomic Value <= Empty sequence. |
| public void test_generalexpression308() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression308.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression308.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Atomic Value <= Sequence of single atomic value. |
| public void test_generalexpression309() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression309.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression309.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Atomic Value <= Sequence of single atomic values. |
| public void test_generalexpression310() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression310.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression310.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Atomic Value <= Sequence of single element nodes. |
| public void test_generalexpression314() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression314.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression314.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Atomic Value <= Sequence of multiple element nodes (single source). |
| public void test_generalexpression315() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression315.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression315.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Atomic Value <= Sequence of multiple element nodes (multiple sources). |
| public void test_generalexpression316() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression316.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression316.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single atomic value <= Empty sequence. |
| public void test_generalexpression317() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression317.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression317.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single atomic value <= Atomic Value. |
| public void test_generalexpression318() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression318.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression318.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single atomic value <= Sequence of single atomic value. |
| public void test_generalexpression319() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression319.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression319.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single atomic value <= Sequence of single atomic values. |
| public void test_generalexpression320() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression320.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression320.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single atomic value <= Sequence of single element nodes. |
| public void test_generalexpression324() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression324.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression324.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single atomic value <= Sequence of multiple element nodes (single source). |
| public void test_generalexpression325() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression325.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression325.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single atomic value <= Sequence of multiple element nodes (multiple sources). |
| public void test_generalexpression326() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression326.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression326.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single atomic values <= Empty sequence. |
| public void test_generalexpression327() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression327.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression327.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single atomic values <= Atomic Value. |
| public void test_generalexpression328() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression328.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression328.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single atomic values <= Sequence of single atomic value. |
| public void test_generalexpression329() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression329.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression329.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single atomic values <= Sequence of single atomic values. |
| public void test_generalexpression330() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression330.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression330.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single atomic values <= Sequence of single element nodes. |
| public void test_generalexpression334() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression334.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression334.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single atomic values <= Sequence of multiple element nodes (single source). |
| public void test_generalexpression335() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression335.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression335.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single atomic values <= Sequence of multiple element nodes (multiple sources). |
| public void test_generalexpression336() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression336.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression336.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single element nodes <= Empty sequence. |
| public void test_generalexpression367() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression367.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression367.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single element nodes <= Atomic Value. |
| public void test_generalexpression368() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression368.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression368.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single element nodes <= Sequence of single atomic value. |
| public void test_generalexpression369() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression369.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression369.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single element nodes <= Sequence of single atomic values. |
| public void test_generalexpression370() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression370.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression370.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single element nodes <= Sequence of single element nodes. |
| public void test_generalexpression374() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression374.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression374.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single element nodes <= Sequence of multiple element nodes (single source). |
| public void test_generalexpression375() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression375.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression375.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of single element nodes <= Sequence of multiple element nodes (multiple sources). |
| public void test_generalexpression376() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression376.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression376.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of multiple element nodes (single source) <= Empty sequence. |
| public void test_generalexpression377() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression377.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression377.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of multiple element nodes (single source) <= Atomic Value. |
| public void test_generalexpression378() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression378.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression378.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of multiple element nodes (single source) <= Sequence of single atomic value. |
| public void test_generalexpression379() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression379.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression379.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of multiple element nodes (single source) <= Sequence of single atomic values. |
| public void test_generalexpression380() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression380.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression380.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of multiple element nodes (single source) <= Sequence of single element nodes. |
| public void test_generalexpression384() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression384.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression384.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of multiple element nodes (single source) <= Sequence of multiple element nodes (single source). |
| public void test_generalexpression385() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression385.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression385.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of multiple element nodes (single source) <= Sequence of multiple element nodes (multiple sources). |
| public void test_generalexpression386() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression386.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression386.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of multiple element nodes (multiple sources) <= Empty sequence. |
| public void test_generalexpression387() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression387.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression387.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of multiple element nodes (multiple sources) <= Atomic Value. |
| public void test_generalexpression388() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression388.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression388.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of multiple element nodes (multiple sources) <= Sequence of single atomic value. |
| public void test_generalexpression389() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression389.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression389.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of multiple element nodes (multiple sources) <= Sequence of single atomic values. |
| public void test_generalexpression390() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression390.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression390.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of multiple element nodes (multiple sources) <= Sequence of single element nodes. |
| public void test_generalexpression394() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression394.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression394.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of multiple element nodes (multiple sources) <= Sequence of multiple element nodes (single source). |
| public void test_generalexpression395() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression395.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression395.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of a General expression with the operands/operator set with the following format: Sequence of multiple element nodes (multiple sources) <= Sequence of multiple element nodes (multiple sources). |
| public void test_generalexpression396() throws Exception { |
| String inputFile = "/TestSources/works.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression396.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/generalexpression396.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| //Evaluation of "le" operator on an xs:anyURI datatype. |
| public void test_lessthaneqonanyuri_1() throws Exception { |
| String inputFile = "/TestSources/emptydoc.xml"; |
| String xqFile = "/Queries/XQuery/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/lessthaneqonanyuri-1.xq"; |
| String resultFile = "/ExpectedTestResults/Expressions/Operators/CompExpr/GenComprsn/GenCompLTEQ/true.txt"; |
| String expectedResult = getExpectedResult(resultFile); |
| URL fileURL = bundle.getEntry(inputFile); |
| loadDOMDocument(fileURL); |
| |
| // Get XML Schema Information for the Document |
| XSModel schema = getGrammar(); |
| |
| setupDynamicContext(schema); |
| |
| String xpath = extractXPathExpression(xqFile, inputFile); |
| String actual = null; |
| try { |
| compileXPath(xpath); |
| ResultSequence rs = evaluate(domDoc); |
| |
| |
| actual = buildResultString(rs); |
| |
| } catch (XPathParserException ex) { |
| actual = ex.code(); |
| } catch (StaticError ex) { |
| actual = ex.code(); |
| } catch (DynamicError ex) { |
| actual = ex.code(); |
| } |
| |
| assertEquals("XPath Result Error " + xqFile + ":", expectedResult, actual); |
| |
| |
| } |
| |
| } |
| |
