tests/org.eclipse.wst.xml.xpath2.wtptypes.tests/src/org/eclipse/wst/xml/xpath2/wtptypes/test/AbstractPsychoPathWTPTest.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
 *     Jin Mingjan - bug 262765 -  extractXPathExpression and getExpectedResults
 *     Jesper S Moller - bug 283214 - fix IF THEN ELSE parsing and update grammars
 *     Jesper S Moller - bug 283214 - fix XML result serialization
 *     Jesper S Moller - bug 283404 - fixed locale  
 *     Jesper S Moller - bug 281159 - fix document URIs and also filter XML namespace
 *     Jesper S Moller - bug 275610 - Avoid big time and memory overhead for externals
 *     Jesper Steen Moeller - bug 282096 - make test harness handle all string encoding
 *     Jesper Steen Moller  - bug 280555 - Add pluggable collation support
 *     Mukul Gandhi         - bug 338494 - prohibiting xpath expressions starting with / or // to be parsed.
 *******************************************************************************/
package org.eclipse.wst.xml.xpath2.wtptypes.test;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Iterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.xml.XMLConstants;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;

import junit.framework.TestCase;

import org.apache.xerces.jaxp.validation.XSGrammarPoolContainer;
import org.apache.xerces.xni.grammars.Grammar;
import org.apache.xerces.xni.grammars.XMLGrammarDescription;
import org.apache.xerces.xni.grammars.XMLGrammarPool;
import org.apache.xerces.xni.grammars.XSGrammar;
import org.apache.xerces.xs.ElementPSVI;
import org.apache.xerces.xs.XSConstants;
import org.apache.xerces.xs.XSModel;
import org.apache.xerces.xs.XSNamedMap;
import org.apache.xerces.xs.XSObject;
import org.apache.xerces.xs.XSSimpleTypeDefinition;
import org.custommonkey.xmlunit.XMLTestCase;
import org.eclipse.core.runtime.Platform;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IModelManager;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
import org.eclipse.wst.xml.xpath2.api.typesystem.TypeModel;
import org.eclipse.wst.xml.xpath2.processor.DOMLoader;
import org.eclipse.wst.xml.xpath2.processor.DOMLoaderException;
import org.eclipse.wst.xml.xpath2.processor.DefaultDynamicContext;
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.JFlexCupParser;
import org.eclipse.wst.xml.xpath2.processor.ResultSequence;
import org.eclipse.wst.xml.xpath2.processor.StaticChecker;
import org.eclipse.wst.xml.xpath2.processor.StaticError;
import org.eclipse.wst.xml.xpath2.processor.StaticNameResolver;
import org.eclipse.wst.xml.xpath2.processor.XPathParser;
import org.eclipse.wst.xml.xpath2.processor.XPathParserException;
import org.eclipse.wst.xml.xpath2.processor.XercesLoader;
import org.eclipse.wst.xml.xpath2.processor.ast.XPath;
import org.eclipse.wst.xml.xpath2.processor.function.FnFunctionLibrary;
import org.eclipse.wst.xml.xpath2.processor.function.XSCtrLibrary;
import org.eclipse.wst.xml.xpath2.processor.internal.types.AnyType;
import org.eclipse.wst.xml.xpath2.processor.internal.types.DocType;
import org.eclipse.wst.xml.xpath2.processor.internal.types.NodeType;
import org.eclipse.wst.xml.xpath2.processor.internal.types.QName;
import org.eclipse.wst.xml.xpath2.processor.internal.types.XSBoolean;
import org.eclipse.wst.xml.xpath2.processor.internal.types.userdefined.UserDefinedCtrLibrary;
import org.eclipse.wst.xml.xpath2.processor.internal.types.xerces.XercesTypeModel;
import org.osgi.framework.Bundle;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.ls.DOMImplementationLS;
import org.w3c.dom.ls.LSOutput;
import org.w3c.dom.ls.LSSerializer;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.ext.EntityResolver2;

public class AbstractPsychoPathWTPTest extends XMLTestCase {

	protected Document domDoc = null;
	protected Document domDoc2 = null;
	protected Bundle bundle = null;

	IDOMModel model = null;

	private DynamicContext dynamicContext = null;
	
	private static final String INPUT_CONTEXT = "input-context";
	private static final String INPUT_CONTEXT1 = "input-context1";
	private static final String INPUT_CONTEXT2 = "input-context2";
	// private static final String S_COMMENT1 = "(:";
	private static final String S_COMMENT2 = ":)";
	private static final String DECLARE_NAMESPACE = "declare namespace";
	private static final String IMPORT_SCHEMA_NAMESPACE = "import schema namespace";
	private static final String REGEX_DN = " namespace\\s+(\\w[-_\\w]*)\\s*=\\s*['\"]([^;]*)['\"];";

	private static HashMap inputMap = new HashMap(3);

	protected void setUp() throws Exception {
		super.setUp();
		bundle = Platform
				.getBundle("org.w3c.xqts.testsuite");

		
		if (bundle == null) {
			System.setProperty("javax.xml.parsers.DocumentBuilderFactory", "org.apache.xerces.jaxp.DocumentBuilderFactoryImpl");
		}
		System.setProperty("javax.xml.validation.SchemaFactory:http://www.w3.org/2001/XMLSchema","org.apache.xerces.jaxp.validation.XMLSchemaFactory");
	}

	protected void loadDOMDocument(URL fileURL) throws IOException,
			DOMLoaderException {
		InputStream is = testResolve(fileURL);
		DOMLoader domloader = new XercesLoader();
		domloader.set_validating(false);
		domDoc = domloader.load(is);
		domDoc.setDocumentURI(fileURL.toString());
	}

	private InputStream testResolve(URL url) throws IOException {
		if (url.getProtocol().equals("http")) {
			return AbstractPsychoPathWTPTest.class.getResourceAsStream("/org/eclipse/wst/xml/xpath2/processor/test/" + url.getFile());
		} else {
			return url.openStream();
		}
	}
	
	protected InputSource getTestSource(String systemId) {
		if (systemId.startsWith("http://")) {
			try {
				URL u = new URL(systemId);
				InputSource inputSource = new InputSource(testResolve(u));
				inputSource.setSystemId(systemId);
				return inputSource;
			} catch (MalformedURLException e) {
				throw new RuntimeException(e);
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return new InputSource(systemId);
	}
	
	protected EntityResolver makeTestResolver() {
		return new EntityResolver2() {
			
			public InputSource resolveEntity(String publicId, String systemId) {
				if (systemId.startsWith("http://")) {
					URL u;
					try {
						u = new URL(systemId);
						return new InputSource(testResolve(u));
					} catch (MalformedURLException e) {
						throw new RuntimeException(e);
					} catch (IOException e) {
						throw new RuntimeException(e);
					}
				}
				return new InputSource(systemId);
			}

			public InputSource getExternalSubset(String publicId, String systemId)
					throws SAXException, IOException {
				return resolveEntity(publicId, systemId);
			}

			public InputSource resolveEntity(String name,
                    String publicId,
                    String baseURI,
                    String systemId) throws SAXException, IOException {
				return resolveEntity(publicId, systemId);
			}
			
		};
	}
	
	protected void loadDOMDocument(URL fileURL, Schema schema) throws IOException, DOMLoaderException {
		InputStream is = testResolve(fileURL);
		DOMLoader domloader = new XercesLoader(schema);
		domloader.set_validating(false);
		domDoc = domloader.load(is);
		domDoc.setDocumentURI(fileURL.toString());
		
	}
	
	protected void load2DOMDocument(URL fileURL, URL fileURL2) throws IOException,
			DOMLoaderException {
		InputStream is = testResolve(fileURL);
		InputStream is2 = testResolve(fileURL2);
		
		DOMLoader domloader = new XercesLoader();
		domloader.set_validating(false);
		domDoc = domloader.load(is);
		domDoc.setDocumentURI(fileURL.toString());
		domDoc2 = domloader.load(is2);
		domDoc2.setDocumentURI(fileURL2.toString());
		is.close();
		is2.close();
	}	

	protected void tearDown() throws Exception {
		super.tearDown();
		domDoc = null;
		domDoc2 = null;
		dynamicContext = null;
		if (model != null) {
			model.releaseFromRead();
		}
	}

	protected XSModel getGrammar() {
		ElementPSVI rootPSVI = (ElementPSVI) domDoc.getDocumentElement();
		XSModel schema = rootPSVI.getSchemaInformation();
		return schema;
	}

	protected void loadDOMDocument(URL fileURL, URL schemaURL)
			throws IOException, DOMLoaderException, SAXException {
		InputStream is = testResolve(fileURL);
		InputStream schemaIs = testResolve(schemaURL);
		Schema jaxpSchema = getSchema(schemaIs);
		DOMLoader domloader = new XercesLoader(jaxpSchema);
		domloader.set_validating(false);
		domDoc = domloader.load(is);
	}
	
	

	private Schema getSchema(InputStream schemaIs) throws SAXException {
		SchemaFactory sf = SchemaFactory
				.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
		Schema schema = sf.newSchema(new StreamSource(schemaIs));
		return schema;
	}

	protected XSModel getGrammar(URL schemaURL) throws IOException,
			SAXException {
		InputStream schemaIs = testResolve(schemaURL);
		SchemaFactory sf = SchemaFactory
				.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
		Schema schema = sf.newSchema(new StreamSource(schemaIs));
		XSGrammarPoolContainer poolContainer = (XSGrammarPoolContainer) schema;
		XMLGrammarPool pool = poolContainer.getGrammarPool();
		Grammar[] grammars = pool
				.retrieveInitialGrammarSet(XMLGrammarDescription.XML_SCHEMA);

		XSGrammar[] xsGrammars = new XSGrammar[grammars.length];
		System.arraycopy(grammars, 0, xsGrammars, 0, grammars.length);

		return xsGrammars[0].toXSModel(xsGrammars);
	}

	protected DefaultDynamicContext setupDynamicContext(XSModel schema) {
		XercesTypeModel typeModel = schema != null ? new XercesTypeModel(schema) : null;
		DefaultDynamicContext dc = new DefaultDynamicContext(typeModel);
//		DefaultDynamicContext dc = new DefaultDynamicContext(schema, domDoc);
		dynamicContext = dc;
		
		dc.add_namespace("xs", "http://www.w3.org/2001/XMLSchema");
		dc.add_namespace("xsd", "http://www.w3.org/2001/XMLSchema");
		dc.add_namespace("fn", "http://www.w3.org/2005/xpath-functions");
		dc.add_namespace("xml", "http://www.w3.org/XML/1998/namespace");

		dc.add_function_library(new FnFunctionLibrary());
		dc.add_function_library(new XSCtrLibrary());
		setupVariables(dc);
		return dc;
	}

	protected DefaultDynamicContext setupDynamicContext2(TypeModel model) {
		DefaultDynamicContext dc = new DefaultDynamicContext(model);
		dynamicContext = dc;
		
		dc.add_namespace("xs", "http://www.w3.org/2001/XMLSchema");
		dc.add_namespace("xsd", "http://www.w3.org/2001/XMLSchema");
		dc.add_namespace("fn", "http://www.w3.org/2005/xpath-functions");
		dc.add_namespace("xml", "http://www.w3.org/XML/1998/namespace");

		dc.add_function_library(new FnFunctionLibrary());
		dc.add_function_library(new XSCtrLibrary());
		setupVariables(dc);
		return dc;
	}

	protected void addXPathDefaultNamespace(String uri) {
	   dynamicContext.add_namespace(null, uri);	
	}

	protected XPath compileXPath(DynamicContext dc, String xpath) throws XPathParserException, StaticError {
		XPathParser xpp = new JFlexCupParser();
		XPath path = xpp.parse(xpath);

		StaticChecker name_check = new StaticNameResolver(dc);
		name_check.check(path);
		return path;
	}
	
	protected XPath compileXPath(DynamicContext dc, String xpath, boolean isRootlessAccess) throws XPathParserException, StaticError {
       XPathParser xpp = new JFlexCupParser();
       XPath path = null; 
       if (isRootlessAccess) {
          path = xpp.parse(xpath, isRootlessAccess);
       }
       else {
    	   path = xpp.parse(xpath); 
       }
       
       StaticChecker name_check = new StaticNameResolver(dc);
       name_check.check(path);
       return path;
    }

	protected String getExpectedResult(String xqFile) {
		return getExpectedResult(xqFile, true);
	}

	protected String getExpectedResultNoEscape(String xqFile) {
		return getExpectedResult(xqFile, false);
	}

	protected String getExpectedResult(String xqFile, boolean unescape) {
		String resultFile = xqFile;
		//
		if (resultFile.length() < 10) { // <9 enough? like XPST0001
			return resultFile;
		}
		String content = "";
		//
		InputStream isrf;
		try {
			isrf = bundle.getEntry(resultFile).openStream();
			BufferedReader rfreader = new BufferedReader(new InputStreamReader(
					isrf, "UTF-8"));
			// XXX:assume char buffer 2048 is long enough;1024 maybe enough
			// Exception: Axes085, NodeTest003/04/05,...
			int bufferLength = 2048;
			if ((resultFile.indexOf("Axes085") != -1)
					|| (resultFile.indexOf("NodeTest003") != -1)
					|| (resultFile.indexOf("NodeTest004") != -1)
					|| (resultFile.indexOf("NodeTest005") != -1)) {
				bufferLength = 40000;
			} else if (resultFile.indexOf("ForExpr013") != -1) {
				bufferLength = 433500;
			} else if (resultFile.indexOf("ForExpr016") != -1
					|| (resultFile.indexOf("ReturnExpr011") != -1)
					|| (resultFile.indexOf("sgml-queries-results-q1") != -1)
					|| (resultFile.indexOf("sgml-queries-results-q2") != -1)) {
				bufferLength = 10240;
			}
			char[] cbuf = new char[bufferLength];
			int nByte = rfreader.read(cbuf);
			assertTrue(resultFile, nByte < bufferLength);// assert nice buffer
			// length

			content = new String(cbuf).trim();
			rfreader.close();
			isrf.close();

		} catch (IOException e) {
			throw new RuntimeException("Can't load expected result from : " + xqFile, e);
		}
		if (unescape && content.contains("&")) return resolveCharacterReferences(content);
		return content;
	}

	public String unwrapResult(String expectedResult, String elemName) {
		return trimSurrounding(expectedResult, "<"+ elemName + ">", "</" + elemName + ">");
	}
	
	protected String getExpectedResult(String resultFile, String elemName) {
		return unwrapResult(getExpectedResult(resultFile), elemName);
	}

	public String extractXPathExpressionNoEscape(String xqFile, String inputFile) {
		return extractXPathExpression(xqFile, inputFile, false);
	}

	public String extractXPathExpression(String xqFile, String inputFile) {
		return extractXPathExpression(xqFile, inputFile, true);
	}

	public String extractXPathExpression(String xqFile, String inputFile, boolean unescape) {
		// get the xpath2 expr from xq file, first
		char[] cbuf = new char[2048];//
		String content = null;
		String xpath2Expr = null;

		try {
			URL entryUrl = bundle.getEntry(xqFile);
			InputStream isxq = testResolve(entryUrl);
			if (dynamicContext.base_uri().string_value() == null)
				dynamicContext.set_base_uri(entryUrl.toString());
			BufferedReader xqreader = new BufferedReader(new InputStreamReader(
					isxq, Charset.forName("UTF-8")));
			int nByte = xqreader.read(cbuf);
			assertTrue(xqFile, nByte < 2048);
			content = new String(cbuf).trim();
			//
			if (content.indexOf(INPUT_CONTEXT) != -1
					&& content.indexOf(INPUT_CONTEXT1) == -1
					&& content.indexOf(INPUT_CONTEXT2) == -1) {
				inputMap.put(INPUT_CONTEXT, inputFile);
			} else if (content.indexOf(INPUT_CONTEXT1) == -1) {
				inputMap.put(INPUT_CONTEXT1, inputFile);
			} else if (content.indexOf(INPUT_CONTEXT2) != -1) {
				inputMap.put(INPUT_CONTEXT2, inputFile);
			}
			//	        
			if (content.indexOf(DECLARE_NAMESPACE) != -1 || content.indexOf(IMPORT_SCHEMA_NAMESPACE) != -1) {
				setupNamespace(content);
			}
			//
			assertTrue(content.lastIndexOf(S_COMMENT2) != -1);// assert to get
			xpath2Expr = content.substring(content.lastIndexOf(S_COMMENT2) + 2)
					.trim();			
			xqreader.close();
			isxq.close();
		} catch (IOException e) {
			throw new RuntimeException("Can't extract XPath expression from XQuery file : " + xqFile, e);
		}
		if (unescape && xpath2Expr.contains("&")) {
			return resolveCharacterReferences(xpath2Expr);
		} else {
			return xpath2Expr;
		}
	}

	protected String extractXPathExpression(String xqFile, String inputFile,
			String tagName) {
		return unwrapQuery(extractXPathExpression(xqFile, inputFile), tagName);
	}

	protected String unwrapQuery(String xpath2Expr, String tag) {
		String str = "<" + tag + ">";
		String endStr = "</" + tag + ">";
		String withoutTag = trimSurrounding(xpath2Expr, str, endStr);
		if (withoutTag != xpath2Expr) {
			// also trim off the braces { }
			xpath2Expr = trimSurrounding(withoutTag, "{", "}");
		}
		return xpath2Expr;
	}

	protected String trimSurrounding(String xpath2Expr, String str, String endStr) {
		int indexOfStart = xpath2Expr.indexOf(str);
		int indexOfEnd = xpath2Expr.indexOf(endStr);
		if (indexOfStart >= 0 && indexOfEnd >= 0) {
			xpath2Expr = xpath2Expr.substring(indexOfStart + str.length(), indexOfEnd).trim(); 
		}
		return xpath2Expr;
	}

	protected void setupNamespace(String content) {
		if (dynamicContext == null) return; // Can't set it up if nonexistent
		Pattern p = Pattern.compile(REGEX_DN);
		Matcher m = p.matcher(content);
		while (m.find()) {
			assertTrue(m.groupCount() == 2);//
			dynamicContext.add_namespace(m.group(1), m.group(2));
		}

	}

	protected DynamicContext setupVariables(DynamicContext dc) {
		dc.add_variable(new QName("x"));
		dc.add_variable(new QName("var"));
		
		if (domDoc != null) {
			AnyType docType = new DocType(domDoc, dc.getTypeModel(domDoc));
			dc.set_variable(new QName("input-context1"), docType);
			dc.set_variable(new QName("input-context"), docType);
			if (domDoc2 == null) {
				dc.set_variable(new QName("input-context2"), docType);
			} else {
				dc.set_variable(new QName("input-context2"), (AnyType) new DocType(domDoc2, dc.getTypeModel(domDoc2)));
			}
		}
		return dc;
	}

	protected String buildResultString(ResultSequence rs) {
		String actual = new String();
		Iterator iterator = rs.iterator();
		while (iterator.hasNext()) {
			AnyType anyType = (AnyType)iterator.next();
			
			actual = actual + anyType.string_value() + " ";
		}

		return actual.trim();
	}
	
	protected String buildXMLResultString(ResultSequence rs) throws Exception {
        DOMImplementationLS domLS = (DOMImplementationLS) domDoc.getImplementation().getFeature("LS", "3.0");
        LSOutput outputText = domLS.createLSOutput();
        LSSerializer serializer = domLS.createLSSerializer();
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        outputText.setByteStream(outputStream);
        
		String actual = new String();
		Iterator iterator = rs.iterator();
		boolean queueSpace = false;
		while (iterator.hasNext()) {
			AnyType aat = (AnyType)iterator.next();
			if (aat instanceof NodeType) {
				NodeType nodeType = (NodeType) aat;
				Node node = nodeType.node_value();
				serializer.write(node, outputText);
				queueSpace = false;
			} else {
				if (queueSpace) outputText.getByteStream().write(32);
				outputText.getByteStream().write(aat.string_value().getBytes("UTF-8"));
				queueSpace = true;
			}
		}

		actual = outputStream.toString("UTF-8");
		actual = actual.replace("<?xml version=\"1.0\" encoding=\"UTF-8\"?>", "");
		actual = actual.replace("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>", "");
		outputStream.close();
		return actual.trim();
	}
	
	protected String formatResultString(String resultFile) throws Exception {
		DOMLoader domloader = new XercesLoader(null);
		domloader.set_validating(false);
		InputStream is = bundle.getEntry(resultFile).openStream();		
		Document resultDoc = domloader.load(is);

        DOMImplementationLS domLS = (DOMImplementationLS) resultDoc.getImplementation().getFeature("LS", "3.0");
        LSSerializer serializer = domLS.createLSSerializer();
        
        String actual = serializer.writeToString(resultDoc.getDocumentElement());

		actual = actual.replace("<?xml version=\"1.0\" encoding=\"UTF-16\"?>", "");
		return actual.trim();
	}

	public Document load(java.net.URL url) throws Exception {
		IModelManager modelManager = StructuredModelManager.getModelManager();
		InputStream inStream = url.openStream();
		if (inStream == null)
			throw new FileNotFoundException("Can't file resource stream "
					+ url.getFile());
		model = (IDOMModel) modelManager.getModelForRead(url.toString(),
				inStream, null);

		return model.getDocument();
	}

	protected String removeIrrelevantNamespaces(String expectedResult) {
		expectedResult = expectedResult.replaceAll(" xmlns:xml=\"http://www.w3.org/XML/1998/namespace\"", "");
		expectedResult = expectedResult.replaceAll(" xmlns:foo=\"http://www.example.com/foo\"", "");
	    expectedResult = expectedResult.replaceAll(" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"", "");
		return expectedResult;
	}

	protected String resolveCharacterReferences(String xpath) {
		String docText = "<doc>" + xpath + "</doc>";
		InputStream is;
		try {
			is = new ByteArrayInputStream(docText.getBytes("UTF-8"));
			DOMLoader domloader = new XercesLoader();
			domloader.set_validating(false);
			Document temp = domloader.load(is);
			return temp.getDocumentElement().getFirstChild().getTextContent();
		} catch (UnsupportedEncodingException e) {
			throw new RuntimeException(e);
		} catch (DOMLoaderException e) {
			throw new RuntimeException(e);
		}
	}

	protected void assertXPathTrue(String xpath, DynamicContext dc, Document domDoc) {
		XSBoolean result = evaluateBoolXPath(xpath, dc, domDoc);
		assertEquals(true, result.value());
	}

	protected XSBoolean evaluateBoolXPath(String xpath, DynamicContext dc, Document doc) {
		return  (XSBoolean) evaluateSimpleXPath(xpath, dc, doc, XSBoolean.class);
	}
		
	protected AnyType evaluateSimpleXPath(String xpath, DynamicContext dc, Document doc, Class resultClass) {
		XPath path;
		try {
			path = compileXPath(dc, xpath);
		}
		catch (XPathParserException e) {
			throw new RuntimeException("XPath parse: " + e.getMessage(), e);
		}
		catch (StaticError e) {
			throw new RuntimeException("Static error: " + e.getMessage(), e);
		}
	
		Evaluator eval = new DefaultEvaluator(dc, doc);
		ResultSequence rs;
		try {
			rs = eval.evaluate(path);
		}
		catch (DynamicError e) {
			throw new RuntimeException("Evaluation error: " + e.getMessage(), e);
		}
		assertEquals("Expected single result from \'" + xpath + "\'", 1, rs.size());
		
		AnyType result = rs.first();
		assertTrue("Exected XPath result instanceof class " + resultClass.getSimpleName() + " from \'" + xpath + "\', got " + result.getClass(), resultClass.isInstance(result));
		
		return result;
	}


}