import net.sf.saxon.xpath.XPathEvaluator; //导入依赖的package包/类
/**
 * Get a Saxon XPathEvaluator for the purposes of compiling an XPath.
 *
 * @param pBackwardsCompatible If true, turns XPath 1.0 backwards compatibility mode on.
 * @param pNamespaceMap        Optional NamespaceContext for resolution of arbitrary namespaces. Leave null to use default.
 * @return A new single-use XPathEvaluator.
 */
public static XPathEvaluator getXPathEvaluator(boolean pBackwardsCompatible, DynamicNamespaceContext pNamespaceMap) {

  XPathEvaluator lXPE = new XPathEvaluator(SaxonEnvironment.getSaxonConfiguration());
  lXPE.getStaticContext().setBackwardsCompatibilityMode(pBackwardsCompatible);

  //All XPath expressions should use the ThreadLocal variable resolver if one exists - setup the proxy for accessing it here
  lXPE.setXPathVariableResolver(VariableResolverProxy.INSTANCE);

  if (pNamespaceMap == null) {
    lXPE.setNamespaceContext(gFoxNamespaceContext);
  }
  else {
    lXPE.setNamespaceContext(pNamespaceMap);
  }
  return lXPE;
}
 

import net.sf.saxon.xpath.XPathEvaluator; //导入依赖的package包/类
@Override
public List<Object> evaluate(TestCase testCase, String file) throws Exception{
    XPathFactoryImpl xpf = new XPathFactoryImpl();
    XPathEvaluator xpe = (XPathEvaluator)xpf.newXPath();
    xpe.getConfiguration().setVersionWarning(false);
    ((StandardErrorListener)xpe.getConfiguration().getErrorListener()).setRecoveryPolicy(Configuration.RECOVER_SILENTLY);
    xpe.getStaticContext().setBackwardsCompatibilityMode(true);
    xpe.setXPathVariableResolver(testCase.variableResolver);
    xpe.setXPathFunctionResolver(testCase.functionResolver);
    xpe.setNamespaceContext(testCase.nsContext);
    NodeInfo doc = xpe.getConfiguration().buildDocument(new SAXSource(new InputSource(file)));

    List<Object> results = new ArrayList<Object>(testCase.xpaths.size());
    for(XPathInfo xpathInfo: testCase.xpaths){
        if(xpathInfo.forEach==null)
            results.add(xpe.evaluate(xpathInfo.xpath, doc, xpathInfo.resultType));
        else{
            List<Object> list = new ArrayList<Object>();
            List nodeList = (List)xpe.evaluate(xpathInfo.forEach, doc, XPathConstants.NODESET);
            for(Object context: nodeList)
                list.add(xpe.evaluate(xpathInfo.xpath, context, xpathInfo.resultType));
            results.add(list);
        }
    }
    return results;
}
 

import net.sf.saxon.xpath.XPathEvaluator; //导入依赖的package包/类
@Nonnull
private XPath _createXPathContext ()
{
  final MapBasedNamespaceContext aNamespaceContext = getNamespaceContext ();
  final XPath aXPathContext = XPathHelper.createNewXPath (m_aXPathFactory,
                                                          m_aXPathVariableResolver,
                                                          m_aXPathFunctionResolver,
                                                          aNamespaceContext);

  if ("net.sf.saxon.xpath.XPathEvaluator".equals (aXPathContext.getClass ().getName ()))
  {
    // Saxon implementation special handling
    final XPathEvaluator aSaxonXPath = (XPathEvaluator) aXPathContext;

    // Since 9.7.0-4 it must implement NamespaceResolver
    aSaxonXPath.setNamespaceContext (new SaxonNamespaceContext (aNamespaceContext));

    // Wrap the PSErrorHandler to a ErrorListener
    aSaxonXPath.getConfiguration ().setErrorListener (new PSErrorListener (getErrorHandler ()));
  }
  return aXPathContext;
}
 

import net.sf.saxon.xpath.XPathEvaluator; //导入依赖的package包/类
private boolean isContained(TestAssertion assertion, String fileLocation)
		throws XPathExpressionException,
		XPathFactoryConfigurationException, XPathException {
	XPathFactory xpathFactory = XPathFactory
			.newInstance(NamespaceConstant.OBJECT_MODEL_SAXON);
	XPathEvaluator xpath = (XPathEvaluator) xpathFactory.newXPath();
	xpath.getConfiguration().setLineNumbering(true);
	xpath.setNamespaceContext(new BpelNamespaceContext());
	XPathExpression expr = xpath.compile(assertion.getTarget());
	InputSource inputSource = new InputSource(
			new File(fileLocation).toString());
	SAXSource saxSource = new SAXSource(inputSource);
	NodeInfo doc = xpath.getConfiguration().buildDocument(saxSource);

	@SuppressWarnings("unchecked")
	List<NodeInfo> matchedLines = (List<NodeInfo>) expr.evaluate(doc,
			XPathConstants.NODESET);
	if (matchedLines.size() > 0) {
		return true;
	}

	return false;
}
 

import net.sf.saxon.xpath.XPathEvaluator; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    super.setUp();
    exchange = new DefaultExchange(context);
    evaluator = new XPathEvaluator();
    doc = evaluator.setSource(new StringSource(CONTENT));
}
 

import net.sf.saxon.xpath.XPathEvaluator; //导入依赖的package包/类
/**
 * Construct a new FoxXPath for the given XPath string.
 * @param pXPathDefinition XPath definition containing a FOX-compliant executable XPath string, possibly containing :{contexts} and/or custom FOX functions.
 * @param pUseXPathBackwardsCompatibility If true, switches XPath 1.0 backwards compatibility mode on.
 * @param pNamespaceMap Optional map for namespace-aware XPath processing.
 * @throws ExBadPath If the XPath cannot be compiled for any reason.
 */
FoxXPath(XPathDefinition pXPathDefinition, boolean pUseXPathBackwardsCompatibility, DynamicNamespaceContext pNamespaceMap)
throws ExBadPath {

  long lStartTime = System.currentTimeMillis();
  mXPathDefinition = pXPathDefinition;
  mLabelSet = new LinkedHashSet<>();
  mInternalXPathString = SaxonEnvironment.replaceFoxMarkup(pXPathDefinition.getExecutableXPath(), mLabelSet);

  //If there are no labels, clear away the set object as it's no longer needed
  if(mLabelSet.size() == 0){
    mLabelSet = null;
  }

  XPathEvaluator lXPathEvaluator = SaxonEnvironment.getXPathEvaluator(pUseXPathBackwardsCompatibility, pNamespaceMap);

  try {
    //Compile the XPath and store the result of the compilation.
    mXPathExpression = lXPathEvaluator.compile(mInternalXPathString);
  }
  catch (XPathExpressionException e) {
    throw new ExBadPath("Bad XPath for original extended XPath: '" + mXPathDefinition.getPathForDebug() +  "'. " +
      (mXPathDefinition.getExecutableXPath().equals(mInternalXPathString) ? "" : "\nNote: FOX markup in the XPath was rewritten to: '" + mInternalXPathString + "'"), e);
  }

  //Establish dependencies - Saxon gives us a bitmap which we AND against the relevant constants
  int lDeps = ((XPathExpressionImpl) mXPathExpression).getInternalExpression().getDependencies();
  mUsesContextItem = (StaticProperty.DEPENDS_ON_CONTEXT_ITEM & lDeps) > 0;
  mUsesContextDocument = (StaticProperty.DEPENDS_ON_CONTEXT_DOCUMENT & lDeps) > 0;

  //Store the compile time
  mCompileTime = System.currentTimeMillis() - lStartTime;
}
 

import net.sf.saxon.xpath.XPathEvaluator; //导入依赖的package包/类
@Override
public List<Object> evaluate(TestCase testCase, String file) throws Exception{
    Document doc = toDOM(file);
    List<Object> results = new ArrayList<Object>(testCase.xpaths.size());
    XPath xpathObj = factory.newXPath();
    if(xpathObj instanceof XPathEvaluator){
        XPathEvaluator xpe = (XPathEvaluator)xpathObj;
        xpe.getConfiguration().setVersionWarning(false);
        ((StandardErrorListener)xpe.getConfiguration().getErrorListener()).setRecoveryPolicy(Configuration.RECOVER_SILENTLY);
        xpe.getStaticContext().setBackwardsCompatibilityMode(true);
    }
    for(XPathInfo xpathInfo: testCase.xpaths){
        xpathObj.setXPathVariableResolver(testCase.variableResolver);
        xpathObj.setXPathFunctionResolver(testCase.functionResolver);
        xpathObj.setNamespaceContext(testCase.nsContext);

        if(xpathInfo.forEach==null)
            results.add(xpathObj.evaluate(xpathInfo.xpath, doc, xpathInfo.resultType));
        else{
            List<Object> list = new ArrayList<Object>();
            NodeList nodeList = (NodeList)xpathObj.evaluate(xpathInfo.forEach, doc, XPathConstants.NODESET);
            for(int i=0; i<nodeList.getLength(); i++){
                Object context = nodeList.item(i);
                list.add(xpathObj.evaluate(xpathInfo.xpath, context, xpathInfo.resultType));
            }
            results.add(list);
        }
    }
    return results;
}
 

import net.sf.saxon.xpath.XPathEvaluator; //导入依赖的package包/类
private void createXPathEvaluator()
		throws XPathFactoryConfigurationException {
	XPathFactory xpathFactory = XPathFactory
			.newInstance(NamespaceConstant.OBJECT_MODEL_SAXON);
	xpath = (XPathEvaluator) xpathFactory.newXPath();
	xpath.getConfiguration().setLineNumbering(true);
	xpath.setNamespaceContext(new BpmnNamespaceContext());
}
 

import net.sf.saxon.xpath.XPathEvaluator; //导入依赖的package包/类
private boolean isContained(AdaptableElement element, String fileLocation) {
	try {
		XPathFactory xpathFactory = XPathFactory
				.newInstance(NamespaceConstant.OBJECT_MODEL_SAXON);
		XPathEvaluator xpath = (XPathEvaluator) xpathFactory.newXPath();
		xpath.getConfiguration().setLineNumbering(true);
		xpath.setNamespaceContext(new BpmnNamespaceContext());
		XPathExpression expr = xpath
				.compile(element.getLocatorExpression());
		InputSource inputSource = new InputSource(
				new File(fileLocation).toString());
		SAXSource saxSource = new SAXSource(inputSource);
		NodeInfo doc = xpath.getConfiguration().buildDocument(saxSource);;

		@SuppressWarnings("unchecked")
		List<NodeInfo> matchedLines = (List<NodeInfo>) expr.evaluate(doc,
				XPathConstants.NODESET);
		if (matchedLines.size() > 0) {
			return true;
		}

		return false;
	} catch (XPathFactoryConfigurationException | XPathExpressionException
			| XPathException e) {
		e.printStackTrace();
		return false;
	}
}
 

import net.sf.saxon.xpath.XPathEvaluator; //导入依赖的package包/类
private void createXPathEvaluator()
		throws XPathFactoryConfigurationException {
	XPathFactory xpathFactory = XPathFactory
			.newInstance(NamespaceConstant.OBJECT_MODEL_SAXON);
	xpath = (XPathEvaluator) xpathFactory.newXPath();
	xpath.getConfiguration().setLineNumbering(true);
	xpath.setNamespaceContext(new BpelNamespaceContext());
}
 

import net.sf.saxon.xpath.XPathEvaluator; //导入依赖的package包/类
private boolean isContained(AdaptableElement element, String fileLocation) {
	try {
		XPathFactory xpathFactory = XPathFactory
				.newInstance(NamespaceConstant.OBJECT_MODEL_SAXON);
		XPathEvaluator xpath = (XPathEvaluator) xpathFactory.newXPath();
		xpath.getConfiguration().setLineNumbering(true);
		xpath.setNamespaceContext(new BpmnNamespaceContext());
		XPathExpression expr = xpath
				.compile(element.getLocatorExpression());
		InputSource inputSource = new InputSource(
				new File(fileLocation).toString());
		SAXSource saxSource = new SAXSource(inputSource);
		NodeInfo doc = xpath.setSource(saxSource);

		@SuppressWarnings("unchecked")
		List<NodeInfo> matchedLines = (List<NodeInfo>) expr.evaluate(doc,
				XPathConstants.NODESET);
		if (matchedLines.size() > 0) {
			return true;
		}

		return false;
	} catch (XPathFactoryConfigurationException | XPathExpressionException
			| XPathException e) {
		e.printStackTrace();
		return false;
	}
}
 

import net.sf.saxon.xpath.XPathEvaluator; //导入依赖的package包/类
private void init() throws XPathExpressionException {
    XPathEvaluator xPathEvaluator = new XPathEvaluator();
    xPathEvaluator.setNamespaceContext(XPath2NamespaceContext.INSTANCE);
    xPathExpression = xPathEvaluator.compile(xpathStr);
}