org.xml.sax.InputSource Java Examples

private boolean pushReader(ExternalEntity next)
        throws IOException, SAXException {

    InputEntity r = InputEntity.getInputEntity(dtdHandler, locale);
    InputSource s;
    try {
        s = next.getInputSource(resolver);
    } catch (IOException e) {
        String msg =
                "unable to open the external entity from :" + next.systemId;
        if (next.publicId != null)
            msg += " (public id:" + next.publicId + ")";

        SAXParseException spe = new SAXParseException(msg,
                getPublicId(), getSystemId(), getLineNumber(), getColumnNumber(), e);
        dtdHandler.fatalError(spe);
        throw e;
    }

    r.init(s, next.name, in, next.isPE);
    in = r;
    return true;
}
 

private static XMLInputSource saxToXMLInputSource(InputSource sis) {
    String publicId = sis.getPublicId();
    String systemId = sis.getSystemId();

    Reader charStream = sis.getCharacterStream();
    if (charStream != null) {
        return new XMLInputSource(publicId, systemId, null, charStream,
                null);
    }

    InputStream byteStream = sis.getByteStream();
    if (byteStream != null) {
        return new XMLInputSource(publicId, systemId, null, byteStream,
                sis.getEncoding());
    }

    return new XMLInputSource(publicId, systemId, null);
}
 

public static InputSource loadEffectivePom(
    File moduleFile, MavenContext context)
    throws IOException, InterruptedException {
  MavenExecutor exec = context.build(moduleFile);
  exec.evalEffectivePom(context);

  if (0 != exec.getExitCode()) {
    MavenLogger.LOG.warn(
        "Err {}  getting effective POM for {}\n\nMaven Console output >\n{}",
        exec.getExitCode(), moduleFile.getPath(), exec.getOut());
  }

  String effPom = exec.getEffPom();
  if (Strings.isNullOrEmpty(effPom)) {
    MavenLogger.LOG.warn(
        "Empty effective POM for {}\n\nMaven Console output >\n",
        moduleFile.getPath(), exec.getOut());
  }

  StringReader reader = new StringReader(effPom);
  return new InputSource(reader);
}
 

@Test
public void noNamespacePrefixes() throws Exception {
	Assume.assumeTrue(wwwSpringframeworkOrgIsAccessible());

	StringWriter stringWriter = new StringWriter();
	AbstractStaxHandler handler = createStaxHandler(new StreamResult(stringWriter));
	xmlReader.setContentHandler(handler);
	xmlReader.setProperty("http://xml.org/sax/properties/lexical-handler", handler);

	xmlReader.setFeature("http://xml.org/sax/features/namespaces", true);
	xmlReader.setFeature("http://xml.org/sax/features/namespace-prefixes", false);

	xmlReader.parse(new InputSource(new StringReader(COMPLEX_XML)));

	assertThat(stringWriter.toString(), isSimilarTo(COMPLEX_XML).withNodeFilter(nodeFilter));
}
 

public Framework(final String name, final File bsFile) {
    super(name, null);
    try {
        final File pathf = bsFile.getCanonicalFile().getParentFile().getParentFile().getParentFile();
        path = pathf.getParentFile().getParentFile().getCanonicalPath();
    } catch (IOException x) {
        throw new RuntimeException(x);
    }
    binaries = findBinaries(path, name);

    pkg = ClassGenerator.JOBJC_PACKAGE + "." + name.toLowerCase();
    try {
        rootNode = (Node)XPATH.evaluate("signatures", new InputSource(bsFile.getAbsolutePath()), XPathConstants.NODE);
    } catch (final XPathExpressionException e) { throw new RuntimeException(e); }
    protocols = new ArrayList<Protocol>();
    categories = new ArrayList<Category>();
}
 

@Override
   public InputSource resolveEntity (
   			    String name,
   			    String publicId,
   			    String baseURI,
   			    String systemId)
throws SAXException, IOException {

	try {
		if (shouldLoadAsResource(systemId)) {
			log.debug("Loading entity '" + systemId + "' as resource");
			return resourceToInputSource(publicId, systemId);
		}
		else {
			return super.resolveEntity(publicId, systemId);
		}
	}
	catch (Exception e) {
		// not in spec but too bad
		throw new PluginException("Error resolving entity: " + systemId + ": " + e, e);
	}
}
 

@Test(dataProvider = "illegalCharactersData")
public void test(int character) throws Exception {
    // Construct the XML document as a String
    int[] cps = new int[]{character};
    String txt = new String(cps, 0, cps.length);
    String inxml = "<topElement attTest=\'" + txt + "\'/>";
    String exceptionText = "NO EXCEPTION OBSERVED";
    String hexString = "0x" + Integer.toHexString(character);

    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    dbf.setNamespaceAware(true);
    dbf.setValidating(false);
    DocumentBuilder db = dbf.newDocumentBuilder();
    InputSource isrc = new InputSource(new StringReader(inxml));

    try {
        db.parse(isrc);
    } catch (SAXException e) {
        exceptionText = e.toString();
    }
    System.out.println("Got Exception:" + exceptionText);
    assertTrue(exceptionText.contains("attribute \"attTest\""));
    assertTrue(exceptionText.contains("element is \"topElement\""));
    assertTrue(exceptionText.contains("Unicode: " + hexString));
}
 

@Test
public void setFromXML() throws Exception {
	String[] expected = new String[] { "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>",
			"<SRE name=\"Hello\" mainClass=\"io.sarl.Boot\" libraryPath=\"" + this.path.toPortableString()
					+ "\" standalone=\"true\">",
			"<libraryLocation packageRootPath=\"\" sourcePath=\"\" systemLibraryPath=\"" + this.path.toPortableString()
					+ "\"/>",
			"<libraryLocation packageRootPath=\"\" sourcePath=\"\" systemLibraryPath=\"x.jar\"/>",
			"<libraryLocation packageRootPath=\"\" sourcePath=\"\" systemLibraryPath=\"y.jar\"/>",
			"<libraryLocation packageRootPath=\"\" sourcePath=\"\" systemLibraryPath=\"z.jar\"/>", "</SRE>", };
	StringBuilder b = new StringBuilder();
	for (String s : expected) {
		b.append(s);
		// b.append("\n");
	}
	try (ByteArrayInputStream bais = new ByteArrayInputStream(b.toString().getBytes())) {
		DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
		parser.setErrorHandler(new DefaultHandler());
		Element root = parser.parse(new InputSource(bais)).getDocumentElement();
		this.sre.setFromXML(root);
		assertTrue(this.sre.isStandalone());
		assertEquals(this.path, this.sre.getJarFile());
		assertEquals("Hello", this.sre.getName());
		assertEquals("io.sarl.Boot", this.sre.getMainClass());
	}
}
 

/**
 * Create and populate the entity as specified by its type and XML
 * definition.
 *
 * @param entityTypeCode The Entity Type code.
 * @param xml The XML of the associated entity.
 * @return The populated entity.
 * @throws ApsSystemException If errors detected while retrieving the
 * entity.
 */
protected IApsEntity createEntityFromXml(String entityTypeCode, String xml) throws ApsSystemException {
    try {
        IApsEntity entityPrototype = this.getEntityPrototype(entityTypeCode);
        SAXParserFactory parseFactory = SAXParserFactory.newInstance();
        SAXParser parser = parseFactory.newSAXParser();
        InputSource is = new InputSource(new StringReader(xml));
        EntityHandler handler = this.getEntityHandler();
        handler.initHandler(entityPrototype, this.getXmlAttributeRootElementName(), this.getCategoryManager());
        parser.parse(is, handler);
        return entityPrototype;
    } catch (ParserConfigurationException | SAXException | IOException t) {
        logger.error("Error detected while creating the entity. typecode: {} - xml: {}", entityTypeCode, xml, t);
        throw new ApsSystemException("Error detected while creating the entity", t);
    }
}
 

@Test(dataProvider = "illegalCharactersData")
public void test(int character) throws Exception {
    // Construct the XML document as a String
    int[] cps = new int[]{character};
    String txt = new String(cps, 0, cps.length);
    String inxml = "<topElement attTest=\'" + txt + "\'/>";
    String exceptionText = "NO EXCEPTION OBSERVED";
    String hexString = "0x" + Integer.toHexString(character);

    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    dbf.setNamespaceAware(true);
    dbf.setValidating(false);
    DocumentBuilder db = dbf.newDocumentBuilder();
    InputSource isrc = new InputSource(new StringReader(inxml));

    try {
        db.parse(isrc);
    } catch (SAXException e) {
        exceptionText = e.toString();
    }
    System.out.println("Got Exception:" + exceptionText);
    assertTrue(exceptionText.contains("attribute \"attTest\""));
    assertTrue(exceptionText.contains("element is \"topElement\""));
    assertTrue(exceptionText.contains("Unicode: " + hexString));
}
 

public static <T> Object unmarshal(final Class<T> type, final InputStream in) throws ParserConfigurationException, SAXException, JAXBException {
    final InputSource inputSource = new InputSource(in);

    final SAXParserFactory factory = SAXParserFactory.newInstance();
    factory.setNamespaceAware(true);
    factory.setValidating(false);

    final JAXBContext ctx = JAXBContextFactory.newInstance(type);
    final Unmarshaller unmarshaller = ctx.createUnmarshaller();
    unmarshaller.setEventHandler(new ValidationEventHandler() {
        public boolean handleEvent(final ValidationEvent validationEvent) {
            System.out.println(validationEvent);
            return false;
        }
    });

    return unmarshaller.unmarshal(inputSource);
}
 

@Test
public void testGetChildElementsByTagNameNS() throws Exception
{
    String xml = "<root><a xmlns='urn:test'/><b/><n:a xmlns:n='urn:test'/><c/></root>";
    
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    dbf.setNamespaceAware(true);
    DocumentBuilder db = dbf.newDocumentBuilder();
    Document doc = db.parse(new InputSource(new StringReader(xml)));
    
    Collection<Element> elements = DOMHelper.getChildElementsByTagNameNS(doc.getDocumentElement(), "urn:test", "a");
    
    Assert.assertNotNull(elements);
    Assert.assertEquals(2, elements.size());
    for (Element element : elements)
    {
        Assert.assertEquals("a", element.getLocalName());
    }
}
 

public static Map<String, Object> extractCustomAttributes(final String xml) {
    final SAXParserFactory spf = SAXParserFactory.newInstance();
    spf.setNamespaceAware(true);
    spf.setValidating(false);
    try {
        final SAXParser saxParser = spf.newSAXParser();
        final XMLReader xmlReader = saxParser.getXMLReader();
        final CustomAttributeHandler handler = new CustomAttributeHandler();
        xmlReader.setContentHandler(handler);
        xmlReader.parse(new InputSource(new StringReader(xml)));
        return handler.getAttributes();
    } catch (final Exception e) {
    	log.error(e.getMessage(), e);
        return Collections.emptyMap();
    }
}
 

/**
 * Loads the document and updates build-time (latency) statistics
 */
public void loadDocument(String uri) {

    try {
        final long stamp = System.currentTimeMillis();
        _dom = (DOMEnhancedForDTM)_dtmManager.getDTM(
                         new SAXSource(_reader, new InputSource(uri)),
                         false, null, true, false);
        _dom.setDocumentURI(uri);

        // The build time can be used for statistics for a better
        // priority algorithm (currently round robin).
        final long thisTime = System.currentTimeMillis() - stamp;
        if (_buildTime > 0)
            _buildTime = (_buildTime + thisTime) >>> 1;
        else
            _buildTime = thisTime;
    }
    catch (Exception e) {
        _dom = null;
    }
}
 

@Test
public void testTasksXML() throws JSONException, Exception {

  WebResource r = resource();
  Map<JobId, Job> jobsMap = appContext.getAllJobs();
  for (JobId id : jobsMap.keySet()) {
    String jobId = MRApps.toString(id);
    ClientResponse response = r.path("ws").path("v1").path("history")
        .path("mapreduce").path("jobs").path(jobId).path("tasks")
        .accept(MediaType.APPLICATION_XML).get(ClientResponse.class);
    assertEquals(MediaType.APPLICATION_XML_TYPE, response.getType());
    String xml = response.getEntity(String.class);
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    DocumentBuilder db = dbf.newDocumentBuilder();
    InputSource is = new InputSource();
    is.setCharacterStream(new StringReader(xml));
    Document dom = db.parse(is);
    NodeList tasks = dom.getElementsByTagName("tasks");
    assertEquals("incorrect number of elements", 1, tasks.getLength());
    NodeList task = dom.getElementsByTagName("task");
    verifyHsTaskXML(task, jobsMap.get(id));
  }
}
 

public boolean eval() throws BuildException {
    if (nullOrEmpty(fileName)) {
        throw new BuildException("No file set");
    }
    File file = new File(fileName);
    if (!file.exists() || file.isDirectory()) {
        throw new BuildException(
                "The specified file does not exist or is a directory");
    }
    if (nullOrEmpty(path)) {
        throw new BuildException("No XPath expression set");
    }
    XPath xpath = XPathFactory.newInstance().newXPath();
    InputSource inputSource = new InputSource(fileName);
    Boolean result = Boolean.FALSE;
    try {
        result = (Boolean) xpath.evaluate(path, inputSource,
                XPathConstants.BOOLEAN);
    } catch (XPathExpressionException e) {
        throw new BuildException("XPath expression fails", e);
    }
    return result.booleanValue();
}
 

public void testXSchema() throws Exception{
    File xsdFile = new File(test_Constants.TEST_RESOURCE_DIR + "Book.xsd");
    assertTrue("xsdFile " + xsdFile.getAbsolutePath() + " exists",
               xsdFile.exists());
            
    InputStream xmlFile = test_Validator.class.getResourceAsStream("/BookXsdGenerated.xml");
    assertNotNull("xmlFile exists", xmlFile);
    try {
        validator = new Validator(new InputSource(xmlFile));

        validator.useXMLSchema(true);
        assertTrue("Schema " + validator.toString(), validator.isValid());
    } finally {
        xmlFile.close();
    }
}
 

private ID getPrescriberIdFromKmehr(InputStream is) throws XPathExpressionException {
    XPath xPath = XPathFactory.newInstance().newXPath();
    NamespaceContext nsCtx = new MapNamespaceContext("http://www.ehealth.fgov.be/standards/kmehr/schema/v1");
    xPath.setNamespaceContext(nsCtx);
    InputSource inputSource = new InputSource(is);
    Document doc = (Document) xPath.evaluate("/", inputSource, XPathConstants.NODE);
    String idValue = xPath.evaluate("/ns1:kmehrmessage/ns1:header/ns1:sender/ns1:hcparty/ns1:id[@S='ID-HCPARTY' and @SV='1.0']/text()", doc);
    String type = xPath.evaluate("/ns1:kmehrmessage/ns1:header/ns1:sender/ns1:hcparty/ns1:cd[@S='CD-HCPARTY' and @SV='1.0']/text()", doc);
    ID id = new ID();
    id.setIdType("NIHII");
    id.setValue(idValue);
    id.setType(type);
    return id;
}
 

/**
 * @param xml
 * @return a list of Entrys from the given xml string.
 * @throws IOException
 * @throws SAXException
 */
public static List<SonosEntry> getEntriesFromString(String xml) throws SAXException {
    XMLReader reader = XMLReaderFactory.createXMLReader();
    EntryHandler handler = new EntryHandler();
    reader.setContentHandler(handler);
    try {
        reader.parse(new InputSource(new StringReader(xml)));
    } catch (IOException e) {
        logger.error("Could not parse Entries from String {}", xml);
    }
    return handler.getArtists();
}
 

public InputSource getInputSource(EntityResolver r)
        throws IOException, SAXException {

    InputSource retval;

    retval = r.resolveEntity(publicId, systemId);
    // SAX sez if null is returned, use the URI directly
    if (retval == null)
        retval = Resolver.createInputSource(new URL(systemId), false);
    return retval;
}
 

@Override
public int compareTo(XSD x) {
	if (x == null) return 1;
	if (namespace != null && x.namespace != null) {
		int c = namespace.compareTo(x.namespace);
		if (c != 0) return c;
	}
	if (wsdlSchema != null || url == null || (url.toString().compareTo(x.url.toString()) != 0)) {
		// Compare XSD content to prevent copies of the same XSD showing up
		// more than once in the WSDL. For example the
		// CommonMessageHeader.xsd used by the EsbSoapValidator will
		// normally also be imported by the XSD for the business response
		// message (for the Result part).
		try {
			InputSource control = new InputSource(getInputStream());
			InputSource test = new InputSource(x.getInputStream());
			Diff diff = new Diff(control, test);
			if (diff.similar()) {
				return 0;
			} else if (wsdlSchema != null || url == null) {
				return Misc.streamToString(getInputStream(), "\n", false).compareTo(Misc.streamToString(x.getInputStream(), "\n", false));
			}
		} catch (Exception e) {
			LOG.warn("Exception during XSD compare", e);
		}
	}
	return url.toString().compareTo(x.url.toString());
}
 

@Test
public void test() {
    try {
        Transformer transformer = TransformerFactory.newInstance().newTransformer();

        copyDTDtoWorkDir();

        File outf = new File(USER_DIR + "Bug4693341.out");
        StreamResult result = new StreamResult(new FileOutputStream(outf));

        String in = getClass().getResource("Bug4693341.xml").getPath();
        File file = new File(in);
        StreamSource source = new StreamSource(new FileInputStream(file), ("file://" + in));

        transformer.transform(source, result);

        //URL inputsource = new URL("file", "", golden);
        URL output = new URL("file", "", outf.getPath());

        // error happens when trying to parse output
        String systemId = output.toExternalForm();
        System.out.println("systemId: " + systemId);
        InputSource is = new InputSource(systemId);
        SAXParser parser = SAXParserFactory.newInstance().newSAXParser();
        parser.parse(is, new DefaultHandler());
    } catch (Exception ex) {
        Assert.fail(ex.getMessage());
    }
}
 

/**
 * Extract file name from input source.
 *
 * @param inputSource the input source
 * @return the string
 */
public static String extractFileNameFromInputSource(InputSource inputSource) {
    if (inputSource.getByteStream() != null) {
        return extractFileNameFromInputStream(inputSource.getByteStream());
    }
    if (inputSource.getCharacterStream() != null) {
        return extractFileNameFromReader(inputSource.getCharacterStream());
    }
    return null;
}
 

public Node generateAssignFromNodeInstanceResponseToStringVarAsNode(final String stringVarName,
                                                                    final String nodeInstanceResponseVarName) throws IOException,
    SAXException {
    final String templateString =
        generateAssignFromNodeInstanceResonseToStringVar(stringVarName, nodeInstanceResponseVarName);
    final InputSource is = new InputSource();
    is.setCharacterStream(new StringReader(templateString));
    final Document doc = this.docBuilder.parse(is);
    return doc.getFirstChild();
}
 

/**
     * convert an array of {@link InputSource InputSource} into an
     * array of {@link Source Source}
     *
     * @param schemas array of {@link InputSource InputSource}
     * @return array of {@link Source Source}
     */
    private static Source[] getSchemaSource(InputSource[] schemas, EntityResolver entityResolver) throws SAXException {
        SAXSource[] sources = new SAXSource[schemas.length];
        for (int i = 0; i < schemas.length; i++) {
            sources[i] = new SAXSource(schemas[i]);
//            sources[i].getXMLReader().setEntityResolver(entityResolver);
        }
        return sources;
    }
 

public JRXmlDataSource(
		JasperReportsContext jasperReportsContext,
		InputStream in, 
		String selectExpression,
		boolean isNamespaceAware
		) throws JRException 
{
	this(jasperReportsContext, JRXmlUtils.parse(new InputSource(in), isNamespaceAware), selectExpression);
	
	this.inputStream = in;
	this.closeInputStream = false;
}
 

public static void main(String[] args) throws SAXException, IOException {
  XMLReader reader = XMLReaderFactory.createXMLReader();
  ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(Payloads.NO_FEEDBACK_SINGLE_LINE
      .getBytes());

  //todo 修复方式
  reader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
  reader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
  reader.setFeature("http://xml.org/sax/features/external-general-entities", false);
  reader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);

  reader.parse(new InputSource(byteArrayInputStream));
}
 

public void parse(InputSource is, HandlerBase hb)
    throws SAXException, IOException {
    if (is == null) {
        throw new IllegalArgumentException();
    }
    if (hb != null) {
        xmlReader.setDocumentHandler(hb);
        xmlReader.setEntityResolver(hb);
        xmlReader.setErrorHandler(hb);
        xmlReader.setDTDHandler(hb);
        xmlReader.setContentHandler(null);
    }
    xmlReader.parse(is);
}
 

public static SourceBean fromXMLStream(InputSource stream, boolean trimCharacters, boolean  upperCase)
	throws SourceBeanException {
    if (stream == null) {
        TracerSingleton.log(
            Constants.NOME_MODULO,
            TracerSingleton.WARNING,
            "SourceBean::fromXMLStream: stream nullo");
        return null;
    } // if (stream == null)
    SourceBean sourceBean = null;
    XMLReader parser = new SAXParser();
    try {
        SourceBeanContentHandler contentHandler =
            new SourceBeanContentHandler(trimCharacters, upperCase);
        parser.setContentHandler(contentHandler);
        parser.parse(stream);
        sourceBean = contentHandler.getSourceBean();
    } // try
    catch (Exception ex) {
        TracerSingleton.log(
            Constants.NOME_MODULO,
            TracerSingleton.CRITICAL,
            "SourceBean::fromXMLString: impossibile elaborare lo stream XML",
            ex);
        throw new SourceBeanException("Impossibile elaborare lo stream XML");
    } // catch (Exception ex) try
    return sourceBean;
}
 

public static ArrayList<LogEvent> parse(Reader reader, boolean cleanup) throws Exception {
    // Create the XML input factory
    SAXParserFactory factory = SAXParserFactory.newInstance();

    // Create the XML LogEvent reader
    SAXParser p = factory.newSAXParser();

    if (cleanup) {
        // some versions of the log have slightly malformed XML, so clean it
        // up before passing it to SAX
        reader = new LogCleanupReader(reader);
    }

    LogParser log = new LogParser();
    try {
        p.parse(new InputSource(reader), log);
    } catch (Throwable th) {
        th.printStackTrace();
        // Carry on with what we've got...
    }

    // Associate compilations with their NMethods
    for (NMethod nm : log.nmethods.values()) {
        Compilation c = log.compiles.get(nm.getId());
        nm.setCompilation(c);
        // Native wrappers for methods don't have a compilation
        if (c != null) {
            c.setNMethod(nm);
        }
    }

    // Initially we want the LogEvent log sorted by timestamp
    Collections.sort(log.events, sortByStart);

    return log.events;
}