import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
@Override
public Object getProperty(String name)
{
    /* 18-Nov-2008, TSa: As per [WSTX-50], should report the
     *   actual Base URL. It can be overridden by matching
     *   setProperty, but if not, is set to actual source
     *   of content being parsed.
     */
    if (WstxInputProperties.P_BASE_URL.equals(name)) {
    	try {
    		return mInput.getSource();
    	} catch (IOException e) { // not optimal but...
    		throw new IllegalStateException(e);
    	}
    }
    /* 23-Apr-2008, TSa: Let's NOT throw IllegalArgumentException
     *   for unknown property; JavaDocs do not suggest it needs
     *   to be done (different from that of XMLInputFactory
     *   and XMLStreamWriter specification)
     */
    return mConfig.safeGetProperty(name);
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
public void testLongElementText() throws Exception {
    try {
        Reader reader = createLongReader("", "", false);
        XMLInputFactory factory = getNewInputFactory();
        factory.setProperty(WstxInputProperties.P_MAX_TEXT_LENGTH, Integer.valueOf(100000));
        XMLStreamReader xmlreader = factory.createXMLStreamReader(reader);
        while (xmlreader.next() != XMLStreamReader.START_ELEMENT) {
        }
        assertEquals(XMLStreamReader.CHARACTERS, xmlreader.next());
        while (xmlreader.next() != XMLStreamReader.START_ELEMENT) {
        }
        fail("Should have failed");
    } catch (XMLStreamException ex) {
        _verifyTextLimitException(ex);
    }
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
public void testLongWhitespace() throws Exception {
    try {
        Reader reader = createLongReader("", "", true);
        XMLInputFactory factory = getNewInputFactory();
        factory.setProperty(WstxInputProperties.P_MAX_TEXT_LENGTH, Integer.valueOf(50000));
        XMLStreamReader xmlreader = factory.createXMLStreamReader(reader);
        while (xmlreader.next() != XMLStreamReader.START_ELEMENT) {
        }
        assertEquals(XMLStreamReader.CHARACTERS, xmlreader.next());
        while (xmlreader.next() != XMLStreamReader.START_ELEMENT) {
        }
        fail("Should have failed");
    } catch (XMLStreamException ex) {
        _verifyTextLimitException(ex);
    }
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
public void testLongCDATA() throws Exception {
    try {
        Reader reader = createLongReader("<![CDATA[", "]]>", true);
        XMLInputFactory factory = getNewInputFactory();
        factory.setProperty(WstxInputProperties.P_MAX_TEXT_LENGTH, Integer.valueOf(50000));
        XMLStreamReader xmlreader = factory.createXMLStreamReader(reader);
        while (xmlreader.next() != XMLStreamReader.START_ELEMENT) {
        }
        assertEquals(XMLStreamReader.CDATA, xmlreader.next());
        while (xmlreader.next() != XMLStreamReader.START_ELEMENT) {
        }
        fail("Should have failed");
    } catch (XMLStreamException ex) {
        _verifyTextLimitException(ex);
    }
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
public void testLongCDATANextTag() throws Exception {
    Reader reader = createLongReader("<![CDATA[", "]]>", true);
    XMLInputFactory factory = getNewInputFactory();
    factory.setProperty(WstxInputProperties.P_MAX_TEXT_LENGTH, Integer.valueOf(1000));
    XMLStreamReader xmlreader = factory.createXMLStreamReader(reader);
    try {
        int tokens = 0;
        while (xmlreader.next() != XMLStreamReader.START_ELEMENT) {
            ++tokens;
        }
        int code = xmlreader.nextTag();
        fail("Should have failed: instead got "+tokens+" tokens; and one following START_ELEMENT: "+code);
    } catch (XMLStreamException ex) {
        _verifyTextLimitException(ex);
    }
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
public void testSingleDocumentMode()
    throws XMLStreamException
{
    // First the valid case:
    streamThrough(getReader(XML_SINGLE_DOC,
                            WstxInputProperties.PARSING_MODE_DOCUMENT));

    // Others will fail though
    streamThroughFailing(getReader(XML_FRAGMENT,
                                   WstxInputProperties.PARSING_MODE_DOCUMENT),
                         "Expected an exception for fragment (non-single root) input, in single-document mode");
    streamThroughFailing(getReader(XML_FRAGMENT2,
                                   WstxInputProperties.PARSING_MODE_DOCUMENT),
                         "Expected an exception for fragment (root-level text) input, in single-document mode");
    streamThroughFailing(getReader(XML_MULTI_DOC,
                                   WstxInputProperties.PARSING_MODE_DOCUMENT),
                         "Expected an exception for multi-document input, in single-document mode");


    // As should the generally invalid ones:
    streamThroughFailing(getReader(XML_UNBALANCED,
                                   WstxInputProperties.PARSING_MODE_DOCUMENT),
                         "Expected an exception for unbalanced xml content");
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
public void testDefaultNamespacePrefixAsNull() throws Exception
{
    String XML = "<blah xmlns=\"http://blah.org\"><foo>foo</foo></blah>";
    System.setProperty("com.ctc.wstx.returnNullForDefaultNamespace", "true");
    XMLInputFactory factory = getInputFactory();
    XMLStreamReader r = factory.createXMLStreamReader(new StringReader(XML));
    while (r.hasNext()) {
        r.next();
        if ((r.getEventType() == XMLEvent.START_ELEMENT) && (r.getLocalName().equals("blah"))) {
            String prefix = r.getNamespacePrefix(0);
            if (prefix != null) {
                throw new Exception("Null value is not returned for the default namespace prefix while "
                        + WstxInputProperties.P_RETURN_NULL_FOR_DEFAULT_NAMESPACE + " is set true");
            }
            break;
        }
    }
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
public void testDefaultNamespacePrefixAsEmptyString() throws Exception
{
    String XML = "<blah xmlns=\"http://blah.org\"><foo>foo</foo></blah>";
    System.setProperty("com.ctc.wstx.returnNullForDefaultNamespace", "false");
    XMLInputFactory factory = getInputFactory();
    XMLStreamReader r = factory.createXMLStreamReader(new StringReader(XML));
    while (r.hasNext()) {
        r.next();
        if ((r.getEventType() == XMLEvent.START_ELEMENT) && (r.getLocalName().equals("blah"))) {
            String prefix = r.getNamespacePrefix(0);
            if (!"".equals(prefix)) {
                throw new Exception("Null value is not returned for the default namespace prefix while "
                        + WstxInputProperties.P_RETURN_NULL_FOR_DEFAULT_NAMESPACE + " is set true");
            }
            break;
        }
    }
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
private static XMLInputFactory getOrCreateInputFactory() throws FactoryConfigurationError {
	if (ourInputFactory == null) {
		XMLInputFactory inputFactory = XMLInputFactory.newInstance();

		if (!ourHaveLoggedStaxImplementation) {
			logStaxImplementation(inputFactory.getClass());
		}

		/*
		 * In the following few lines, you can uncomment the first and comment the second to disable automatic
		 * parsing of extended entities, e.g. §
		 * 
		 * Note that these properties are Woodstox specific and they cause a crash in environments where SJSXP is
		 * being used (e.g. glassfish) so we don't set them there.
		 */
		try {
			Class.forName("com.ctc.wstx.stax.WstxInputFactory");
			if (inputFactory instanceof com.ctc.wstx.stax.WstxInputFactory) {
				// inputFactory.setProperty(WstxInputFactory.IS_REPLACING_ENTITY_REFERENCES, false);
				inputFactory.setProperty(WstxInputProperties.P_UNDECLARED_ENTITY_RESOLVER, XML_RESOLVER);
			}
		} catch (ClassNotFoundException e) {
			ourLog.debug("WstxOutputFactory (Woodstox) not found on classpath");
		}
		ourInputFactory = inputFactory;
	}
	return ourInputFactory;
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
/**
 * Constructor used by Multistream parser
 * @param header   parsed header
 * @param xmlInput parallel input stream
 */
public XmlDumpParser(Header header, InputStream xmlInput) {
    try {
        this.header = header;

        XMLInputFactory2 factory = (XMLInputFactory2) XMLInputFactory2.newInstance();
        factory.setProperty(XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES, Boolean.TRUE);
        factory.setProperty(WstxInputProperties.P_INPUT_PARSING_MODE, WstxInputProperties.PARSING_MODE_FRAGMENT);

        xmlReader = (XMLStreamReader2)factory.createXMLStreamReader(xmlInput);

    } catch (XMLStreamException e) {
        throw new IOError(e);
    }
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
public XMLInputFactoryImpl()
{
    super();
    // Aalto & Woodstox
    delegate.setProperty( XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false );
    // Woodstox
    delegate.setProperty( WstxInputProperties.P_MAX_ATTRIBUTES_PER_ELEMENT, DEFAULT_MAX_ATTRIBUTES_PER_ELEMENT );
    delegate.setProperty( WstxInputProperties.P_MAX_ATTRIBUTE_SIZE, DEFAULT_MAX_ATTRIBUTE_LENGTH );
    delegate.setProperty( WstxInputProperties.P_MAX_ELEMENT_DEPTH, DEFAULT_MAX_ELEMENT_DEPTH );
    delegate.setProperty( WstxInputProperties.P_MAX_ENTITY_COUNT, DEFAULT_MAX_ENTITY_COUNT );
    delegate.setProperty( WstxInputProperties.P_MAX_ENTITY_DEPTH, DEFAULT_MAX_ENTITY_DEPTH );
    // delegate.setProperty( WstxInputProperties.P_MAX_CHARACTERS, 42 );
    // delegate.setProperty( WstxInputProperties.P_MAX_CHILDREN_PER_ELEMENT, 42 );
    // delegate.setProperty( WstxInputProperties.P_MAX_ELEMENT_COUNT, 42 );
    // delegate.setProperty( WstxInputProperties.P_MAX_TEXT_LENGTH, 42 );
    // None
    try
    {
        delegate.setProperty(
            XMLConstants.ACCESS_EXTERNAL_DTD,
            Internal.EXTERNAL_ENTITIES.get() ? ACCESS_EXTERNAL_ALL : ACCESS_EXTERNAL_NONE
        );
    }
    catch( IllegalArgumentException ex )
    {
        LOG.trace( "JAXP<1.5 - {} on {}", ex.getMessage(), delegate );
    }
    delegate.setXMLResolver( Internal.RESOLVER.get() );
    delegate.setXMLReporter( Errors.INSTANCE );
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
/**
 * @return Schema (DTD, RNG, W3C Schema) based type of the attribute
 *   in specified index
 */
@Override
public final String getAttributeType(int index)
{
    if (index == mIdAttrIndex && index >= 0) { // second check to ensure -1 is not passed
        return "ID";
    }
    return (mValidator == null) ? WstxInputProperties.UNKNOWN_ATTR_TYPE : 
        mValidator.getAttributeType(index);
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
/**
 * @param name Name of the property to set
 * @param value Value to set property to.
 *
 * @return True, if the specified property was <b>succesfully</b>
 *    set to specified value; false if its value was not changed
 */
@Override
public boolean setProperty(String name, Object value)
{
    boolean ok = mConfig.setProperty(name, value);
    /* To make [WSTX-50] work fully dynamically (i.e. allow
     * setting BASE_URL after stream reader has been constructed)
     * need to force
     */
    if (ok && WstxInputProperties.P_BASE_URL.equals(name)) {
        // Easiest to just access from config: may come in as a String etc
        mInput.overrideSource(mConfig.getBaseURL());
    }
    return ok;
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
@Override
public String getAttributeType(int index)
{
    DTDAttribute attr = mAttrSpecs[index];
    return (attr == null) ? WstxInputProperties.UNKNOWN_ATTR_TYPE : 
        attr.getValueTypeString();
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
public void testMaxAttributesLimit() throws Exception
{
    final int max = 100;
    XMLInputFactory factory = getNewInputFactory();
    factory.setProperty(WstxInputProperties.P_MAX_ATTRIBUTES_PER_ELEMENT, Integer.valueOf(50));
    Reader reader = new Reader() {
        StringReader sreader = new StringReader("<ns:element xmlns:ns=\"http://foo.com\"");
        int count;
        boolean done;
        @Override
        public int read(char[] cbuf, int off, int len) throws IOException {
            int i = sreader.read(cbuf, off, len);
            if (i == -1) {
                if (count < max) {
                    sreader = new StringReader(" attribute" + count++ + "=\"foo\"");
                } else if (!done) {
                    sreader = new StringReader("/>");
                    done = true;
                }
                i = sreader.read(cbuf, off, len);
            }
            return i;
        }
        @Override
        public void close() throws IOException { }
    };
    XMLStreamReader xmlreader = factory.createXMLStreamReader(reader);
    try {
        xmlreader.nextTag();
        fail("Should have failed");
    } catch (XMLStreamException ex) {
        verifyException(ex, "Attribute limit (50)");
    }
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
public void testLongAttribute() throws Exception {
    final int max = 500;
    Reader reader = new Reader() {
        StringReader sreader = new StringReader("<ns:element xmlns:ns=\"http://foo.com\" blah=\"");
        int count;
        boolean done;
        @Override
        public int read(char[] cbuf, int off, int len) throws IOException {
            int i = sreader.read(cbuf, off, len);
            if (i == -1) {
                if (count < max) {
                    sreader = new StringReader("          ");
                    count++;
                } else if (!done) {
                    sreader = new StringReader("\"/>");
                    done = true;
                }
                i = sreader.read(cbuf, off, len);
            }
            return i;
        }
        @Override
        public void close() throws IOException { }
    };
    try {
        XMLInputFactory factory = getNewInputFactory();
        factory.setProperty(WstxInputProperties.P_MAX_ATTRIBUTE_SIZE, Integer.valueOf(100));
        XMLStreamReader xmlreader = factory.createXMLStreamReader(reader);
        while (xmlreader.next() != XMLStreamReader.END_DOCUMENT) {
        }
        fail("Should have failed");
    } catch (XMLStreamException ex) {
        verifyException(ex, "Maximum attribute size");
    }
    reader.close(); // never gets here
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
public void testSettingResolvers()
    throws XMLStreamException
{
    XMLInputFactory ifact = getNewInputFactory();
    // Default should be "no custom resolvers"
    assertNull(ifact.getProperty(WstxInputProperties.P_DTD_RESOLVER));
    assertNull(ifact.getProperty(WstxInputProperties.P_ENTITY_RESOLVER));

    // But if and when they are set, they should stick for both factory:
    XMLResolver dtdR = new DTDResolver();
    XMLResolver entityR = new EntityResolver();

    ifact.setProperty(WstxInputProperties.P_DTD_RESOLVER, dtdR);
    ifact.setProperty(WstxInputProperties.P_ENTITY_RESOLVER, entityR);

    Object gotDtdR = ifact.getProperty(WstxInputProperties.P_DTD_RESOLVER);
    Object gotEntityR = ifact.getProperty(WstxInputProperties.P_ENTITY_RESOLVER);
    assertTrue("DTD resolver set for factory should stick: didn't except value ["+gotDtdR+"]",
               dtdR == gotDtdR);
    assertTrue("Entity resolver set for factory should stick: didn't except value ["+gotEntityR+"]",
               entityR == gotEntityR);

    // and for the instances as well:
    XMLStreamReader sr = constructStreamReader(ifact, "<root />");
    gotDtdR = sr.getProperty(WstxInputProperties.P_DTD_RESOLVER);
    gotEntityR = sr.getProperty(WstxInputProperties.P_ENTITY_RESOLVER);

    assertTrue("DTD resolver set should be passed to instance by factory: didn't except value ["+gotDtdR+"]",
               dtdR == gotDtdR);
    assertTrue("Entity resolver set should be passed to instance by factory: didn't except value ["+gotEntityR+"]",
               entityR == gotEntityR);
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
public void testMaxEntityNesting() throws XMLStreamException
{
    String XML = "<!DOCTYPE root [\n"
            +" <!ENTITY top '&middle;'>\n"
            +" <!ENTITY middle '&bottom;'>\n"
            +" <!ENTITY bottom 'yay!'>\n"
            +"]><root>&top;</root>"
           ;

    // First: with default limits (high), should be fine
    XMLInputFactory f = getNewInputFactory();
    XMLStreamReader sr = f.createXMLStreamReader(new StringReader(XML));
    assertTokenType(DTD, sr.next());
    assertTokenType(START_ELEMENT, sr.next());
    assertTokenType(CHARACTERS, sr.next());
    assertTokenType(END_ELEMENT, sr.next());
    sr.close();

    // and with max depth of 3 as well
    f.setProperty(WstxInputProperties.P_MAX_ENTITY_DEPTH, Integer.valueOf(3));
    sr = f.createXMLStreamReader(new StringReader(XML));
    assertTokenType(DTD, sr.next());
    assertTokenType(START_ELEMENT, sr.next());
    assertTokenType(CHARACTERS, sr.next());
    assertTokenType(END_ELEMENT, sr.next());
    sr.close();

    // but not with 2
    f.setProperty(WstxInputProperties.P_MAX_ENTITY_DEPTH, Integer.valueOf(2));
    sr = f.createXMLStreamReader(new StringReader(XML));
    assertTokenType(DTD, sr.next());
    assertTokenType(START_ELEMENT, sr.next());
    try {
        sr.next();
        fail("Should have failed with entity depth limit extension");
    } catch (XMLStreamException e) {
        verifyException(e, "Maximum entity expansion depth");
    }
    sr.close();
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
public void testSuperDeep() throws Exception 
{
    final int max = Integer.MAX_VALUE;
    Reader reader = new Reader() {
        StringReader sreader = new StringReader("<ns:element xmlns:ns=\"http://foo.com\">");
        int count;
        boolean done;
        @Override
        public int read(char[] cbuf, int off, int len) throws IOException {
            int i = sreader.read(cbuf, off, len);
            if (i == -1) {
                if (count < max) {
                    sreader = new StringReader("<ns:element>");
                    count++;
                } else if (!done) {
                    sreader = new StringReader("</ns:element>");
                    done = true;
                }
                i = sreader.read(cbuf, off, len);
            }
            return i;
        }
        @Override
        public void close() throws IOException {
        }
    };
    XMLInputFactory factory = getNewInputFactory();
    factory.setProperty(WstxInputProperties.P_MAX_ELEMENT_DEPTH, Integer.valueOf(25));
    XMLStreamReader xmlreader = factory.createXMLStreamReader(reader);
    try {
        while (xmlreader.next() != XMLStreamReader.END_ELEMENT) {
            ;
        }
        fail("Should have failed");
    } catch (XMLStreamException ex) {
        verifyException(ex, "Maximum Element Depth limit");
    }
}
 

import com.ctc.wstx.api.WstxInputProperties; //导入依赖的package包/类
public void testManyChildren() throws Exception 
{
    final int max = Integer.MAX_VALUE;
    Reader reader = new Reader() {
        StringReader sreader = new StringReader("<ns:element xmlns:ns=\"http://foo.com\">");
        int count;
        boolean done;
        @Override
        public int read(char[] cbuf, int off, int len) throws IOException {
            int i = sreader.read(cbuf, off, len);
            if (i == -1) {
                if (count < max) {
                    sreader = new StringReader("<ns:element/>");
                    count++;
                } else if (!done) {
                    sreader = new StringReader("</ns:element>");
                    done = true;
                }
                i = sreader.read(cbuf, off, len);
            }
            return i;
        }
        @Override
        public void close() throws IOException {
        }
    };
    XMLInputFactory factory = getNewInputFactory();
    factory.setProperty(WstxInputProperties.P_MAX_CHILDREN_PER_ELEMENT, Integer.valueOf(100));
    try {
        XMLStreamReader xmlreader = factory.createXMLStreamReader(reader);
        while (xmlreader.next() != XMLStreamReader.END_DOCUMENT) {
        }
        fail("Should have failed");
    } catch (XMLStreamException ex) {
        verifyException(ex, "Maximum Number of Child Elements");
    }
}