tests/org.eclipse.wst.xml.xpath2.wtptypes.tests/src/org/eclipse/wst/xml/xpath2/wtptypes/test/TestWTPDOMXPath2.java

/*******************************************************************************
 * Copyright (c) 2009, 2010 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 v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     David Carver (STAR) - initial API and implementation 
 *     Mukul Gandhi - bug 280798 - PsychoPath support for JDK 1.4
 *******************************************************************************/

package org.eclipse.wst.xml.xpath2.wtptypes.test;

import java.net.URL;
import java.util.Iterator;

import org.apache.xerces.xs.XSModel;
import org.eclipse.core.runtime.Platform;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMDocument;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
import org.eclipse.wst.xml.xpath2.processor.DefaultEvaluator;
import org.eclipse.wst.xml.xpath2.processor.DynamicContext;
import org.eclipse.wst.xml.xpath2.processor.DynamicError;
import org.eclipse.wst.xml.xpath2.processor.Evaluator;
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.ast.XPath;
import org.eclipse.wst.xml.xpath2.processor.internal.types.AnyType;
import org.eclipse.wst.xml.xpath2.processor.internal.types.NodeType;
import org.eclipse.wst.xml.xpath2.wtptypes.XsdDOMTypeProvider;

public class TestWTPDOMXPath2 extends AbstractPsychoPathWTPTest {

	public void testSimpleWTPDOM() throws Exception {
		// Test for the fix, for xpathDefaultNamespace
		bundle = Platform
				.getBundle("org.eclipse.wst.xml.xpath2.wtptypes.tests");

		URL fileURL = bundle.getEntry("/bugTestFiles/bug273719.xml");
		super.domDoc = load(fileURL);

		// set up XPath default namespace in Dynamic Context
		DynamicContext dc = setupDynamicContext(null);

		String xpath = "string-length(x) > 2";
		XPath path = compileXPath(dc, xpath);

		Evaluator eval = new DefaultEvaluator(dc, domDoc);
		ResultSequence rs = eval.evaluate(path);

		AnyType result = rs.first();

		String actual = result.string_value();

		assertEquals("true", actual);
	}

	{
//		DefaultTypeProviderRegistry.getInstance().register(DOMModelImpl.class, new XsdDOMTypeProvider());
	}

	public void testWTPDOMWithTypes() throws Exception {
		// Test for the fix, for xpathDefaultNamespace
		bundle = Platform
				.getBundle("org.eclipse.wst.xml.xpath2.wtptypes.tests");

		URL fileURL = bundle.getEntry("/bugTestFiles/attrNodeTest.xml");
		super.domDoc = load(fileURL);

		// set up XPath default namespace in Dynamic Context
		DynamicContext dc = setupDynamicContext2(new XsdDOMTypeProvider.XsdTypeModel((IDOMDocument)domDoc));
		
		assertXPathTrue("/Example/x[1] instance of element(*, x_Type)", dc, domDoc);
		assertXPathTrue("not (/Example/x[1] instance of element(*, y_Type))", dc, domDoc);
		assertXPathTrue("/Example/x instance of x_Type+", dc, domDoc);
		assertXPathTrue("/Example/x instance of element(x, x_Type)+", dc, domDoc);
		assertXPathTrue("not (/Example/x instance of element(z, x_Type)+)", dc, domDoc);
		assertXPathTrue("/Example/x[2]/@mesg instance of mesg_Type", dc, domDoc);
		assertXPathTrue("/Example/x[2]/@mesg instance of attribute(mesg, mesg_Type)", dc, domDoc);
		assertXPathTrue("not (/Example/x[2]/@mesg instance of attribute(mesg, xs:integer))", dc, domDoc);
		assertXPathTrue("not (/Example/x[2]/@mesg instance of attribute(cesc, mesg_Type))", dc, domDoc);
		assertXPathTrue("/Example/y/@intAttr instance of attribute(intAttr, xs:integer)", dc, domDoc);
	}

	public void test_ForExpr005() throws Exception {
		String inputFile = "/TestSources/fsx.xml";
		String xqFile = "/Queries/XQuery/Expressions/FLWORExpr/ForExpr/ForExpr005.xq";
		String resultFile = "/ExpectedTestResults/Expressions/FLWORExpr/ForExpr/ForExpr005.xml";
		String expectedResult = getExpectedResult(resultFile);

		URL fileURL = bundle.getEntry(inputFile);
		super.domDoc = load(fileURL);
		DynamicContext dc = setupDynamicContext(null);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Type declaration containing multiple 'as' keywords.
	public void test_ForExprType013() throws Exception {
		String inputFile = "/TestSources/orderData.xml";
		String xqFile = "/Queries/XQuery/Expressions/FLWORExpr/ForExprType/ForExprType013.xq";
		String expectedResult = "XPST0003";
		URL fileURL = bundle.getEntry(inputFile);
		super.domDoc = load(fileURL);

		DynamicContext dc = setupDynamicContext(null);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// No children for child::*.
	public void test_Axes001_1() throws Exception {
		String inputFile = "/TestSources/TreeTrunc.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes001.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes001-1.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		super.domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// Simple filter using data query from xml source and the "gt" operator.
	public void test_filterexpressionhc1() throws Exception {
		String inputFile = "/TestSources/works.xml";
		String xqFile = "/Queries/XQuery/Expressions/SeqExpr/FilterExpr/filterexpressionhc1.xq";
		String resultFile = "/ExpectedTestResults/Expressions/SeqExpr/FilterExpr/filterexpressionhc1.txt";
		String expectedResult = "<result>" + getExpectedResult(resultFile)
				+ "</result>";
		URL fileURL = bundle.getEntry(inputFile);
		super.domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = "<result>" + buildXMLResultString(rs) + "</result>";

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// No children, child::name gets none.
	public void test_Axes002_1() throws Exception {
		String inputFile = "/TestSources/TreeTrunc.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes002.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes002-1.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// Evaluates abbreviated syntax, "hours". Selects the "hours" element
	// children of the context node.
	public void test_abbreviatedSyntax_1() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/AbbrAxes/abbreviatedSyntax-1.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/AbbrAxes/abbreviatedSyntax-1.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(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);

	}

	// Evaluates abbreviated syntax, "text()". Selects all text node children of
	// the context node.
	public void test_abbreviatedSyntax_2() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/AbbrAxes/abbreviatedSyntax-2.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/AbbrAxes/abbreviatedSyntax-2.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// Evaluates abbreviated syntax, "@name". Selects the name attribute of the
	// context node.
	public void test_abbreviatedSyntax_3() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/AbbrAxes/abbreviatedSyntax-3.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/AbbrAxes/abbreviatedSyntax-3.txt";
		String expectedResult = formatResultString(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Evaluates abbreviated syntax, "employee[1]". Selects the first employee
	// child of the context node.
	public void test_abbreviatedSyntax_5() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/AbbrAxes/abbreviatedSyntax-5.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/AbbrAxes/abbreviatedSyntax-5.txt";
		String expectedResult = formatResultString(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Evaluation of a Node expression With the operands/operator set with the
	// following format: empty Sequence is Single Node Element.
	public void test_nodeexpression3() throws Exception {
		String inputFile = "/TestSources/works.xml";
		String xqFile = "/Queries/XQuery/Expressions/Operators/NodeOp/NodeSame/nodeexpression3.xq";
		String resultFile = "/ExpectedTestResults/Expressions/Operators/NodeOp/NodeSame/nodeexpression3.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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 Node expression With the operands/operator set with the
	// following format: empty Sequence is Sequence of single Element Node.
	public void test_nodeexpression4() throws Exception {
		String inputFile = "/TestSources/staff.xml";
		String xqFile = "/Queries/XQuery/Expressions/Operators/NodeOp/NodeSame/nodeexpression4.xq";
		String resultFile = "/ExpectedTestResults/Expressions/Operators/NodeOp/NodeSame/nodeexpression4.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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 Node expression With the operands/operator set with the
	// following format: Single Node Element is empty Sequence.
	public void test_nodeexpression9() throws Exception {
		String inputFile = "/TestSources/works.xml";
		String xqFile = "/Queries/XQuery/Expressions/Operators/NodeOp/NodeSame/nodeexpression9.xq";
		String resultFile = "/ExpectedTestResults/Expressions/Operators/NodeOp/NodeSame/nodeexpression9.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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 Node expression With the operands/operator set with the
	// following format: Single Node Element is Single Node Element.
	public void test_nodeexpression11() throws Exception {
		String inputFile = "/TestSources/works.xml";
		String xqFile = "/Queries/XQuery/Expressions/Operators/NodeOp/NodeSame/nodeexpression11.xq";
		String resultFile = "/ExpectedTestResults/Expressions/Operators/NodeOp/NodeSame/nodeexpression11.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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 simple predicate with a "true" value (uses "fn:true").
	public void test_predicates_1() throws Exception {
		String inputFile = "/TestSources/atomicns.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Predicates/predicates-1.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Predicates/predicates-1.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(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 simple predicate with a "false" value (uses "fn:false").
	// Use "fn:count" to avoid empty file.
	public void test_predicates_2() throws Exception {
		String inputFile = "/TestSources/atomicns.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Predicates/predicates-2.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Predicates/predicates-2.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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 simple predicate with a "true" value (uses "fn:true" and
	// fn:not()).
	public void test_predicates_3() throws Exception {
		String inputFile = "/TestSources/atomicns.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Predicates/predicates-3.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Predicates/predicates-3.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(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 simple predicate set to a boolean expression ("and"
	// operator), returns true.
	public void test_predicates_4() throws Exception {
		String inputFile = "/TestSources/atomicns.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Predicates/predicates-4.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Predicates/predicates-4.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(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 simple predicate set to a boolean expression ("or"
	// operator), return true.
	public void test_predicates_5() throws Exception {
		String inputFile = "/TestSources/atomicns.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Predicates/predicates-5.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Predicates/predicates-5.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(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 simple predicate set to a boolean expression ("and"
	// operator), returns false. Use "fn:count" to avoid empty file.
	public void test_predicates_6() throws Exception {
		String inputFile = "/TestSources/atomicns.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Predicates/predicates-6.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Predicates/predicates-6.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// No children of any kind, elem//child::* gets none.
	public void test_Axes074_1() throws Exception {
		String inputFile = "/TestSources/TreeTrunc.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes074.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes074-1.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//child::* gets nothing when no element children.
	public void test_Axes074_2() throws Exception {
		String inputFile = "/TestSources/Tree1Text.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes074.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes074-2.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//child::* gets 1 child element.
	public void test_Axes074_3() throws Exception {
		String inputFile = "/TestSources/Tree1Child.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes074.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes074-3.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//child::* gets several nodes.
	public void test_Axes074_4() throws Exception {
		String inputFile = "/TestSources/TreeRepeat.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes074.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes074-4.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//child::name gets nothing when no sub-tree.
	public void test_Axes075_1() throws Exception {
		String inputFile = "/TestSources/TreeTrunc.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes075.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes075-1.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//child::name gets none when no elements have that name.
	public void test_Axes075_2() throws Exception {
		String inputFile = "/TestSources/Tree1Child.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes075.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes075-2.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//child::name gets the 1 descendant of that name.
	public void test_Axes075_3() throws Exception {
		String inputFile = "/TestSources/TreeCompass.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes075.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes075-3.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//child::name gets several elements.
	public void test_Axes075_4() throws Exception {
		String inputFile = "/TestSources/TreeStack.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes075.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes075-4.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// No children, elem//child::node() gets none.
	public void test_Axes076_1() throws Exception {
		String inputFile = "/TestSources/TreeTrunc.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes076.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes076-1.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//child::node() gets 1 child element.
	public void test_Axes076_2() throws Exception {
		String inputFile = "/TestSources/Tree1Child.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes076.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes076-2.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//child::node() gets 1 child text node.
	public void test_Axes076_3() throws Exception {
		String inputFile = "/TestSources/Tree1Text.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes076.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes076-3.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// Several children for elem//child::node().
	public void test_Axes076_4() throws Exception {
		String inputFile = "/TestSources/TreeRepeat.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes076.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes076-4.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// No children for elem//*.
	public void test_Axes077_1() throws Exception {
		String inputFile = "/TestSources/TreeTrunc.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes077.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes077-1.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// 1 child for elem//*.
	public void test_Axes077_2() throws Exception {
		String inputFile = "/TestSources/Tree1Child.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes077.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes077-2.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// Many children for elem//*.
	public void test_Axes077_3() throws Exception {
		String inputFile = "/TestSources/TreeRepeat.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes077.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes077-3.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//name gets none when there are no children.
	public void test_Axes078_1() throws Exception {
		String inputFile = "/TestSources/TreeTrunc.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes078.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes078-1.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//name gets none when no elements have that name.
	public void test_Axes078_2() throws Exception {
		String inputFile = "/TestSources/Tree1Child.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes078.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes078-2.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//name gets the 1 descendant of that name.
	public void test_Axes078_3() throws Exception {
		String inputFile = "/TestSources/TreeCompass.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes078.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes078-3.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//name gets several elements.
	public void test_Axes078_4() throws Exception {
		String inputFile = "/TestSources/TreeStack.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes078.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes078-4.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// No children, elem//node() gets none.
	public void test_Axes079_1() throws Exception {
		String inputFile = "/TestSources/TreeTrunc.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes079.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes079-1.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//node() gets 1 child element.
	public void test_Axes079_2() throws Exception {
		String inputFile = "/TestSources/Tree1Child.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes079.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes079-2.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// elem//node() gets 1 child text node.
	public void test_Axes079_3() throws Exception {
		String inputFile = "/TestSources/Tree1Text.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/Steps/Axes/Axes079.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/Steps/Axes/Axes079-3.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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 Node expression With the operands/operator set with the
	// following format: empty Sequence "<<" empty Sequence.
	public void test_nodeexpression17() throws Exception {
		String inputFile = "/TestSources/emptydoc.xml";
		String xqFile = "/Queries/XQuery/Expressions/Operators/NodeOp/NodeBefore/nodeexpression17.xq";
		String resultFile = "/ExpectedTestResults/Expressions/Operators/NodeOp/NodeBefore/nodeexpression17.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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 Node expression With the operands/operator set with the
	// following format: empty Sequence "<<" Single Node Element.
	public void test_nodeexpression19() throws Exception {
		String inputFile = "/TestSources/works.xml";
		String xqFile = "/Queries/XQuery/Expressions/Operators/NodeOp/NodeBefore/nodeexpression19.xq";
		String resultFile = "/ExpectedTestResults/Expressions/Operators/NodeOp/NodeBefore/nodeexpression19.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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 Node expression With the operands/operator set with the
	// following format: empty Sequence "<<" Sequence of single Element Node.
	public void test_nodeexpression20() throws Exception {
		String inputFile = "/TestSources/staff.xml";
		String xqFile = "/Queries/XQuery/Expressions/Operators/NodeOp/NodeBefore/nodeexpression20.xq";
		String resultFile = "/ExpectedTestResults/Expressions/Operators/NodeOp/NodeBefore/nodeexpression20.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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 Node expression With the operands/operator set with the
	// following format: Single Node Element "<<" empty Sequence.
	public void test_nodeexpression25() throws Exception {
		String inputFile = "/TestSources/works.xml";
		String xqFile = "/Queries/XQuery/Expressions/Operators/NodeOp/NodeBefore/nodeexpression25.xq";
		String resultFile = "/ExpectedTestResults/Expressions/Operators/NodeOp/NodeBefore/nodeexpression25.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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 Node expression With the operands/operator set with the
	// following format: Single Node Element "<<" Single Node Element.
	public void test_nodeexpression27() throws Exception {
		String inputFile = "/TestSources/works.xml";
		String xqFile = "/Queries/XQuery/Expressions/Operators/NodeOp/NodeBefore/nodeexpression27.xq";
		String resultFile = "/ExpectedTestResults/Expressions/Operators/NodeOp/NodeBefore/nodeexpression27.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// Evaluates unabbreviated syntax - child::empnum - select empnum children
	// of the context node.
	public void test_unabbreviatedSyntax_1() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-1.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-1.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(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);

	}

	// Evaluates unabbreviated syntax - child::* - select all element children
	// of the context node.
	public void test_unabbreviatedSyntax_2() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-2.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-2.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(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);

	}

	// Evaluates unabbreviated syntax - child::text() - select all text node
	// children of the context node.
	public void test_unabbreviatedSyntax_3() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-3.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-3.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}
	
	// Evaluates unabbreviated syntax - parent::node() - Selects the parent of
	// the context node.
	public void test_unabbreviatedSyntax_8() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-8.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-8.txt";
		String expectedResult = formatResultString(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Evaluates unabbreviated syntax - descendant::empnum - Selects the
	// "empnum" descendants of the context node.
	public void test_unabbreviatedSyntax_9() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-9.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-9.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(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);

	}

	// Evaluates unabbreviated syntax - descendant-or-self::employee - Selects
	// all the "employee" descendant of the context node (selects employee, if
	// the context node is "employee").
	public void test_unabbreviatedSyntax_12() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-12.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-12.txt";
		String expectedResult = formatResultString(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Evaluates unabbreviated syntax - self::employee - Selects the context
	// node, if it is an "employee" element, otherwise returns empty sequence.
	// This test retuns an "employee" element.
	public void test_unabbreviatedSyntax_13() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-13.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-13.txt";
		String expectedResult = formatResultString(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Evaluates unabbreviated syntax - self::hours - Selects the context node,
	// if it is an "hours" element, otherwise returns empty sequence. This test
	// retuns the empty sequence.
	public void test_unabbreviatedSyntax_14() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-14.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-14.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			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);

	}

	// Evaluates unabbreviated syntax child::employee/descendant:empnum- Selects
	// the empnum element descendants of the employee element children of the
	// context node.
	public void test_unabbreviatedSyntax_15() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-15.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-15.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(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);

	}

	// Evaluates unabbreviated syntax child::*/child:pnum)- Selects the pnum
	// grandchildren of the context node.
	public void test_unabbreviatedSyntax_16() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-16.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-16.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(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);

	}

	// Evaluates unabbreviated syntax. Evaluate /descendant::pnum - Selects all
	// the pnum elements in the same document as the context node.
	public void test_unabbreviatedSyntax_18() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-18.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-18.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(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);

	}

	// Evaluates unabbreviated syntax. Evaluate
	// /descendant::employee/child::pnum selects all the pnum elements that have
	// an "employee" parent and that are in the same document as the context
	// node.
	public void test_unabbreviatedSyntax_19() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-19.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-19.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(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);

	}

	// Evaluates unabbreviated syntax. Evaluate
	// "child::employee[fn:position() = 1]". Selects the first employee child of
	// the context node.
	public void test_unabbreviatedSyntax_20() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-20.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-20.txt";
		String expectedResult = formatResultString(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Evaluates unabbreviated syntax. Evaluate
	// "child::employee[fn:position() = fn:last()]". Selects the last "employee"
	// child of the context node.
	public void test_unabbreviatedSyntax_21() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-21.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-21.txt";
		String expectedResult = formatResultString(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Evaluates unabbreviated syntax. Evaluate
	// "child::employee[fn:position() = fn:last()-1]. Selects the previous to the last one "employee"
	// child of the context node.
	public void test_unabbreviatedSyntax_22() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-22.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-22.txt";
		String expectedResult = formatResultString(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Evaluates unabbreviated syntax. Evaluate
	// "child::hours[fn:position() > 1]". Selects all the para children of the
	// context node other than the first "hours" child of the context node.
	public void test_unabbreviatedSyntax_23() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-23.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-23.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(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);

	}

	// Evaluates unabbreviated syntax. Evaluate
	// "/descendant::employee[fn:position() = 12]". Selects the twelfth employee
	// element in the document containing the context node.
	public void test_unabbreviatedSyntax_26() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-26.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-26.txt";
		String expectedResult = formatResultString(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Evaluates unabbreviated syntax. Evaluate
	// "/child::works/child::employee[fn:position() = 5]/child::hours[fn:position() = 2]".
	// Selects the second "hours" of the fifth "employee" of the "works" whose
	// parent is the document node that contains the context node.
	public void test_unabbreviatedSyntax_27() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-27.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-27.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Evaluates unabbreviated syntax. Evaluate
	// "child::employee[attribute::name eq "Jane Doe 11"]". Selects all
	// "employee" children of the context node that have a "name" attribute with
	// value "Jane Doe 11".
	public void test_unabbreviatedSyntax_28() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-28.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-28.txt";
		String expectedResult = formatResultString(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Evaluates unabbreviated syntax. Evaluate
	// "child::employee[attribute::gender eq 'female'][fn:position() = 5]".
	// Selects the fifth employee child of the context node that has a gender
	// attribute with value "female".
	public void test_unabbreviatedSyntax_29() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-29.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-29.txt";
		String expectedResult = formatResultString(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Evaluates unabbreviated syntax. Evaluate
	// "child::employee[child::empnum = 'E3']". Selects the employee children of
	// the context node that have one or more empnum children whose typed value
	// is equal to the string "E3".
	public void test_unabbreviatedSyntax_30() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-30.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-30.txt";
		String expectedResult = "<result>" + getExpectedResult(resultFile)
				+ "</result>";
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = "<result>" + buildXMLResultString(rs) + "</result>";

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Evaluates unabbreviated syntax. Evaluate
	// "child::employee[child::status]". Selects the employee children of the
	// context node that have one or more status children.
	public void test_unabbreviatedSyntax_31() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-31.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-31.txt";
		String expectedResult = formatResultString(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	// Evaluates unabbreviated syntax. Evaluate
	// "child::*[self::pnum or self::empnum]". Selects the pnum and empnum
	// children of the context node.
	public void test_unabbreviatedSyntax_32() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-32.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-32.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(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);

	}

	// Evaluates unabbreviated syntax. Evaluate
	// "child::*[self::empnum or self::pnum][fn:position() = fn:last()]".
	// Selects the last empnum or pnum child of the context node.
	public void test_unabbreviatedSyntax_33() throws Exception {
		String inputFile = "/TestSources/works-mod.xml";
		String xqFile = "/Queries/XQuery/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-33.xq";
		String resultFile = "/ExpectedTestResults/Expressions/PathExpr/UnabbrAxes/unabbreviatedSyntax-33.txt";
		String expectedResult = getExpectedResult(resultFile);
		URL fileURL = bundle.getEntry(inputFile);
		domDoc = load(fileURL);

		// Get XML Schema Information for the Document
		XSModel schema = null;

		DynamicContext dc = setupDynamicContext(schema);

		String xpath = extractXPathExpression(xqFile, inputFile);
		String actual = null;
		try {
			XPath path = compileXPath(dc, xpath);

			Evaluator eval = new DefaultEvaluator(dc, domDoc);
			ResultSequence rs = eval.evaluate(path);

			actual = buildXMLResultString(rs);

		} catch (XPathParserException ex) {
			actual = ex.code();
		} catch (StaticError ex) {
			actual = ex.code();
		} catch (DynamicError ex) {
			actual = ex.code();
		}

		assertXMLEqual("XPath Result Error " + xqFile + ":", expectedResult,
				actual);

	}

	  //FLWOR expression returns a constructed sequence.
	   public void test_ReturnExpr011() throws Exception {
	      String inputFile = "/TestSources/fsx.xml";
	      String xqFile = "/Queries/XQuery/Expressions/FLWORExpr/ReturnExpr/ReturnExpr011.xq";
	      String resultFile = "/ExpectedTestResults/Expressions/FLWORExpr/ReturnExpr/ReturnExpr011.xml";
	      String expectedResult = getExpectedResult(resultFile);
	      URL fileURL = bundle.getEntry(inputFile);
	      domDoc = load(fileURL);
	      
	      // Get XML Schema Information for the Document
	      XSModel schema = null;

	      DynamicContext dc = setupDynamicContext(schema);

	      String xpath = extractXPathExpression(xqFile, inputFile);
	      String actual = null;
	      try {
		   	  XPath path = compileXPath(dc, xpath);
		
		      Evaluator eval = new DefaultEvaluator(dc, domDoc);
		      ResultSequence rs = eval.evaluate(path);
	         
	          actual = buildXMLResultString(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);
	        

	   }
	
	protected String buildXMLResultString(ResultSequence rs) throws Exception {
		Iterator iterator = rs.iterator();
		StringBuffer buffer = new StringBuffer();
		while (iterator.hasNext()) {
			AnyType aat = (AnyType)iterator.next();
			if (aat instanceof NodeType) {
				NodeType nodeType = (NodeType) aat;
				IDOMNode node = (IDOMNode) nodeType.node_value();
				buffer = buffer.append(node.getSource());
			} else {
				buffer = buffer.append(aat.string_value());
			}
		}

		return buffer.toString();
	}

}