<form method="POST">
    <h3>Editing: HasXPath.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php
namespace Hamcrest\Xml;

/*
 Copyright (c) 2009 hamcrest.org
 */
use Hamcrest\Core\IsEqual;
use Hamcrest\Description;
use Hamcrest\DiagnosingMatcher;
use Hamcrest\Matcher;

/**
 * Matches if XPath applied to XML/HTML/XHTML document either
 * evaluates to result matching the matcher or returns at least
 * one node, matching the matcher if present.
 */
class HasXPath extends DiagnosingMatcher
{

    /**
     * XPath to apply to the DOM.
     *
     * @var string
     */
    private $_xpath;

    /**
     * Optional matcher to apply to the XPath expression result
     * or the content of the returned nodes.
     *
     * @var Matcher
     */
    private $_matcher;

    public function __construct($xpath, Matcher $matcher = null)
    {
        $this-&gt;_xpath = $xpath;
        $this-&gt;_matcher = $matcher;
    }

    /**
     * Matches if the XPath matches against the DOM node and the matcher.
     *
     * @param string|\DOMNode $actual
     * @param Description $mismatchDescription
     * @return bool
     */
    protected function matchesWithDiagnosticDescription($actual, Description $mismatchDescription)
    {
        if (is_string($actual)) {
            $actual = $this-&gt;createDocument($actual);
        } elseif (!$actual instanceof \DOMNode) {
            $mismatchDescription-&gt;appendText('was ')-&gt;appendValue($actual);

            return false;
        }
        $result = $this-&gt;evaluate($actual);
        if ($result instanceof \DOMNodeList) {
            return $this-&gt;matchesContent($result, $mismatchDescription);
        } else {
            return $this-&gt;matchesExpression($result, $mismatchDescription);
        }
    }

    /**
     * Creates and returns a &lt;code&gt;DOMDocument&lt;/code&gt; from the given
     * XML or HTML string.
     *
     * @param string $text
     * @return \DOMDocument built from &lt;code&gt;$text&lt;/code&gt;
     * @throws \InvalidArgumentException if the document is not valid
     */
    protected function createDocument($text)
    {
        $document = new \DOMDocument();
        if (preg_match('/^\s*&lt;\?xml/', $text)) {
            if (!@$document-&gt;loadXML($text)) {
                throw new \InvalidArgumentException('Must pass a valid XML document');
            }
        } else {
            if (!@$document-&gt;loadHTML($text)) {
                throw new \InvalidArgumentException('Must pass a valid HTML or XHTML document');
            }
        }

        return $document;
    }

    /**
     * Applies the configured XPath to the DOM node and returns either
     * the result if it's an expression or the node list if it's a query.
     *
     * @param \DOMNode $node context from which to issue query
     * @return mixed result of expression or DOMNodeList from query
     */
    protected function evaluate(\DOMNode $node)
    {
        if ($node instanceof \DOMDocument) {
            $xpathDocument = new \DOMXPath($node);

            return $xpathDocument-&gt;evaluate($this-&gt;_xpath);
        } else {
            $xpathDocument = new \DOMXPath($node-&gt;ownerDocument);

            return $xpathDocument-&gt;evaluate($this-&gt;_xpath, $node);
        }
    }

    /**
     * Matches if the list of nodes is not empty and the content of at least
     * one node matches the configured matcher, if supplied.
     *
     * @param \DOMNodeList $nodes selected by the XPath query
     * @param Description $mismatchDescription
     * @return bool
     */
    protected function matchesContent(\DOMNodeList $nodes, Description $mismatchDescription)
    {
        if ($nodes-&gt;length == 0) {
            $mismatchDescription-&gt;appendText('XPath returned no results');
        } elseif ($this-&gt;_matcher === null) {
            return true;
        } else {
            foreach ($nodes as $node) {
                if ($this-&gt;_matcher-&gt;matches($node-&gt;textContent)) {
                    return true;
                }
            }
            $content = array();
            foreach ($nodes as $node) {
                $content[] = $node-&gt;textContent;
            }
            $mismatchDescription-&gt;appendText('XPath returned ')
                                                    -&gt;appendValue($content);
        }

        return false;
    }

    /**
     * Matches if the result of the XPath expression matches the configured
     * matcher or evaluates to &lt;code&gt;true&lt;/code&gt; if there is none.
     *
     * @param mixed $result result of the XPath expression
     * @param Description $mismatchDescription
     * @return bool
     */
    protected function matchesExpression($result, Description $mismatchDescription)
    {
        if ($this-&gt;_matcher === null) {
            if ($result) {
                return true;
            }
            $mismatchDescription-&gt;appendText('XPath expression result was ')
                                                    -&gt;appendValue($result);
        } else {
            if ($this-&gt;_matcher-&gt;matches($result)) {
                return true;
            }
            $mismatchDescription-&gt;appendText('XPath expression result ');
            $this-&gt;_matcher-&gt;describeMismatch($result, $mismatchDescription);
        }

        return false;
    }

    public function describeTo(Description $description)
    {
        $description-&gt;appendText('XML or HTML document with XPath &quot;')
                                -&gt;appendText($this-&gt;_xpath)
                                -&gt;appendText('&quot;');
        if ($this-&gt;_matcher !== null) {
            $description-&gt;appendText(' ');
            $this-&gt;_matcher-&gt;describeTo($description);
        }
    }

    /**
     * Wraps &lt;code&gt;$matcher&lt;/code&gt; with {@link Hamcrest\Core\IsEqual)
     * if it's not a matcher and the XPath in &lt;code&gt;count()&lt;/code&gt;
     * if it's an integer.
     *
     * @factory
     */
    public static function hasXPath($xpath, $matcher = null)
    {
        if ($matcher === null || $matcher instanceof Matcher) {
            return new self($xpath, $matcher);
        } elseif (is_int($matcher) &amp;&amp; strpos($xpath, 'count(') !== 0) {
            $xpath = 'count(' . $xpath . ')';
        }

        return new self($xpath, IsEqual::equalTo($matcher));
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>