org.apache.jmeter.util

## Class XPathUtil

- java.lang.Object
- - org.apache.jmeter.util.XPathUtil

    public class XPathUtil
    extends Object

This class provides a few utility methods for dealing with XML/XPath.

### Method Summary

All Methods Static Methods Concrete Methods
`static void` `computeAssertionResult(AssertionResult result, Document doc, String xPathExpression, boolean isNegated)` Fills result
`static void` `computeAssertionResultUsingSaxon(AssertionResult result, String xmlFile, String xPathQuery, String namespaces, Boolean isNegated)`
`static String` `formatXml(String xml)` Formats XML
`static List<String[]>` `getNamespaces(String xml)` Compute namespaces for XML
`static net.sf.saxon.s9api.Processor` `getProcessor()`
`static String` `getValueForNode(Node node)`
`static Document` `makeDocument(InputStream stream, boolean validate, boolean whitespace, boolean namespace, boolean tolerant, boolean quiet, boolean showWarnings, boolean reportErrors, boolean isXml, boolean downloadDTDs)` Utility function to get new Document
`static Document` `makeDocument(InputStream stream, boolean validate, boolean whitespace, boolean namespace, boolean tolerant, boolean quiet, boolean showWarnings, boolean report_errors, boolean isXml, boolean downloadDTDs, OutputStream tidyOut)` Utility function to get new Document
`static DocumentBuilder` `makeDocumentBuilder(boolean validate, boolean whitespace, boolean namespace, boolean downloadDTDs)` Create a DocumentBuilder using the makeDocumentFactory func.
`static org.w3c.tidy.Tidy` `makeTidyParser(boolean quiet, boolean showWarnings, boolean isXml, StringWriter stringWriter)` Create a Tidy parser with the specified settings.
`static List<String[]>` `namespacesParse(String namespaces)`
`static void` `putValuesForXPathInList(Document document, String xPathQuery, List<String> matchStrings, boolean fragment)` Put in matchStrings results of evaluation
`static void` `putValuesForXPathInList(Document document, String xPathQuery, List<String> matchStrings, boolean fragment, int matchNumber)` Put in matchStrings results of evaluation
`static void` `putValuesForXPathInListUsingSaxon(String xmlFile, String xPathQuery, List<String> matchStrings, boolean fragment, int matchNumber, String namespaces)`
`static NodeList` `selectNodeList(Document document, String xPathExpression)` Extract NodeList using expression
`static void` `validateXPath(Document document, String xpathString)` Validate xpathString is a valid XPath expression
`static void` `validateXPath2(Document document, String xpathString, String namespaces)` Validate xpathString is a valid XPath expression

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Method Detail

#### getProcessor

    public static net.sf.saxon.s9api.Processor getProcessor()

#### makeDocumentBuilder

    public static DocumentBuilder makeDocumentBuilder(boolean validate,
                                                      boolean whitespace,
                                                      boolean namespace,
                                                      boolean downloadDTDs)
                                               throws ParserConfigurationException

Create a DocumentBuilder using the makeDocumentFactory func.

Parameters:
  `validate` - should the parser validate documents?
  `whitespace` - should the parser eliminate whitespace in element content?
  `namespace` - should the parser be namespace aware?
  `downloadDTDs` - if true, parser should attempt to resolve external entities
Returns:
  document builder
Throws:
  `ParserConfigurationException` - if `DocumentBuilder` can not be created for the wanted configuration

#### makeDocument

    public static Document makeDocument(InputStream stream,
                                        boolean validate,
                                        boolean whitespace,
                                        boolean namespace,
                                        boolean tolerant,
                                        boolean quiet,
                                        boolean showWarnings,
                                        boolean reportErrors,
                                        boolean isXml,
                                        boolean downloadDTDs)
                                 throws ParserConfigurationException,
                                        SAXException,
                                        IOException,
                                        TidyException

Utility function to get new Document

Parameters:
  `stream` - - Document Input stream
  `validate` - - Validate Document (not Tidy)
  `whitespace` - - Element Whitespace (not Tidy)
  `namespace` - - Is Namespace aware. (not Tidy)
  `tolerant` - - Is tolerant - i.e. use the Tidy parser
  `quiet` - - set Tidy quiet
  `showWarnings` - - set Tidy warnings
  `reportErrors` - - throw TidyException if Tidy detects an error
  `isXml` - - is document already XML (Tidy only)
  `downloadDTDs` - - if true, try to download external DTDs
Returns:
  document
Throws:
  `ParserConfigurationException` - when no `DocumentBuilder` can be constructed for the wanted configuration
  `SAXException` - if parsing fails
  `IOException` - if an I/O error occurs while parsing
  `TidyException` - if a ParseError is detected and `report_errors` is `true`

#### makeDocument

    public static Document makeDocument(InputStream stream,
                                        boolean validate,
                                        boolean whitespace,
                                        boolean namespace,
                                        boolean tolerant,
                                        boolean quiet,
                                        boolean showWarnings,
                                        boolean report_errors,
                                        boolean isXml,
                                        boolean downloadDTDs,
                                        OutputStream tidyOut)
                                 throws ParserConfigurationException,
                                        SAXException,
                                        IOException,
                                        TidyException

Utility function to get new Document

Parameters:
  `stream` - - Document Input stream
  `validate` - - Validate Document (not Tidy)
  `whitespace` - - Element Whitespace (not Tidy)
  `namespace` - - Is Namespace aware. (not Tidy)
  `tolerant` - - Is tolerant - i.e. use the Tidy parser
  `quiet` - - set Tidy quiet
  `showWarnings` - - set Tidy warnings
  `report_errors` - - throw TidyException if Tidy detects an error
  `isXml` - - is document already XML (Tidy only)
  `downloadDTDs` - - if true, try to download external DTDs
  `tidyOut` - OutputStream for Tidy pretty-printing
Returns:
  document
Throws:
  `ParserConfigurationException` - if `DocumentBuilder` can not be created for the wanted configuration
  `SAXException` - if parsing fails
  `IOException` - if I/O error occurs while parsing
  `TidyException` - if a ParseError is detected and `report_errors` is `true`

#### makeTidyParser

    public static org.w3c.tidy.Tidy makeTidyParser(boolean quiet,
                                                   boolean showWarnings,
                                                   boolean isXml,
                                                   StringWriter stringWriter)

Create a Tidy parser with the specified settings.

Parameters:
  `quiet` - - set the Tidy quiet flag?
  `showWarnings` - - show Tidy warnings?
  `isXml` - - treat the content as XML?
  `stringWriter` - - if non-null, use this for Tidy errorOutput
Returns:
  the Tidy parser

#### getValueForNode

    public static String getValueForNode(Node node)

Parameters:
  `node` - `Node`
Returns:
  String content of node

#### selectNodeList

    public static NodeList selectNodeList(Document document,
                                          String xPathExpression)
                                   throws TransformerException

Extract NodeList using expression

Parameters:
  `document` - `Document`
  `xPathExpression` - XPath expression
Returns:
  `NodeList`
Throws:
  `TransformerException` - when the internally used xpath engine fails

#### putValuesForXPathInList

    public static void putValuesForXPathInList(Document document,
                                               String xPathQuery,
                                               List<String> matchStrings,
                                               boolean fragment)
                                        throws TransformerException

Put in matchStrings results of evaluation

Parameters:
  `document` - XML document
  `xPathQuery` - XPath Query
  `matchStrings` - List of strings that will be filled
  `fragment` - return fragment
Throws:
  `TransformerException` - when the internally used xpath engine fails

#### putValuesForXPathInList

    public static void putValuesForXPathInList(Document document,
                                               String xPathQuery,
                                               List<String> matchStrings,
                                               boolean fragment,
                                               int matchNumber)
                                        throws TransformerException

Put in matchStrings results of evaluation

Parameters:
  `document` - XML document
  `xPathQuery` - XPath Query
  `matchStrings` - List of strings that will be filled
  `fragment` - return fragment
  `matchNumber` - match number
Throws:
  `TransformerException` - when the internally used xpath engine fails

#### putValuesForXPathInListUsingSaxon

    public static void putValuesForXPathInListUsingSaxon(String xmlFile,
                                                         String xPathQuery,
                                                         List<String> matchStrings,
                                                         boolean fragment,
                                                         int matchNumber,
                                                         String namespaces)
                                                  throws net.sf.saxon.s9api.SaxonApiException,
                                                         FactoryConfigurationError

Throws:
  `net.sf.saxon.s9api.SaxonApiException`
  `FactoryConfigurationError`

#### namespacesParse

    public static List<String[]> namespacesParse(String namespaces)

#### getNamespaces

    public static List<String[]> getNamespaces(String xml)
                                        throws XMLStreamException,
                                               FactoryConfigurationError

Compute namespaces for XML

Parameters:
  `xml` - XML content
Returns:
  List of Namespaces
Throws:
  `XMLStreamException` - on problematic xml
  `FactoryConfigurationError` - when no xml input factory can be established

#### validateXPath

    public static void validateXPath(Document document,
                                     String xpathString)
                              throws TransformerException

Validate xpathString is a valid XPath expression

Parameters:
  `document` - XML Document
  `xpathString` - XPATH String
Throws:
  `TransformerException` - if expression fails to evaluate

#### validateXPath2

    public static void validateXPath2(Document document,
                                      String xpathString,
                                      String namespaces)
                               throws TransformerException

Validate xpathString is a valid XPath expression

Parameters:
  `document` - XML Document
  `xpathString` - XPATH String
  `namespaces` - Space separated set of prefix=namespace
Throws:
  `TransformerException` - if expression fails to evaluate

#### computeAssertionResult

    public static void computeAssertionResult(AssertionResult result,
                                              Document doc,
                                              String xPathExpression,
                                              boolean isNegated)

Fills result

Parameters:
  `result` - `AssertionResult`
  `doc` - XML Document
  `xPathExpression` - XPath expression
  `isNegated` - flag whether a non-match should be considered a success

#### computeAssertionResultUsingSaxon

    public static void computeAssertionResultUsingSaxon(AssertionResult result,
                                                        String xmlFile,
                                                        String xPathQuery,
                                                        String namespaces,
                                                        Boolean isNegated)
                                                 throws net.sf.saxon.s9api.SaxonApiException,
                                                        FactoryConfigurationError

Parameters:
  `result` - The result of xpath2 assertion
  `xmlFile` - XML data
  `xPathQuery` - XPath Query
  `namespaces` - Space separated set of prefix=namespace
  `isNegated` - invert result
Throws:
  `net.sf.saxon.s9api.SaxonApiException` - when the parser has problems with the given xml or xpath query
  `FactoryConfigurationError` - when the parser can not be instantiated

#### formatXml

    public static String formatXml(String xml)

Formats XML

Parameters:
  `xml` - string to format
Returns:
  String formatted XML