下面列出了怎么用org.w3c.dom.Attr的API类实例代码及写法,或者点击链接到github查看源代码。
/** {@inheritDoc} */
protected void processAttribute(XMLObject samlObject, Attr attribute) throws UnmarshallingException {
EntitiesDescriptor entitiesDescriptor = (EntitiesDescriptor) samlObject;
if (attribute.getLocalName().equals(EntitiesDescriptor.ID_ATTRIB_NAME)) {
entitiesDescriptor.setID(attribute.getValue());
attribute.getOwnerElement().setIdAttributeNode(attribute, true);
} else if (attribute.getLocalName().equals(TimeBoundSAMLObject.VALID_UNTIL_ATTRIB_NAME)
&& !DatatypeHelper.isEmpty(attribute.getValue())) {
entitiesDescriptor.setValidUntil(new DateTime(attribute.getValue(), ISOChronology.getInstanceUTC()));
} else if (attribute.getLocalName().equals(CacheableSAMLObject.CACHE_DURATION_ATTRIB_NAME)) {
entitiesDescriptor.setCacheDuration(new Long(XMLHelper.durationToLong(attribute.getValue())));
} else if (attribute.getLocalName().equals(EntitiesDescriptor.NAME_ATTRIB_NAME)) {
entitiesDescriptor.setName(attribute.getValue());
} else {
super.processAttribute(samlObject, attribute);
}
}
protected Attr createAttrNode (QName attrQName) {
Attr attr = null;
if (fNamespaceAware) {
if (fDocumentImpl != null) {
// if we are using xerces DOM implementation, call our
// own constructor to reuse the strings we have here.
attr = fDocumentImpl.createAttributeNS (attrQName.uri,
attrQName.rawname,
attrQName.localpart);
}
else {
attr = fDocument.createAttributeNS (attrQName.uri,
attrQName.rawname);
}
}
else {
attr = fDocument.createAttribute (attrQName.rawname);
}
return attr;
}
@Override
public void visitAttribute(@NonNull XmlContext context, @NonNull Attr attribute) {
String value = attribute.getValue();
if (!value.isEmpty()) {
// Make sure this is really one of the android: attributes
if (!ANDROID_URI.equals(attribute.getNamespaceURI())) {
return;
}
value = value.substring(5); // ignore "@+id/"
if (!idCorrectFormat(value)) {
context.report(ISSUE, attribute, context.getLocation(attribute),
String.format("The id \"%1$s\", should be written using lowerCamelCase.", value));
}
}
}
/**
* Constructor SignatureAlgorithm
*
* @param element
* @param baseURI
* @param secureValidation
* @throws XMLSecurityException
*/
public SignatureAlgorithm(
Element element, String baseURI, boolean secureValidation
) throws XMLSecurityException {
super(element, baseURI);
algorithmURI = this.getURI();
Attr attr = element.getAttributeNodeNS(null, "Id");
if (attr != null) {
element.setIdAttributeNode(attr, true);
}
if (secureValidation && (XMLSignature.ALGO_ID_MAC_HMAC_NOT_RECOMMENDED_MD5.equals(algorithmURI)
|| XMLSignature.ALGO_ID_SIGNATURE_NOT_RECOMMENDED_RSA_MD5.equals(algorithmURI))) {
Object exArgs[] = { algorithmURI };
throw new XMLSecurityException("signature.signatureAlgorithm", exArgs);
}
signatureAlgorithm = getSignatureAlgorithmSpi(algorithmURI);
signatureAlgorithm.engineGetContextFromElement(this.constructionElement);
}
public static void test2() {
String name = "attr";
String oldValue = "old value";
String newValue = "new value";
Attr retAttr;
IIOMetadataNode parent = new IIOMetadataNode("parent");
MyAttrNode attrNode1 = new MyAttrNode(name, oldValue);
MyAttrNode attrNode2 = new MyAttrNode(name, newValue);
retAttr = parent.setAttributeNode(attrNode1);
retAttr = parent.setAttributeNode(attrNode2);
String actName = retAttr.getNodeName();
String actValue = retAttr.getValue();
if (!actName.equals(name) || !actValue.equals(oldValue)) {
throw new RuntimeException("Test 2 failed: Invalid attribute " +
"returned: " +
"(name: " + actName +
", value: " + actValue + ")");
}
}
/**
* Gets the attribute node that defines the binding for the prefix.
* @param prefix the prefix to obtain the attribute.
* @return null if there is no need to render the prefix. Otherwise the node of
* definition.
**/
public Attr getMapping(String prefix) {
NameSpaceSymbEntry entry = symb.get(prefix);
if (entry == null) {
//There is no definition for the prefix(a bug?).
return null;
}
if (entry.rendered) {
//No need to render an entry already rendered.
return null;
}
// Mark this entry as render.
entry = (NameSpaceSymbEntry) entry.clone();
needsClone();
symb.put(prefix, entry);
entry.rendered = true;
entry.lastrendered = entry.uri;
// Return the node for outputing.
return entry.n;
}
public Attr setAttributeNode(Attr newAttr) throws DOMException {
AttrImpl newAttrImpl = (AttrImpl) newAttr;
if (newAttrImpl.document != this.document) {
throw new DOMException(DOMException.WRONG_DOCUMENT_ERR, null);
}
if (newAttrImpl.getOwnerElement() != null) {
throw new DOMException(DOMException.INUSE_ATTRIBUTE_ERR, null);
}
AttrImpl oldAttrImpl = null;
int i = indexOfAttribute(newAttr.getName());
if (i != -1) {
oldAttrImpl = attributes.get(i);
attributes.remove(i);
}
attributes.add(newAttrImpl);
newAttrImpl.ownerElement = this;
return oldAttrImpl;
}
private Element createElement( Document document, String name, Object bean )
throws IntrospectionException, InvocationTargetException, NoSuchMethodException, IllegalAccessException {
Element element = document.createElement( name );
BeanInfo beanInfo = Introspector.getBeanInfo( bean.getClass(), Object.class );
for( PropertyDescriptor propInfo: beanInfo.getPropertyDescriptors() ) {
String propName = propInfo.getName();
if( propInfo.getReadMethod() != null && String.class.isAssignableFrom( propInfo.getPropertyType() ) ) {
String propValue = BeanUtils.getProperty( bean, propName );
if( propValue != null && !propValue.isEmpty() ) {
// Doing it the hard way to avoid having the &'s in the query string escaped at &
Attr attr = document.createAttribute( propName );
attr.setValue( propValue );
element.setAttributeNode( attr );
//element.setAttribute( propName, propValue );
}
}
}
return element;
}
/**
* Constructs {@link SignatureProperties} from {@link Element}
* @param element <code>SignatureProperties</code> element
* @param BaseURI the URI of the resource where the XML instance was stored
* @throws XMLSecurityException
*/
public SignatureProperties(Element element, String BaseURI) throws XMLSecurityException {
super(element, BaseURI);
Attr attr = element.getAttributeNodeNS(null, "Id");
if (attr != null) {
element.setIdAttributeNode(attr, true);
}
int length = getLength();
for (int i = 0; i < length; i++) {
Element propertyElem =
XMLUtils.selectDsNode(this.constructionElement, Constants._TAG_SIGNATUREPROPERTY, i);
Attr propertyAttr = propertyElem.getAttributeNodeNS(null, "Id");
if (propertyAttr != null) {
propertyElem.setIdAttributeNode(propertyAttr, true);
}
}
}
private void addNamespaces(Namespaces rv, Element element) {
if (element == null) throw new RuntimeException("element must not be null");
String myDefaultNamespace = toUri(element.lookupNamespaceURI(null));
String parentDefaultNamespace = "";
if (element.getParentNode() != null) {
parentDefaultNamespace = toUri(element.getParentNode().lookupNamespaceURI(null));
}
if (!myDefaultNamespace.equals(parentDefaultNamespace) || !(element.getParentNode() instanceof Element) ) {
rv.declare(Namespace.create("", myDefaultNamespace));
}
NamedNodeMap attributes = element.getAttributes();
for (int i=0; i<attributes.getLength(); i++) {
Attr attr = (Attr)attributes.item(i);
if (attr.getPrefix() != null && attr.getPrefix().equals("xmlns")) {
rv.declare(Namespace.create(attr.getLocalName(), attr.getValue()));
}
}
}
/** {@inheritDoc} */
protected void processAttribute(XMLObject samlObject, Attr attribute) throws UnmarshallingException {
ContactPerson person = (ContactPerson) samlObject;
if (attribute.getLocalName().equals(ContactPerson.CONTACT_TYPE_ATTRIB_NAME)) {
if (ContactPersonTypeEnumeration.TECHNICAL.toString().equals(attribute.getValue())) {
person.setType(ContactPersonTypeEnumeration.TECHNICAL);
} else if (ContactPersonTypeEnumeration.SUPPORT.toString().equals(attribute.getValue())) {
person.setType(ContactPersonTypeEnumeration.SUPPORT);
} else if (ContactPersonTypeEnumeration.ADMINISTRATIVE.toString().equals(attribute.getValue())) {
person.setType(ContactPersonTypeEnumeration.ADMINISTRATIVE);
} else if (ContactPersonTypeEnumeration.BILLING.toString().equals(attribute.getValue())) {
person.setType(ContactPersonTypeEnumeration.BILLING);
} else if (ContactPersonTypeEnumeration.OTHER.toString().equals(attribute.getValue())) {
person.setType(ContactPersonTypeEnumeration.OTHER);
} else {
super.processAttribute(samlObject, attribute);
}
} else {
QName attribQName = XMLHelper.getNodeQName(attribute);
if (attribute.isId()) {
person.getUnknownAttributes().registerID(attribQName);
}
person.getUnknownAttributes().put(attribQName, attribute.getValue());
}
}
/**
* This method throws an exception if the Attribute value contains
* a relative URI.
*
* @param attr
* @throws CanonicalizationException
*/
public static void assertNotRelativeNS(Attr attr) throws CanonicalizationException {
if (attr == null) {
return;
}
String nodeAttrName = attr.getNodeName();
boolean definesDefaultNS = nodeAttrName.equals("xmlns");
boolean definesNonDefaultNS = nodeAttrName.startsWith("xmlns:");
if ((definesDefaultNS || definesNonDefaultNS) && namespaceIsRelative(attr)) {
String parentName = attr.getOwnerElement().getTagName();
String attrValue = attr.getValue();
Object exArgs[] = { parentName, nodeAttrName, attrValue };
throw new CanonicalizationException(
"c14n.Canonicalizer.RelativeNamespace", exArgs
);
}
}
/** {@inheritDoc} */
protected void processAttribute(XMLObject samlObject, Attr attribute) throws UnmarshallingException {
AuthorizationDecisionStatement authorizationDecisionStatement;
authorizationDecisionStatement = (AuthorizationDecisionStatement) samlObject;
if (AuthorizationDecisionStatement.DECISION_ATTRIB_NAME.equals(attribute.getLocalName())) {
String value = attribute.getValue();
if (value.equals(DecisionTypeEnumeration.PERMIT.toString())) {
authorizationDecisionStatement.setDecision(DecisionTypeEnumeration.PERMIT);
} else if (value.equals(DecisionTypeEnumeration.DENY.toString())) {
authorizationDecisionStatement.setDecision(DecisionTypeEnumeration.DENY);
} else if (value.equals(DecisionTypeEnumeration.INDETERMINATE.toString())) {
authorizationDecisionStatement.setDecision(DecisionTypeEnumeration.INDETERMINATE);
} else {
log.error("Unknown value for DecisionType '" + value + "'");
throw new UnmarshallingException("Unknown value for DecisionType '" + value + "'");
}
} else if (AuthorizationDecisionStatement.RESOURCE_ATTRIB_NAME.equals(attribute.getLocalName())) {
authorizationDecisionStatement.setResource(attribute.getValue());
} else {
super.processAttribute(samlObject, attribute);
}
}
/**
* Converts the given {@link Node} to a {@link String}.
*/
public static String nodeToString(Node node)
{
StringWriter sw = new StringWriter();
if (node instanceof Attr)
{
Attr attr = (Attr) node;
return attr.getValue();
}
try
{
Transformer t = TransformerFactory.newInstance().newTransformer();
t.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
t.setOutputProperty(OutputKeys.INDENT, "no");
t.transform(new DOMSource(node), new StreamResult(sw));
}
catch (TransformerException te)
{
LOG.warning("Transformer Exception: " + te.getMessage());
}
return sw.toString();
}
private static CombineChildren getCombineChildren(@Nullable Element element) {
CombineChildren combine = null;
if (element == null) {
return null;
}
Attr combineAttribute = element.getAttributeNode(CombineChildren.ATTRIBUTE_NAME);
if (combineAttribute != null) {
try {
combine = CombineChildren.valueOf(combineAttribute.getValue().toUpperCase());
} catch (IllegalArgumentException e) {
throw new RuntimeException("The attribute 'combine' of element '"
+ element.getTagName() + "' has invalid value '"
+ combineAttribute.getValue(), e);
}
}
return combine;
}
/**
* Declares a new prefix on the given element and associates it
* with the specified namespace URI.
* <p>
* Note that this method doesn't use the default namespace
* even if it can.
*/
private String allocatePrefix( Element e, String nsUri ) {
// look for existing namespaces.
NamedNodeMap atts = e.getAttributes();
for( int i=0; i<atts.getLength(); i++ ) {
Attr a = (Attr)atts.item(i);
if( Const.XMLNS_URI.equals(a.getNamespaceURI()) ) {
if( a.getName().indexOf(':')==-1 ) continue;
if( a.getValue().equals(nsUri) )
return a.getLocalName(); // found one
}
}
// none found. allocate new.
while(true) {
String prefix = "p"+(int)(Math.random()*1000000)+'_';
if(e.getAttributeNodeNS(Const.XMLNS_URI,prefix)!=null)
continue; // this prefix is already allocated.
e.setAttributeNS(Const.XMLNS_URI,"xmlns:"+prefix,nsUri);
return prefix;
}
}
/**
* This method returns the first non-null owner document of the Nodes in this Set.
* This method is necessary because it <I>always</I> returns a
* {@link Document}. {@link Node#getOwnerDocument} returns <CODE>null</CODE>
* if the {@link Node} is a {@link Document}.
*
* @param xpathNodeSet
* @return the owner document
*/
public static Document getOwnerDocument(Set<Node> xpathNodeSet) {
NullPointerException npe = null;
for (Node node : xpathNodeSet) {
int nodeType = node.getNodeType();
if (nodeType == Node.DOCUMENT_NODE) {
return (Document) node;
}
try {
if (nodeType == Node.ATTRIBUTE_NODE) {
return ((Attr)node).getOwnerElement().getOwnerDocument();
}
return node.getOwnerDocument();
} catch (NullPointerException e) {
npe = e;
}
}
throw new NullPointerException(I18n.translate("endorsed.jdk1.4.0")
+ " Original message was \""
+ (npe == null ? "" : npe.getMessage()) + "\"");
}
/**
* Look up a single Attribute by name. Returns the Attribute's
* string value, or an empty string (NOT null!) to indicate that the
* name did not map to a currently defined attribute.
* <p>
* Note: Attributes may contain complex node trees. This method
* returns the "flattened" string obtained from Attribute.getValue().
* If you need the structure information, see getAttributeNode().
*/
public String getAttribute(String name) {
if (needsSyncData()) {
synchronizeData();
}
if (attributes == null) {
return "";
}
Attr attr = (Attr)(attributes.getNamedItem(name));
return (attr == null) ? "" : attr.getValue();
}
/**
* Creates a DOM Atrribute @see org.w3c.dom.Node and associates it with the current DOM element @see org.w3c.dom.Node.
* @param namespaceURI {@inheritDoc}
* @param localName {@inheritDoc}
* @param value {@inheritDoc}
* @throws javax.xml.stream.XMLStreamException {@inheritDoc}
*/
public void writeAttribute(String namespaceURI,String localName,String value)throws XMLStreamException {
if(currentNode.getNodeType() == Node.ELEMENT_NODE){
String prefix = null;
if(namespaceURI == null ){
throw new XMLStreamException("NamespaceURI cannot be null");
}
if(localName == null){
throw new XMLStreamException("Local name cannot be null");
}
if(namespaceContext != null){
prefix = namespaceContext.getPrefix(namespaceURI);
}
if(prefix == null){
throw new XMLStreamException("Namespace URI "+namespaceURI +
"is not bound to any prefix" );
}
String qualifiedName = null;
if(prefix.equals("")){
qualifiedName = localName;
}else{
qualifiedName = getQName(prefix,localName);
}
Attr attr = ownerDoc.createAttributeNS(namespaceURI, qualifiedName);
attr.setValue(value);
((Element)currentNode).setAttributeNode(attr);
}else{
//Convert node type to String
throw new IllegalStateException("Current DOM Node type is "+ currentNode.getNodeType() +
"and does not allow attributes to be set ");
}
}
/**
* Creates a DOM Atrribute @see org.w3c.dom.Node and associates it with the current DOM element @see org.w3c.dom.Node.
* @param localName {@inheritDoc}
* @param value {@inheritDoc}
* @throws javax.xml.stream.XMLStreamException {@inheritDoc}
*/
public void writeAttribute(String localName, String value) throws XMLStreamException {
if(currentNode.getNodeType() == Node.ELEMENT_NODE){
Attr attr = ownerDoc.createAttribute(localName);
attr.setValue(value);
((Element)currentNode).setAttributeNode(attr);
}else{
//Convert node type to String
throw new IllegalStateException("Current DOM Node type is "+ currentNode.getNodeType() +
"and does not allow attributes to be set ");
}
}
/**
* This method is not particularly fast, but shouldn't be called very
* often. If we start to use it more, we should keep track of the
* NS declarations using a NamespaceContext implementation instead.
*/
public String getNamespaceURI(String prefix) {
if (prefix == null) {
throw new IllegalArgumentException("DOMStreamReader: getNamespaceURI(String) call with a null prefix");
}
else if (prefix.equals("xml")) {
return "http://www.w3.org/XML/1998/namespace";
}
else if (prefix.equals("xmlns")) {
return "http://www.w3.org/2000/xmlns/";
}
// check scopes
String nsUri = scopes[depth].getNamespaceURI(prefix);
if(nsUri!=null) return nsUri;
// then ancestors above start node
Node node = findRootElement();
String nsDeclName = prefix.length()==0 ? "xmlns" : "xmlns:"+prefix;
while (node.getNodeType() != DOCUMENT_NODE) {
// Is ns declaration on this element?
NamedNodeMap namedNodeMap = node.getAttributes();
Attr attr = (Attr) namedNodeMap.getNamedItem(nsDeclName);
if (attr != null)
return attr.getValue();
node = node.getParentNode();
}
return null;
}
/**
* Called when the current node is {@link Element} to look at attribute list
* (which contains both ns decl and attributes in DOM) and split them
* to attributes-proper and namespace decls.
*/
protected void splitAttributes() {
// Clear attribute and namespace lists
_currentAttributes.clear();
Scope scope = allocateScope();
_namedNodeMap = _current.getAttributes();
if (_namedNodeMap != null) {
final int n = _namedNodeMap.getLength();
for (int i = 0; i < n; i++) {
final Attr attr = (Attr) _namedNodeMap.item(i);
final String attrName = attr.getNodeName();
if (attrName.startsWith("xmlns:") || attrName.equals("xmlns")) { // NS decl?
scope.currentNamespaces.add(attr);
}
else {
_currentAttributes.add(attr);
}
}
}
// verify that all the namespaces used in element and attributes are indeed available
ensureNs(_current);
for( int i=_currentAttributes.size()-1; i>=0; i-- ) {
Attr a = _currentAttributes.get(i);
if(fixNull(a.getNamespaceURI()).length()>0)
ensureNs(a); // no need to declare "" for attributes in the default namespace
}
}
void getXmlnsAttr(Collection<Attr> col) {
int size = levels.size() - 1;
if (cur == null) {
cur = new XmlsStackElement();
cur.level = currentLevel;
lastlevel = currentLevel;
levels.add(cur);
}
boolean parentRendered = false;
XmlsStackElement e = null;
if (size == -1) {
parentRendered = true;
} else {
e = levels.get(size);
if (e.rendered && e.level + 1 == currentLevel) {
parentRendered = true;
}
}
if (parentRendered) {
col.addAll(cur.nodes);
cur.rendered = true;
return;
}
Map<String, Attr> loa = new HashMap<String, Attr>();
for (; size >= 0; size--) {
e = levels.get(size);
Iterator<Attr> it = e.nodes.iterator();
while (it.hasNext()) {
Attr n = it.next();
if (!loa.containsKey(n.getName())) {
loa.put(n.getName(), n);
}
}
}
cur.rendered = true;
col.addAll(loa.values());
}
private static void appendAttr(Document doc, Node node, String name, String value, boolean force) {
if(force || (name != null && name.length() > 0)) {
Attr attr = doc.createAttribute(name);
attr.setValue(value);
NamedNodeMap attrs = node.getAttributes();
attrs.setNamedItem(attr);
}
}
/**
* Add a new name/value pair, or replace the value of the existing
* attribute having that name.
*
* Note: this method supports only the simplest kind of Attribute,
* one whose value is a string contained in a single Text node.
* If you want to assert a more complex value (which XML permits,
* though HTML doesn't), see setAttributeNode().
*
* The attribute is created with specified=true, meaning it's an
* explicit value rather than inherited from the DTD as a default.
* Again, setAttributeNode can be used to achieve other results.
*
* @throws DOMException(INVALID_NAME_ERR) if the name is not acceptable.
* (Attribute factory will do that test for us.)
*
* @throws DOMException(NO_MODIFICATION_ALLOWED_ERR) if the node is
* readonly.
*/
public void setAttribute(String name, String value) {
if (ownerDocument.errorChecking && isReadOnly()) {
String msg =
DOMMessageFormatter.formatMessage(
DOMMessageFormatter.DOM_DOMAIN,
"NO_MODIFICATION_ALLOWED_ERR",
null);
throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR, msg);
}
if (needsSyncData()) {
synchronizeData();
}
Attr newAttr = getAttributeNode(name);
if (newAttr == null) {
newAttr = getOwnerDocument().createAttribute(name);
if (attributes == null) {
attributes = new AttributeMap(this, null);
}
newAttr.setNodeValue(value);
attributes.setNamedItem(newAttr);
}
else {
newAttr.setNodeValue(value);
}
}
/**
* @param attributes the attributes
* @return the attr list
*/
static AttrList create(final NamedNodeMap attributes) {
final int l = attributes.getLength();
final List<Attr> as = new ArrayList<Attr>(l);
for (int i = 0; i < l; i++) {
as.add((Attr) attributes.item(i));
}
return new AttrList(as);
}
private void addNamespaces(Node element) {
if (element.getParentNode() != null) {
addNamespaces(element.getParentNode());
}
if (element instanceof Element) {
Element el = (Element)element;
NamedNodeMap map = el.getAttributes();
for (int x = 0; x < map.getLength(); x++) {
Attr attr = (Attr)map.item(x);
if ("xmlns".equals(attr.getPrefix())) {
namespaceMap.put(attr.getLocalName(), attr.getValue());
}
}
}
}
/** {@inheritDoc} */
protected void processAttribute(XMLObject xmlObject, Attr attribute) throws UnmarshallingException {
SignatureConfirmation sc = (SignatureConfirmation) xmlObject;
QName attrName =
XMLHelper.constructQName(attribute.getNamespaceURI(), attribute.getLocalName(), attribute.getPrefix());
if (SignatureConfirmation.WSU_ID_ATTR_NAME.equals(attrName)) {
sc.setWSUId(attribute.getValue());
attribute.getOwnerElement().setIdAttributeNode(attribute, true);
} else if (SignatureConfirmation.VALUE_ATTRIB_NAME.equals(attribute.getLocalName())) {
sc.setValue(attribute.getValue());
} else {
super.processAttribute(xmlObject, attribute);
}
}
@Test
public void testSetNamedItemNS() throws Exception {
final String nsURI = "urn:BooksAreUs.org:BookInfo";
Document document = createDOMWithNS("NamedNodeMap01.xml");
NodeList nodeList = document.getElementsByTagName("body");
nodeList = nodeList.item(0).getChildNodes();
Node n = nodeList.item(3);
NamedNodeMap namedNodeMap = n.getAttributes();
// creating an Attribute using createAttributeNS
// method having the same namespaceURI
// and the same qualified name as the existing one in the xml file
Attr attr = document.createAttributeNS(nsURI, "b:style");
// setting to a new Value
attr.setValue("newValue");
Node replacedAttr = namedNodeMap.setNamedItemNS(attr); // return the replaced attr
assertEquals(replacedAttr.getNodeValue(), "font-family");
Node updatedAttr = namedNodeMap.getNamedItemNS(nsURI, "style");
assertEquals(updatedAttr.getNodeValue(), "newValue");
// creating a non existing attribute node
attr = document.createAttributeNS(nsURI, "b:newNode");
attr.setValue("newValue");
assertNull(namedNodeMap.setNamedItemNS(attr)); // return null
// checking if the node could be accessed
// using the getNamedItemNS method
Node newAttr = namedNodeMap.getNamedItemNS(nsURI, "newNode");
assertEquals(newAttr.getNodeValue(), "newValue");
}
public Attr getAttributeNodeNS(String namespaceURI, String localName) {
for (int i=0; i<attrs.length; i++) {
if (attrs[i].getName().equals(localName) && nsEquals(attrs[i].getNamespaceURI(), namespaceURI)) {
return attrs[i];
}
}
return null;
}