CPD Results

}
        final NodeIterator it = attributeIterator(qName);
        it.setPosition(1);
        return it.getNodePointer();
    }

    @Override
    public NodePointer createChild(final JXPathContext context, final QName qName, int index) {
        if (index == WHOLE_COLLECTION) {
            index = 0;
        }
        final boolean success = getAbstractFactory(context).createObject(context, this, node, qName.toString(), index);
        if (success) {
            NodeTest nodeTest;
            final String prefix = qName.getPrefix();
            final String namespaceURI = prefix == null ? null : context.getNamespaceURI(prefix);
            nodeTest = new NodeNameTest(qName, namespaceURI);
            final NodeIterator it = childIterator(nodeTest, false, null);
            if (it != null && it.setPosition(index + 1)) {
                return it.getNodePointer();
            }
        }
        throw new JXPathAbstractFactoryException("Factory could not create a child node for path: " + asPath() + "/" + qName + "[" + (index + 1) + "]");
    }

    @Override
    public NodePointer createChild(final JXPathContext context, final QName qName, final int index, final Object value) {
        final NodePointer ptr = createChild(context, qName, index);
        ptr.setValue(value);
        return ptr;
    }

    @Override
    public boolean equals(final Object object) {

public NamespacePointer(final NodePointer parent, final String prefix, final String namespaceURI) {
        super(parent);
        this.prefix = prefix;
        this.namespaceURI = namespaceURI;
    }

    @Override
    public String asPath() {
        final StringBuilder buffer = new StringBuilder();
        if (parent != null) {
            buffer.append(parent.asPath());
            if (buffer.length() == 0 || buffer.charAt(buffer.length() - 1) != '/') {
                buffer.append('/');
            }
        }
        buffer.append("namespace::");
        buffer.append(prefix);
        return buffer.toString();
    }

    @Override
    public int compareChildNodePointers(final NodePointer pointer1, final NodePointer pointer2) {
        // Won't happen - namespaces don't have children
        return 0;
    }

    @Override
    public boolean equals(final Object object) {

return prefix.equals(other.prefix);
    }

    @Override
    public Object getBaseValue() {
        return null;
    }

    @Override
    public Object getImmediateNode() {
        return getNamespaceURI();
    }

    @Override
    public int getLength() {
        return 1;
    }

    @Override
    public QName getName() {
        return new QName(prefix);
    }

    @Override
    public String getNamespaceURI() {
        if (namespaceURI == null) {
            namespaceURI = parent.getNamespaceURI(prefix);
        }
        return namespaceURI;
    }

    @Override
    public int hashCode() {
        return prefix.hashCode();
    }

    @Override
    public boolean isCollection() {
        return false;
    }

    @Override
    public boolean isLeaf() {
        return true;
    }

    /**
     * Throws UnsupportedOperationException.
     *
     * @param value Object
     */
    @Override
    public void setValue(final Object value) {
        throw new UnsupportedOperationException("Cannot modify DOM trees");

}

    @Override
    public String asPath() {
        final StringBuilder buffer = new StringBuilder();
        if (parent != null) {
            buffer.append(parent.asPath());
            if (buffer.length() == 0 || buffer.charAt(buffer.length() - 1) != '/') {
                buffer.append('/');
            }
        }
        buffer.append('@');
        buffer.append(getName());
        return buffer.toString();
    }

    @Override
    public int compareChildNodePointers(final NodePointer pointer1, final NodePointer pointer2) {
        // Won't happen - attributes don't have children
        return 0;
    }

    @Override
    public boolean equals(final Object object) {
        return object == this || object instanceof DOMAttributePointer && attr == ((DOMAttributePointer) object).attr;

if (node.getNodeType() != Node.ELEMENT_NODE) {
                return false;
            }
            final NodeNameTest nodeNameTest = (NodeNameTest) test;
            final QName testName = nodeNameTest.getNodeName();
            final String namespaceURI = nodeNameTest.getNamespaceURI();
            final boolean wildcard = nodeNameTest.isWildcard();
            final String testPrefix = testName.getPrefix();
            if (wildcard && testPrefix == null) {
                return true;
            }
            if (wildcard || testName.getName().equals(getLocalName(node))) {
                final String nodeNS = getNamespaceURI(node);
                return equalStrings(namespaceURI, nodeNS) || nodeNS == null && equalStrings(testPrefix, getPrefix(node));
            }
            return false;
        }
        if (test instanceof NodeTypeTest) {

final String nsURI = getNamespaceURI();
                if (nsURI == null) {
                    buffer.append(ln);
                    buffer.append('[');
                    buffer.append(getRelativePositionByQName()).append(']');
                } else {
                    final String prefix = getNamespaceResolver().getPrefix(nsURI);
                    if (prefix != null) {
                        buffer.append(prefix);
                        buffer.append(':');
                        buffer.append(ln);
                        buffer.append('[');
                        buffer.append(getRelativePositionByQName());
                    } else {
                        buffer.append("node()");
                        buffer.append('[');
                        buffer.append(getRelativePositionOfElement());
                    }
                    buffer.append(']');
                }
            }

iterator = parentContext.getCurrentNodePointer().attributeIterator(qName);
        }
        if (iterator == null) {
            return false;
        }
        if (!iterator.setPosition(iterator.getPosition() + 1)) {
            return false;
        }
        currentNodePointer = iterator.getNodePointer();
        return true;
    }

    @Override
    public void reset() {
        setStarted = false;
        iterator = null;
        super.reset();
    }

    @Override
    public boolean setPosition(final int position) {
        if (position < getCurrentPosition()) {
            reset();
        }
        while (getCurrentPosition() < position) {
            if (!nextNode()) {
                return false;
            }
        }
        return true;
    }
}