Java Code Examples for org.xml.sax.SAXParseException

public void parse() throws SAXException {
  try {
    marshaller.marshal(contentObject,repeater);
  }
 catch (  JAXBException e) {
    SAXParseException se=new SAXParseException(e.getMessage(),null,null,-1,-1,e);
    if (errorHandler != null) {
      errorHandler.fatalError(se);
    }
    throw se;
  }
}
 

public static void main(String args[]) throws ParserConfigurationException, SAXException {
  SAXParserFactory factory=SAXParserFactory.newInstance();
  factory.setValidating(true);
  XMLReader parser=factory.newSAXParser().getXMLReader();
  parser.setContentHandler(new DefaultHandler());
  parser.setErrorHandler(new MyErrorHandler());
  try {
    parser.parse(args[0]);
    System.out.println("Everything is OK.");
  }
 catch (  IOException e) {
    System.err.printf("Handler in main. I/O error: %s\n",e.getMessage());
  }
catch (  SAXException e) {
    SAXParseException spe=(SAXParseException)e.getException();
    System.err.printf("Handler in main. Parsing error: %s\n",e.getMessage());
    if (spe != null) {
      System.err.println("Additional infos: " + spe.getLineNumber() + "/"+ spe.getColumnNumber());
    }
  }
}
 

dk.hlyh.hudson.tools.jobcreator.input.xml.model.Pipeline loadXml(){
  File inputFile=arguments.getInput();
  if (inputFile == null || !inputFile.exists()) {
    throw new ImportException("Pipline file '" + inputFile + "' cannot be found");
  }
  try {
    JAXBContext context=JAXBContext.newInstance(ROOT_NODE);
    Unmarshaller unmarshaller=context.createUnmarshaller();
    Schema schema=loadSchema();
    unmarshaller.setSchema(schema);
    dk.hlyh.hudson.tools.jobcreator.input.xml.model.Pipeline pipeline=(dk.hlyh.hudson.tools.jobcreator.input.xml.model.Pipeline)unmarshaller.unmarshal(new FileInputStream(inputFile));
    LogFacade.info("Successfully loaded pipline from {0}",inputFile);
    return pipeline;
  }
 catch (  FileNotFoundException ex) {
    throw new ImportException("Could not find pipeline file: " + inputFile);
  }
catch (  UnmarshalException ex) {
    if (ex.getCause() instanceof org.xml.sax.SAXParseException) {
      SAXParseException pe=(SAXParseException)ex.getCause();
      LogFacade.severe("Failed to validate the pipeline definition against the schema: \"{0}\"  at line {1}, column={2}",pe.getMessage(),pe.getLineNumber(),pe.getColumnNumber());
    }
 else {
      LogFacade.severe(ex);
    }
    throw new ImportException("Failed to validate the pipeline definition against the schema" + ex);
  }
catch (  JAXBException ex) {
    throw new ImportException("Failed to configure JAXB",ex);
  }
}
 

@Test public void testGenericContentHandlerErrorThrowsSAXParseException() throws Throwable {
  SAXParseException ex2=new SAXParseException("testGenericContentHandlerParam1","testGenericContentHandlerParam2","testGenericContentHandlerParam3",100,1000);
  try {
    new GenericSubFieldPackager().new GenericContentHandler().error(ex2);
    fail("Expected SAXParseException to be thrown");
  }
 catch (  SAXParseException ex) {
    assertEquals("ex.getMessage()","testGenericContentHandlerParam1",ex.getMessage());
    assertEquals("ex.getPublicId()","testGenericContentHandlerParam2",ex.getPublicId());
    assertEquals("ex.getSystemId()","testGenericContentHandlerParam3",ex.getSystemId());
    assertEquals("ex.getLineNumber()",100,ex.getLineNumber());
    assertEquals("ex.getColumnNumber()",1000,ex.getColumnNumber());
    assertNull("ex.getException()",ex.getException());
  }
}
 

public List<Content> toOSIS(Book book,Key key,String plain){
  Element ele=cleanParse(book,key,plain);
  if (ele == null) {
    if (error instanceof SAXParseException) {
      SAXParseException spe=(SAXParseException)error;
      int colNumber=spe.getColumnNumber();
      int start=Math.max(0,colNumber - 40);
      int stop=Math.min(finalInput.length(),colNumber + 40);
      int here=stop - start;
      log.warn("Could not fix " + book.getInitials() + '('+ key.getName()+ ") by "+ errorMessage+ ": Error here("+ colNumber+ ','+ finalInput.length()+ ','+ here+ "): "+ finalInput.substring(start,stop));
    }
 else {
      log.warn("Could not fix " + book.getInitials() + "("+ key.getName()+ ") by "+ errorMessage+ ": "+ error.getMessage());
    }
    ele=OSISUtil.factory().createP();
  }
  return ele.removeContent();
}
 

public void parse(String systemId) throws IOException, SAXException {
  this.initialize();
  try {
    DraftDocument doc=parser.parse(new FileInputStream(systemId),new HashMap());
    SAXGenerator generator=new SVGGenerator();
    generator.setProperties(new HashMap());
    generator.generate(doc,this.getContentHandler(),null);
    doc=null;
    this.parser=null;
  }
 catch (  ParseException e) {
    errorhandler.error(new SAXParseException(e.getMessage(),null));
  }
}
 

private void fatalError(String message) throws SAXException {
  log.debug("Fatal error: {}",message);
  state=State.CLOSED;
  tokenizer.close();
  startDocument();
  errorHandler.fatalError(new SAXParseException(message,null));
}
 

@Override public void startElement(String uri,String localName,String qName,Attributes attributes) throws SAXException {
  if (isModified || !"import".equals(qName))   return;
  String value=attributes.getValue(qNameFile.getLocalPart());
  if (value == null)   throw new SAXParseException("Attribute 'file' is missing",locator);
  File file=new File(basedir,value);
  if (!file.exists())   throw new SAXParseException("Imported file not found. file=" + file.getPath(),locator);
  if (file.isFile() && checkFile(file)) {
    isModified=true;
    return;
  }
  if (file.isDirectory()) {
    String rec=attributes.getValue(qNameRecursiveImport.getLocalPart());
    Collection<File> files=listFiles(file,rec == null ? true : Boolean.valueOf(rec));
    for (    File childFile : files) {
      if (checkFile(childFile)) {
        isModified=true;
        return;
      }
    }
  }
}
 

@Override public void endElement(String uri,String localName,String qName) throws SAXException {
  if (uri.equals(NAMESPACE_LOG4J) && localName.equals(ELEMENT_EVENT)) {
    try {
      collector.collect(currentEntry);
    }
 catch (    IOException e) {
      throw new SAXParseException(e.getLocalizedMessage(),documentLocator,e);
    }
    checkMonitorCanceled();
  }
 else   if (uri.equals(NAMESPACE_LOG4J) && localName.equals(ELEMENT_MESSAGE)) {
    currentEntry.put(Log4JFieldProvider.FIELD_MESSAGE,buffer.toString());
    buffer=null;
  }
 else   if (uri.equals(NAMESPACE_LOG4J) && localName.equals(ELEMENT_NDC)) {
    currentEntry.put(Log4JFieldProvider.FIELD_NDC,buffer.toString());
    buffer=null;
  }
 else   if (uri.equals(NAMESPACE_LOG4J) && localName.equals(ELEMENT_THROWABLE)) {
    currentEntry.put(Log4JFieldProvider.FIELD_THROWABLE,buffer.toString());
    buffer=null;
  }
  super.endElement(uri,localName,qName);
}
 

private void validateXML(String xml) throws Exception {
  DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
  dbf.setValidating(true);
  dbf.setNamespaceAware(true);
  dbf.setAttribute("http://java.sun.com/xml/jaxp/properties/schemaLanguage","http://www.w3.org/2001/XMLSchema");
  DocumentBuilder db=dbf.newDocumentBuilder();
  db.setErrorHandler(new ErrorHandler(){
    @Override public void warning(    SAXParseException exception) throws SAXException {
      throw exception;
    }
    @Override public void fatalError(    SAXParseException exception) throws SAXException {
      throw exception;
    }
    @Override public void error(    SAXParseException exception) throws SAXException {
      throw exception;
    }
  }
);
  db.setEntityResolver(new EntityResolver(){
    @Override public InputSource resolveEntity(    String publicId,    String systemId) throws SAXException, IOException {
      if ("http://jboss.org/schema/arquillian/arquillian_1_0.xsd".equals(systemId)) {
        return new InputSource(this.getClass().getClassLoader().getResourceAsStream("arquillian_1_0.xsd"));
      }
      return null;
    }
  }
);
  db.parse(new ByteArrayInputStream(xml.getBytes()));
}
 

@Override public void actionPerformed(ActionEvent e){
  if (transformer == null) {
    return;
  }
  JTextComponent target=getTextComponent(e);
  try {
    SyntaxDocument sdoc=ActionUtils.getSyntaxDocument(target);
    StringWriter out=new StringWriter(sdoc.getLength());
    StringReader reader=new StringReader(target.getText());
    InputSource src=new InputSource(reader);
    Document doc=getDocBuilder().parse(src);
    getTransformer().transform(new DOMSource(doc),new StreamResult(out));
    target.setText(out.toString());
  }
 catch (  SAXParseException ex) {
    showErrorMessage(target,String.format("XML error: %s\nat(%d, %d)",ex.getMessage(),ex.getLineNumber(),ex.getColumnNumber()));
    ActionUtils.setCaretPosition(target,ex.getLineNumber(),ex.getColumnNumber() - 1);
  }
catch (  TransformerException ex) {
    showErrorMessage(target,ex.getMessageAndLocation());
  }
catch (  SAXException ex) {
    showErrorMessage(target,ex.getLocalizedMessage());
  }
catch (  IOException ex) {
    showErrorMessage(target,ex.getLocalizedMessage());
  }
}
 

@Override public String getMessage(){
  StringBuilder sb=new StringBuilder();
  sb.append(super.getMessage());
  sb.append("The METS did not meet all requirements.\n");
  for (  SAXParseException e : this.fatalErrors) {
    sb.append(e.getMessage()).append("\n");
  }
  for (  SAXParseException e : this.errors) {
    sb.append(e.getMessage()).append("\n");
  }
  for (  SAXParseException e : this.warnings) {
    sb.append(e.getMessage()).append("\n");
  }
  return sb.toString();
}
 

private boolean handleError(SAXParseException ex){
  ErrorType er=new ErrorType();
  er.setServerity(ErrorType.FATAL);
  InFileLocation loc=new InFileLocation();
  loc.setColumnNumber(ex.getColumnNumber());
  loc.setLineNumber(ex.getLineNumber());
  er.setInFileLocation(loc);
  er.setMessage(ex.getMessage());
  tResult.add(er);
  return true;
}
 

@Test public void testXml() throws Exception {
  XmlParser parser=getParser(true);
  try {
    parser.parse(getClass().getResource("sip.xml").toString());
    fail("expected SAXParseException");
  }
 catch (  SAXParseException e) {
  }
  parser=getParser(false);
  parser.parse(getClass().getResource("sip.xml").toString());
}
 

private static Document createDocument(String configFilename){
  try {
    Document document;
    javax.xml.parsers.DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
    dbf.setValidating(false);
    dbf.setIgnoringComments(true);
    dbf.setIgnoringElementContentWhitespace(true);
    javax.xml.parsers.DocumentBuilder parser=dbf.newDocumentBuilder();
    parser.setErrorHandler(new org.xml.sax.ErrorHandler(){
      public void warning(      SAXParseException e){
        logger.warn("WARNING: " + e.getMessage(),e);
      }
      public void error(      SAXParseException e){
        logger.error("ERROR: " + e.getMessage(),e);
      }
      public void fatalError(      SAXParseException e) throws SAXException {
        logger.error("FATAL ERROR: " + e.getMessage(),e);
        throw e;
      }
    }
);
    InputStream is=getResourceStream(configFilename);
    if (is == null) {
      throw new RuntimeException("Unable to find config file:" + configFilename);
    }
    document=parser.parse(is);
    return document;
  }
 catch (  Exception e) {
    throw new RuntimeException(e);
  }
}
 

@Override public void warning(SAXParseException e) throws SAXException {
  if (_failOnWarning) {
    throw e;
  }
 else {
    LOGGER.warn("Warning during validation with '" + _schemaFile + "' as '"+ _schemaType+ "'",e);
  }
}
 

public Object getMessage(){
  if (logger.isTraceEnabled()) {
    logger.trace("getMessage() - entry");
  }
  if (!initialize()) {
    if (logger.isTraceEnabled()) {
      logger.trace("getMessage() - exit - not yet initialized! Returning null.");
    }
    return null;
  }
  String message=null;
  try {
    xmlReader.parse(input);
  }
 catch (  IOException e) {
    logger.error("getMessage()",e);
  }
catch (  SAXEndMessageException e) {
    message=buffer.toString().trim();
  }
catch (  SAXParseException e) {
    if (buffer.length() > 0)     logger.error("getMessage()",e);
  }
catch (  SAXException e) {
    logger.error("getMessage()",e);
  }
  if (logger.isTraceEnabled()) {
    logger.trace("getMessage() - exit - result :" + message);
  }
  return message;
}
 

@Override public void warning(SAXParseException err) throws SAXException {
  if (isVerbose) {
    err.printStackTrace();
  }
 else {
    System.out.println("warning:" + err.getMessage());
  }
}
 

/** 
 * Validate the supplied xml file.
 * @param project The project name.
 * @param filename The file path to the xml file.
 * @param schema True to use schema validation relying on thexsi:schemaLocation attribute of the document.
 * @param handler The content handler to use while parsing the file.
 * @return A possibly empty list of errors.
 */
public static List<Error> validateXml(String project,String filename,boolean schema,DefaultHandler handler) throws Exception {
  SAXParserFactory factory=SAXParserFactory.newInstance();
  factory.setNamespaceAware(true);
  factory.setValidating(true);
  if (schema) {
    factory.setFeature("http://apache.org/xml/features/validation/schema",true);
    factory.setFeature("http://apache.org/xml/features/validation/schema-full-checking",true);
  }
  SAXParser parser=factory.newSAXParser();
  filename=ProjectUtils.getFilePath(project,filename);
  filename=filename.replace('\\','/');
  ErrorAggregator errorHandler=new ErrorAggregator(filename);
  EntityResolver entityResolver=new EntityResolver(FileUtils.getFullPath(filename));
  try {
    parser.parse(new File(filename),getHandler(handler,errorHandler,entityResolver));
  }
 catch (  SAXParseException spe) {
    ArrayList<Error> errors=new ArrayList<Error>();
    errors.add(new Error(spe.getMessage(),filename,spe.getLineNumber(),spe.getColumnNumber(),false));
    return errors;
  }
  return errorHandler.getErrors();
}
 

private PluginModel processManifestFile(URL manifest){
  InputStream is=null;
  try {
    is=manifest.openStream();
  }
 catch (  IOException e) {
    if (debug)     debug("No plugin found for: " + manifest);
    return null;
  }
  PluginModel result=null;
  try {
    try {
      InputSource in=new InputSource(is);
      in.setSystemId(manifest.getFile());
      result=new PluginParser((Factory)factory).parsePlugin(in);
    }
  finally {
      is.close();
    }
  }
 catch (  SAXParseException se) {
    factory.error(new Status(IStatus.WARNING,Platform.PI_RUNTIME,Platform.PARSE_PROBLEM,NLS.bind(Messages.parse_errorProcessing,manifest),null));
  }
catch (  Exception e) {
    factory.error(new Status(IStatus.WARNING,Platform.PI_RUNTIME,Platform.PARSE_PROBLEM,NLS.bind(Messages.parse_errorProcessing,manifest + ":  " + e.getMessage()),null));
  }
  return result;
}
 

private String getTextFromInputSource(InputSource is) throws SAXException, IOException {
  XMLReader xr=new org.ccil.cowan.tagsoup.Parser();
  ContentHandler handler=new MyHandler();
  xr.setContentHandler(handler);
  xr.setErrorHandler(new ErrorHandler(){
    public void warning(    SAXParseException exception) throws SAXException {
      LOG.log(Level.WARNING,"exception while parsing note contents",exception);
    }
    public void error(    SAXParseException exception) throws SAXException {
      LOG.log(Level.WARNING,"exception while parsing note contents",exception);
    }
    public void fatalError(    SAXParseException exception) throws SAXException {
      LOG.log(Level.WARNING,"exception while parsing note contents",exception);
    }
  }
);
  xr.parse(is);
  String text=handler.toString();
  return text;
}
 

/** 
 * Formats a SAXParseException as a string: error message, followed by five lines of the markup centered around the line where the error occurs.
 */
private String format(SAXParseException ex){
  StringBuffer buf=new StringBuffer();
  buf.append(ex.getMessage());
  buf.append("\n");
  final int ctx=this.numLinesContext;
  for (int offset=-1 * ctx / 2; offset <= ctx / 2; offset++) {
    int line=ex.getLineNumber() + offset;
    if (line >= 1 && line <= this.lines.length) {
      buf.append("   ");
      if (line == ex.getLineNumber()) {
        buf.append("*");
      }
 else {
        buf.append(" ");
      }
      buf.append(String.format("%-5d",line));
      buf.append("| ");
      buf.append(this.lines[line - 1]);
      buf.append("\n");
    }
  }
  return buf.toString();
}
 

public static Document newDocument(InputStream input) throws IOException, SAXException {
  try {
    return getDocumentBuilder().parse(input);
  }
 catch (  SAXParseException e) {
    throw new SAXException(String.format("SAXParseException at line:%d, col:%d, %s",e.getLineNumber(),e.getColumnNumber(),e.getMessage()));
  }
}
 

/** 
 * Adds the default EntityResolved and ErrorHandler for the SAX parser.
 */
private void addHandlers(XMLReader xmlReader){
  try {
    xmlReader.setEntityResolver(FSEntityResolver.instance());
    xmlReader.setErrorHandler(new ErrorHandler(){
      public void error(      SAXParseException ex){
        XRLog.load(ex.getMessage());
      }
      public void fatalError(      SAXParseException ex){
        XRLog.load(ex.getMessage());
      }
      public void warning(      SAXParseException ex){
        XRLog.load(ex.getMessage());
      }
    }
);
  }
 catch (  Exception ex) {
    throw new XRRuntimeException("Failed on configuring SAX parser/XMLReader.",ex);
  }
}
 

/** 
 * @return true, if well formed XML.
 */
public boolean isWellformedXml(String xml){
  try {
    SAXParserFactory factory=SAXParserFactory.newInstance();
    factory.setValidating(false);
    factory.newSAXParser().parse(new InputSource(new StringReader(xml)),new DefaultHandler());
    return true;
  }
 catch (  SAXParseException e) {
    logger.log(Level.SEVERE,"XmlParseError on line " + e.getLineNumber() + " of "+ xml,e);
  }
catch (  Exception e) {
    logger.log(Level.SEVERE,"XmlParseError",e);
  }
  return false;
}
 

private static Document createDocument(String configFilename){
  try {
    Document document;
    javax.xml.parsers.DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
    dbf.setValidating(false);
    dbf.setIgnoringComments(true);
    dbf.setIgnoringElementContentWhitespace(true);
    javax.xml.parsers.DocumentBuilder parser=dbf.newDocumentBuilder();
    parser.setErrorHandler(new org.xml.sax.ErrorHandler(){
      public void warning(      SAXParseException e){
        logger.warn("WARNING: " + e.getMessage(),e);
      }
      public void error(      SAXParseException e){
        logger.error("ERROR: " + e.getMessage(),e);
      }
      public void fatalError(      SAXParseException e) throws SAXException {
        logger.error("FATAL ERROR: " + e.getMessage(),e);
        throw e;
      }
    }
);
    InputStream is=getResourceStream(configFilename);
    if (is == null) {
      throw new RuntimeException("Unable to find config file:" + configFilename);
    }
    document=parser.parse(is);
    return document;
  }
 catch (  Exception e) {
    throw new RuntimeException(e);
  }
}
 

@SuppressWarnings("unchecked") private boolean equals(List<GedcomTag> gedcomTags,List<GedcomTag> compareGedcomTags) throws SAXParseException, IOException {
  mergeContConcTags(gedcomTags);
  mergeContConcTags(compareGedcomTags);
  removeEmptyTags(gedcomTags);
  removeEmptyTags(compareGedcomTags);
  convertMultipleTextTags(gedcomTags);
  Collections.sort(gedcomTags);
  Collections.sort(compareGedcomTags);
  if (gedcomTags.size() != compareGedcomTags.size()) {
    return false;
  }
  for (int indx=0; indx < gedcomTags.size(); indx++) {
    GedcomTag gedcomTagOne=gedcomTags.get(indx);
    GedcomTag gedcomTagTwo=compareGedcomTags.get(indx);
    if (!gedcomTagOne.equals(gedcomTagTwo)) {
      logger.info("file=" + currentFilename + " !tag="+ gedcomTagOne.toString()+ "<=====>"+ gedcomTagTwo.toString());
      return false;
    }
  }
  return true;
}
 

private void convertXFile(File inFile,OutputStream outputStream) throws SAXParseException, IOException {
  GedcomxFile gxFile=new GedcomxFile(new JarFile(inFile));
  GedcomxOutputStream out=new GedcomxOutputStream(outputStream);
  Map<String,String> attributes=gxFile.getAttributes();
  for (  Map.Entry<String,String> attribute : attributes.entrySet()) {
    out.addAttribute(attribute.getKey(),attribute.getValue());
  }
  for (  GedcomxFileEntry entry : gxFile.getEntries()) {
    if (!entry.getJarEntry().isDirectory() && !entry.getJarEntry().getName().endsWith("MANIFEST.MF")) {
      Object resource=gxFile.readResource(entry);
      String contentType=entry.getContentType();
      if (contentType == null) {
        contentType=CommonModels.GEDCOMX_XML_MEDIA_TYPE;
      }
      out.addResource(contentType,entry.getJarEntry().getName(),resource,null,entry.getAttributes());
    }
  }
  out.close();
}
 

private static Document getDocument(URL url,TreeLogger logger) throws UnableToCompleteException {
  Document doc=null;
  try {
    doc=new W3cDomHelper(logger).documentFor(url);
  }
 catch (  SAXParseException e) {
    logger.log(TreeLogger.ERROR,String.format("Error parsing XML (line " + e.getLineNumber() + "): "+ e.getMessage(),e));
    throw new UnableToCompleteException();
  }
  return doc;
}
 

private void parse(Reader reader) throws IOException {
  try {
    DocumentBuilderFactory docBuilderFactory=DocumentBuilderFactory.newInstance();
    docBuilderFactory.setIgnoringComments(true);
    DocumentBuilder builder=docBuilderFactory.newDocumentBuilder();
    builder.setErrorHandler(new ErrorHandler(){
      @Override public void warning(      SAXParseException exception) throws SAXException {
        throw exception;
      }
      @Override public void error(      SAXParseException exception) throws SAXException {
        throw exception;
      }
      @Override public void fatalError(      SAXParseException exception) throws SAXException {
        throw exception;
      }
    }
);
    Document doc=builder.parse(new InputSource(reader));
    parseDocument(doc);
  }
 catch (  SAXException e) {
    throw new IOException(e);
  }
catch (  ParserConfigurationException e) {
    throw new IOException(e);
  }
}
 

DOM4JXMLParser() throws Exception {
  this.dom4jReader.setErrorHandler(new ErrorHandler(){
    @Override public void warning(    SAXParseException e) throws SAXException {
      errorHolder.addErrorMessage("warning",e);
    }
    @Override public void fatalError(    SAXParseException e) throws SAXException {
      errorHolder.addErrorMessage("fatal error",e);
    }
    @Override public void error(    SAXParseException e) throws SAXException {
      errorHolder.addErrorMessage("error",e);
    }
  }
);
}
 

/** 
 * Parse a <code>File</code> containing an XML structure into a DOM tree.
 * @param input The input XML file.
 * @return The corresponding DOM tree, or <code>null</code> if the input could not be parsed successfully.
 */
public static Document parseFile(final File input){
  Document output=null;
  try {
    final DocumentBuilder db=FACTORY.newDocumentBuilder();
    db.setErrorHandler(new ParserErrorHandler());
    output=db.parse(input);
  }
 catch (  final Exception ex) {
    String msg="Problem parsing the input XML file";
    if (ex instanceof SAXParseException) {
      msg+=" at line #" + ((SAXParseException)ex).getLineNumber();
    }
    LOGGER.error(msg,ex);
  }
  return output;
}
 

/** 
 * Test method for  {@link org.jboss.jsfunit.analysis.util.ParserUtils#getDocument(java.lang.String)}.
 */
public void testGetDocumentBadXml(){
  try {
    Document testDoc=ParserUtils.getDocument("bad xml");
    assertNotNull(testDoc);
  }
 catch (  SAXParseException spe) {
    assertEquals("Content is not allowed in prolog.",spe.getMessage());
  }
catch (  Throwable t) {
    fail("wrong exception " + t.getClass().getName());
  }
}
 

protected Document parse(File artifact) throws Exception {
  if (dbf == null) {
    dbf=DocumentBuilderFactory.newInstance();
    dbf.setNamespaceAware(true);
  }
  DocumentBuilder db=dbf.newDocumentBuilder();
  db.setErrorHandler(new ErrorHandler(){
    public void warning(    SAXParseException exception) throws SAXException {
    }
    public void error(    SAXParseException exception) throws SAXException {
    }
    public void fatalError(    SAXParseException exception) throws SAXException {
      throw exception;
    }
  }
);
  return db.parse(artifact);
}
 

public void error(SAXParseException exception) throws SAXException {
  if (exception.getMessage().equals("cvc-elt.1: Cannot find the declaration of element 'configuration'.")) {
    LOG.info("The document " + url + " does not contain a schema declaration, it should have an "+ "XML declaration similar to\n"+ "<configuration\n"+ "   xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"+ "   xsi:schemaLocation=\"http://www.exoplatform.org/xml/ns/kernel_1_1.xsd "+ "http://www.exoplatform.org/xml/ns/kernel_1_1.xsd\"\n"+ "   xmlns=\"http://www.exoplatform.org/xml/ns/kernel_1_1.xsd\">");
  }
 else {
    LOG.error("In document " + url + "  at ("+ exception.getLineNumber()+ ","+ exception.getColumnNumber()+ ") :"+ exception.getMessage());
  }
  valid=false;
}
 

protected void addErrorMessage(SAXParseException e,String message){
  String[] params=new String[3];
  params[0]=e.getMessage();
  params[1]=Integer.toString(e.getLineNumber());
  params[2]=Integer.toString(e.getColumnNumber());
  this.usecase.addErrorMessage(message,params);
}
 

/** 
 * Creates an XML document model with the given contents.
 */
public Document documentFor(String string,String resourcePath) throws SAXParseException {
  try {
    factory.setFeature("http://xml.org/sax/features/xmlns-uris",true);
    factory.setFeature("http://xml.org/sax/features/namespace-prefixes",true);
    if (resourcePath != null) {
      int pos=resourcePath.lastIndexOf('/');
      resourcePath=(pos < 0) ? "" : resourcePath.substring(0,pos + 1);
    }
    W3cDocumentBuilder handler=new W3cDocumentBuilder(logger,resourcePath,resourceOracle);
    SAXParser parser=factory.newSAXParser();
    InputSource input=new InputSource(new StringReader(string));
    input.setSystemId(resourcePath);
    parser.parse(input,handler);
    return handler.getDocument();
  }
 catch (  SAXParseException e) {
    throw e;
  }
catch (  SAXException e) {
    throw new RuntimeException(e);
  }
catch (  IOException e) {
    throw new RuntimeException(e);
  }
catch (  ParserConfigurationException e) {
    throw new RuntimeException(e);
  }
}
 

void store(SAXParseException ex,String type){
  String errorString=type + " at line number, " + ex.getLineNumber()+ ": "+ ex.getMessage()+ "\n";
  Node currentNode=null;
  try {
    currentNode=(Node)parser.getProperty("http://apache.org/xml/properties/dom-node");
  }
 catch (  SAXException se) {
    System.err.println(se.getMessage());
    return;
  }
  if (currentNode == null)   return;
  String previous=(String)errorNodes.get(currentNode);
  if (previous != null)   errorNodes.put(currentNode,previous + errorString);
 else   errorNodes.put(currentNode,errorString);
}
 

@Test public void withCorruptFile() throws JoranException, IOException {
  String tmpOut=copyToTemp(INVALID);
  System.setProperty(INCLUDE_KEY,tmpOut);
  tc.doConfigure(TOP_BY_FILE);
  assertEquals(Status.ERROR,statusChecker.getHighestLevel(0));
  assertTrue(statusChecker.containsException(SAXParseException.class));
  File f=new File(tmpOut);
  assertTrue(f.exists());
  assertTrue(f.delete());
}
 

@Override public void error(SAXParseException e) throws SAXException {
  if (stopped) {
    return;
  }
  super.error(e);
}
 

/** 
 * {@inheritDoc} 
 */
@Override public void error(SAXParseException e) throws SAXException {
  if (!hasDtdAndXsd) {
    processException(TYPE_ERROR,e);
    return;
  }
  Matcher m=ELEMENT_TYPE_PATTERN.matcher(e.getMessage());
  if (!m.find()) {
    processException(TYPE_ERROR,e);
  }
}
 

/** 
 * @param file - xml configuration file for Mockey
 * @throws IOException
 * @throws SAXException
 * @throws SAXParseException
 */
private String getFileContentAsString(File file) throws IOException, SAXParseException, SAXException {
  FileInputStream fstream=new FileInputStream(file);
  BufferedReader br=new BufferedReader(new InputStreamReader(fstream,Charset.forName(HTTP.UTF_8)));
  StringBuffer inputString=new StringBuffer();
  String strLine=null;
  while ((strLine=br.readLine()) != null) {
    inputString.append(new String(strLine.getBytes(HTTP.UTF_8)));
  }
  return inputString.toString();
}
 

public void testXsdGenerator() throws Throwable {
  ModelloCore modello=(ModelloCore)lookup(ModelloCore.ROLE);
  Model model=modello.loadModel(getXmlResourceReader("/features.mdo"));
  Properties parameters=getModelloParameters("1.0.0");
  modello.generate(model,"xsd",parameters);
  SchemaFactory sf=SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
  Schema schema=sf.newSchema(new StreamSource(new File(getOutputDirectory(),"features-1.0.0.xsd")));
  Validator validator=schema.newValidator();
  try {
    validator.validate(new StreamSource(getClass().getResourceAsStream("/features.xml")));
  }
 catch (  SAXParseException e) {
    throw new ModelloException("line " + e.getLineNumber() + " column "+ e.getColumnNumber(),e);
  }
  try {
    validator.validate(new StreamSource(getClass().getResourceAsStream("/features-invalid.xml")));
    fail("parsing of features-invalid.xml should have failed");
  }
 catch (  SAXParseException e) {
    assertTrue(String.valueOf(e.getMessage()).indexOf("invalidElement") >= 0);
  }
  try {
    validator.validate(new StreamSource(getClass().getResourceAsStream("/features-invalid-transient.xml")));
    fail("XSD did not prohibit appearance of transient fields");
  }
 catch (  SAXParseException e) {
    assertTrue(String.valueOf(e.getMessage()).indexOf("transientString") >= 0);
  }
}
 

/** 
 * Gets the info to the corresponding exception.
 * @param e the exception
 * @return the info
 */
private String getInfo(SAXParseException e){
  final StringBuilder stringb=new StringBuilder();
  stringb.append("   Public ID: " + e.getPublicId());
  stringb.append("   System ID: " + e.getSystemId());
  stringb.append("   Line number: " + e.getLineNumber());
  stringb.append("   Column number: " + e.getColumnNumber());
  stringb.append("   Message: " + e.getMessage());
  return stringb.toString();
}
 

public void parseInputStream(InputStream is){
  try {
    SAXParserFactory factory=SAXParserFactory.newInstance();
    SAXParser saxParser=factory.newSAXParser();
    try {
      saxParser.parse(is,handler);
    }
 catch (    DoneParsingException e) {
    }
catch (    SAXParseException e) {
      Logger.getInstance().logException("SAXParseException on parsing: " + e.getMessage());
      e.printStackTrace();
      error=true;
      AppMIDlet.getInstance().getFileSystem().setError(true);
    }
  }
 catch (  Exception e) {
    Logger.getInstance().logException("Exception on parsing: " + e.getMessage());
    e.printStackTrace();
    error=true;
    GeneralAlert.getInstance().addCommand(ExitCommand.getInstance());
    GeneralAlert.getInstance().show(Resources.ERROR_TITLE,Resources.EPARSE_GENERAL,GeneralAlert.ERROR);
  }
}
 

/** 
 * Test what happens if the appcast file can not be parsed.
 */
@Test public void testUnreadableAppcast(){
  Updater updater=new Updater(new UnreadableHost());
  TestUpdateDelegate delegate=checkForUpdates(updater);
  assertFalse(delegate.checkPerformed);
  assertEquals(SAXParseException.class,delegate.throwable.getClass());
}
 

public void error(SAXParseException e) throws SAXException {
  if (e.getMessage().contains("cvc-complex-type.2.4.a")) {
    log.log(Level.SEVERE,"",e);
    return;
  }
  sb.append(String.format("line: %d column: %d error: %s",e.getLineNumber(),e.getColumnNumber(),e.getMessage()));
  error=true;
}
 

/** 
 * args[0]: the file name of the file to validate args[1]: the file name of the schema to validate against
 */
public static void main(String[] args) throws IOException, SAXException, ParsingException, ValidityException {
  BasicConfigurator.configure();
  if (args.length < 2) {
    throw new IllegalArgumentException("Invalid arguments: you must pass a file name of the file to be validated as " + "the first argument and a file name of the schema to use in validation as the second argument.");
  }
  String fileName=args[0];
  String schemaFileName=args[1];
  CampaignValidator validator=new CampaignValidator();
  try {
    validator.runAgainstFiles(fileName,schemaFileName);
  }
 catch (  SAXParseException saxe) {
    LOGGER.error("Parsing failed at line number " + saxe.getLineNumber() + " column number "+ saxe.getColumnNumber());
    throw saxe;
  }
}
 

public void error(SAXParseException arg0) throws SAXException {
  log.error("Error validating XML.");
  printInfo(arg0);
  this.saxe=arg0;
  setValidationError(true);
}
 

public void characters(char[] buf,int start,int count,AntXMLContext context){
  try {
    super.characters(buf,start,count,context);
  }
 catch (  SAXParseException e) {
    ErrorHelper.handleErrorFromElementText(start,count,context,e);
  }
catch (  BuildException be) {
    ErrorHelper.handleErrorFromElementText(start,count,context,be);
  }
}
 

public static void main(String[] args) throws SAXParseException, IOException {
  AnalyzeMatches self=new AnalyzeMatches();
  CmdLineParser parser=new CmdLineParser(self);
  try {
    parser.parseArgument(args);
    self.doMain();
  }
 catch (  CmdLineException e) {
    System.err.println(e.getMessage());
    parser.printUsage(System.err);
  }
}
 

@Test public void throwsExceptionWhenXsdValidationFails() throws Exception {
  exception.expect(SAXParseException.class);
  exception.expectMessage("Cannot find the declaration of element 'shopping'.");
  final InputStream xsd=getClass().getResourceAsStream("/car-records.xsd");
  expect().body(matchesXsd(xsd)).when().get("/shopping");
}
 

private String formatMessage(SAXParseException e){
  StringBuffer sb=new StringBuffer();
  sb.append('[');
  if (e.getSystemId() == null) {
    sb.append("<<null>>");
  }
 else {
    sb.append(e.getSystemId());
  }
  sb.append(" ");
  sb.append(e.getLineNumber());
  sb.append(':');
  sb.append(e.getColumnNumber());
  sb.append("] ");
  sb.append(e.getMessage());
  return sb.toString();
}
 

public void loadEcuDefsFromXml(File ecuDefsFile){
  checkNotNull(ecuDefsFile,"ecuDefsFile");
  try {
    InputStream inputStream=new BufferedInputStream(new FileInputStream(ecuDefsFile));
    try {
      EcuDefinitionHandler handler=new EcuDefinitionHandler();
      getSaxParser().parse(inputStream,handler);
      ecuDefinitionMap=handler.getEcuDefinitionMap();
    }
  finally {
      inputStream.close();
    }
  }
 catch (  SAXParseException spe) {
    throw new ConfigurationException("Unable to read ECU definition file " + ecuDefsFile + ".  Please make sure the definition file is correct.  If it is in a ZIP archive, unzip the file and try again.");
  }
catch (  FileNotFoundException fnfe) {
    throw new ConfigurationException("The specified ECU definition file " + ecuDefsFile + " does not exist.");
  }
catch (  Exception e) {
    throw new ConfigurationException(e);
  }
}
 

private static Document createDocument(String configFilename){
  try {
    Document document;
    javax.xml.parsers.DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
    dbf.setValidating(false);
    dbf.setIgnoringComments(true);
    dbf.setIgnoringElementContentWhitespace(true);
    javax.xml.parsers.DocumentBuilder parser=dbf.newDocumentBuilder();
    parser.setErrorHandler(new org.xml.sax.ErrorHandler(){
      public void warning(      SAXParseException e){
        logger.warn("WARNING: " + e.getMessage(),e);
      }
      public void error(      SAXParseException e){
        logger.error("ERROR: " + e.getMessage(),e);
      }
      public void fatalError(      SAXParseException e) throws SAXException {
        logger.error("FATAL ERROR: " + e.getMessage(),e);
        throw e;
      }
    }
);
    InputStream is=getResourceStream(configFilename);
    if (is == null) {
      throw new RuntimeException("Unable to find config file:" + configFilename);
    }
    document=parser.parse(is);
    return document;
  }
 catch (  Exception e) {
    throw new RuntimeException(e);
  }
}
 

@Override public void error(SAXParseException e) throws SAXException {
  if (valid) {
    valid=false;
  }
  logError(e);
}
 

private static void validate(final Object o,HierarchicalStreamWriter writer,DocumentBuilderFactory dbf) throws Exception {
  final String xml=writer.toString();
  Reader reader=new StringReader(xml);
  DocumentBuilder db=dbf.newDocumentBuilder();
  db.setErrorHandler(new ErrorHandler(){
    @Override public void warning(    SAXParseException exception) throws SAXException {
      Assert.fail(o.toString() + ": " + exception.getMessage()+ "\n"+ xml);
    }
    @Override public void error(    SAXParseException exception) throws SAXException {
      Assert.fail(o.toString() + ": " + exception.getMessage()+ "\n"+ xml);
    }
    @Override public void fatalError(    SAXParseException exception) throws SAXException {
      Assert.fail(o.toString() + ": " + exception.getMessage()+ "\n"+ xml);
    }
  }
);
  db.parse(new InputSource(reader));
}
 

private Document getDocumentForSource(InputStream contentTypeDef) throws SAXException, ParserConfigurationException, IOException {
  final DocumentBuilderFactory docBuilderFactor=DocumentBuilderFactory.newInstance();
  docBuilderFactor.setNamespaceAware(true);
  DocumentBuilder parser=docBuilderFactor.newDocumentBuilder();
  parser.setErrorHandler(new ErrorHandler(){
    public void warning(    SAXParseException exception) throws SAXException {
      throw exception;
    }
    public void error(    SAXParseException exception) throws SAXException {
      throw exception;
    }
    public void fatalError(    SAXParseException exception) throws SAXException {
      throw exception;
    }
  }
);
  Document document=parser.parse(contentTypeDef);
  return document;
}
 

public Object parse(final String pvXmlRpcString) throws XmlRpcException {
  Object lvReturn=null;
  boolean lvIsFault=false;
  try {
    if (pvXmlRpcString != null) {
      SAXParserFactory lvFactory=SAXParserFactory.newInstance();
      SAXParser lvParser=lvFactory.newSAXParser();
      XMLReader lvReader=lvParser.getXMLReader();
      XmlRpcContentHandler lvContentHandler=new XmlRpcContentHandler();
      lvContentHandler.setReturnValueAsList(getReturnValueAsList());
      lvReader.setContentHandler(lvContentHandler);
      ByteArrayInputStream lvArrayInputStream=new ByteArrayInputStream(pvXmlRpcString.getBytes());
      lvReader.parse(new InputSource(lvArrayInputStream));
      lvReturn=lvContentHandler.getResults();
      methodName=lvContentHandler.getMethodName();
      lvIsFault=lvContentHandler.isFault();
    }
  }
 catch (  SAXParseException e) {
    throw new XmlRpcException(e.getMessage(),e);
  }
catch (  Exception e) {
    throw new XmlRpcException("Exception by parse XML-RPC-String: " + pvXmlRpcString,e);
  }
  if (lvIsFault == true && getConvertResult2XmlRpcExceptionAndThrow()) {
    Map<?,?> lvMap=(Map<?,?>)lvReturn;
    Object lvFaultCode=lvMap.get("faultCode");
    Object lvMessage=lvMap.get("faultString");
    throw new XmlRpcException(lvFaultCode + ": " + lvMessage);
  }
  return lvReturn;
}
 

private boolean transformWith(String string,boolean needRewind){
  try {
    try {
      final Transformer t=transformerFor(string);
      String mimetype=mimetype(t);
      final Result result=resultFor(mimetype);
      if (result == null)       return false;
      final Source in=input.startAfresh(needRewind);
      runInSandbox(new TERunnable(){
        public void run() throws TransformerException {
          t.transform(in,result);
        }
      }
,true);
      postProcess(mimetype,result);
      return true;
    }
 catch (    TransformerException e) {
      error(e);
      return false;
    }
catch (    SAXParseException e) {
      error(e);
      return false;
    }
catch (    InterruptedException e) {
      throw new InterruptedIOException("In GRDDL transformWith");
    }
 finally {
      input.close();
      if (subThread != null)       subThread.interrupt();
    }
  }
 catch (  IOException ioe) {
    error(ioe);
    return false;
  }
}
 

/** 
 * Wraps a  {@link SAXException} into a {@link DataSetException}
 * @param cause The cause to be wrapped into a  {@link DataSetException}
 * @return A {@link DataSetException} that wraps the given{@link SAXException}
 */
protected final static DataSetException buildException(SAXException cause){
  int lineNumber=-1;
  if (cause instanceof SAXParseException) {
    lineNumber=((SAXParseException)cause).getLineNumber();
  }
  Exception exception=cause.getException() == null ? cause : cause.getException();
  String message;
  if (lineNumber >= 0) {
    message="Line " + lineNumber + ": "+ exception.getMessage();
  }
 else {
    message=exception.getMessage();
  }
  if (exception instanceof DataSetException) {
    return (DataSetException)exception;
  }
 else {
    return new DataSetException(message,exception);
  }
}
 

@Test public void testParsingOfAdviceTypesWithError(){
  try {
    new ClassPathXmlApplicationContext(getClass().getSimpleName() + "-error.xml",getClass());
    fail("Expected BeanDefinitionStoreException");
  }
 catch (  BeanDefinitionStoreException ex) {
    assertTrue(ex.contains(SAXParseException.class));
  }
}
 

public void fatalError(SAXParseException e) throws SAXException {
  if (this.locator != null) {
    throw new SAXException("Error Traced[line: " + this.locator.getLineNumber() + "] "+ e.getMessage());
  }
 else {
    throw e;
  }
}
 

@Override public Object makeObject() throws Exception {
  DocumentBuilder newDocumentBuilder=factory.newDocumentBuilder();
  newDocumentBuilder.setErrorHandler(new ErrorHandler(){
    public void error(    SAXParseException exception) throws SAXException {
      if (LOG.isDebugEnabled())       LOG.debug(exception.toString());
    }
    public void fatalError(    SAXParseException exception) throws SAXException {
      if (LOG.isDebugEnabled())       LOG.debug(exception.toString());
    }
    public void warning(    SAXParseException exception) throws SAXException {
      if (LOG.isDebugEnabled())       LOG.debug(exception.toString());
    }
  }
);
  return newDocumentBuilder;
}
 

private final Document parseTemplateUsingPool(final Configuration configuration,final String documentName,final Reader reader,final ResourcePool<SAXParser> poolToBeUsed){
  final SAXParser saxParser=poolToBeUsed.allocate();
  final TemplatePreprocessingReader templateReader=getTemplatePreprocessingReader(reader);
  try {
    final Document document=doParse(configuration,documentName,templateReader,saxParser);
    if (this.canResetParsers) {
      try {
        saxParser.reset();
      }
 catch (      final UnsupportedOperationException e) {
        if (this.logger.isWarnEnabled()) {
          this.logger.warn("[THYMELEAF] The SAX Parser implementation being used (\"{}\") does not implement " + "the \"reset\" operation. This will force Thymeleaf to re-create parser instances " + "each time they are needed for parsing templates, which is more costly. Enabling template "+ "cache is recommended, and also using a parser library which implements \"reset\" such as "+ "xerces version 2.9.1 or newer.",saxParser.getClass().getName());
        }
        this.canResetParsers=false;
      }
    }
    return document;
  }
 catch (  final IOException e) {
    throw new TemplateInputException("Exception parsing document",e);
  }
catch (  final TemplateProcessingException e) {
    throw e;
  }
catch (  final SAXParseException e) {
    final String message=String.format("Exception parsing document: template=\"%s\", line %d - column %d",documentName,Integer.valueOf(e.getLineNumber()),Integer.valueOf(e.getColumnNumber()));
    throw new TemplateInputException(message,e);
  }
catch (  final SAXException e) {
    throw new TemplateInputException("Exception parsing document",e);
  }
 finally {
    if (this.canResetParsers) {
      poolToBeUsed.release(saxParser);
    }
 else {
      poolToBeUsed.discardAndReplace(saxParser);
    }
  }
}
 

public void error(SAXParseException e) throws SAXParseException {
  reportError(Level.SEVERE,e);
  if (m_checkLevel.equals(SchemaValidationLevel.ERROR)) {
    throw e;
  }
}
 

public void error(SAXParseException e) throws SAXParseException {
  reportError(Level.SEVERE,e);
  if (m_checkLevel.equals(SchemaValidationLevel.ERROR)) {
    throw e;
  }
}
 

private HashMap<String,Object> parseXMLFile(File xml) throws Exception {
  DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
  HashMap<String,Object> result=new HashMap<String,Object>();
  DocumentBuilder db=dbf.newDocumentBuilder();
  db.setErrorHandler(new VddErrorHandler());
  try {
    dom=db.parse(xml);
  }
 catch (  SAXParseException e) {
    System.out.println("(!)Error parsing log file (" + e.getMessage() + ").  Retrying with end tag hack...");
    InputSource is=endTagHack(xml);
    dom=db.parse(is);
    System.out.println("(*)Success!");
  }
  result=getSuiteData(dom);
  return result;
}
 

/** 
 * getConfig If the configuration file has not been loaded yet, it will be loaded.
 * @return The ISQLConfig object this class manages
 * @throws RemoteException
 */
synchronized public ISQLConfig getConfig() throws RemoteException {
  if (config == null) {
    if (configFileName == null)     throw new RemoteException("Server failed to initialize because no configuration file was specified.");
    try {
      _lastModifiedTime=0L;
      new File(configFileName).getAbsoluteFile().getParentFile().mkdirs();
      config=new SQLConfigXML(configFileName);
      try {
        config=new DatabaseConfig(config);
        System.out.println("Successfully initialized Weave database connection");
      }
 catch (      Exception e) {
        e.printStackTrace();
        System.out.println("Using configuration stored in " + configFileName);
      }
      _lastModifiedTime=new File(configFileName).lastModified();
    }
 catch (    SAXParseException e) {
      String msg=String.format("%s parse error: Line %d, column %d: %s",new File(configFileName).getName(),e.getLineNumber(),e.getColumnNumber(),e.getMessage());
      throw new RemoteException(msg);
    }
catch (    Exception e) {
      e.printStackTrace();
      throw new RemoteException("Server configuration error.",e);
    }
  }
  return config;
}
 

public void error(SAXParseException exception) throws SAXException {
  if (this.rethrowValidationExceptions) {
    throw exception;
  }
 else {
    Logger.log(Logger.WARNING,Launcher.RESOURCES,"WebXmlParser.XMLParseError",exception.getLineNumber() + "",exception.getMessage());
  }
}
 

/** 
 * {@inheritDoc}
 */
public DOMSource readFrom(Class<DOMSource> type,Type genericType,Annotation[] annotations,MediaType mediaType,MultivaluedMap<String,String> httpHeaders,final InputStream entityStream) throws IOException {
  try {
    final DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
    factory.setNamespaceAware(true);
    Document d=SecurityHelper.doPrivilegedExceptionAction(new PrivilegedExceptionAction<Document>(){
      public Document run() throws Exception {
        return factory.newDocumentBuilder().parse(entityStream);
      }
    }
);
    return new DOMSource(d);
  }
 catch (  PrivilegedActionException pae) {
    Throwable cause=pae.getCause();
    if (cause instanceof SAXParseException) {
      if (LOG.isDebugEnabled()) {
        LOG.debug(cause.getLocalizedMessage(),cause);
      }
      return null;
    }
 else     if (cause instanceof SAXException) {
      throw new IOException("Can't read from input stream " + cause,cause);
    }
 else     if (cause instanceof ParserConfigurationException) {
      throw new IOException("Can't read from input stream " + cause,cause);
    }
 else     if (cause instanceof IOException) {
      throw (IOException)cause;
    }
 else     if (cause instanceof RuntimeException) {
      throw (RuntimeException)cause;
    }
 else {
      throw new RuntimeException(cause);
    }
  }
}
 

@Test public void convertOpenStepToXML() throws Exception {
  JAXBPlistParser parser=new JAXBPlistParser();
  try {
    parser.load(fileNameOpenStep);
    Assert.fail();
  }
 catch (  javax.xml.bind.UnmarshalException e) {
    if (!(e.getCause().getClass() == SAXParseException.class)) {
      Assert.fail();
    }
  }
  File xmlProj=File.createTempFile("project",".pbxproj");
  xmlProj.deleteOnExit();
  parser.convert(fileNameOpenStep,xmlProj.getAbsolutePath());
  Plist plist=parser.load(xmlProj.getAbsolutePath());
  assertEquals("1.0",plist.getVersion());
}
 

public void error(SAXParseException e) throws SAXException {
  TreeWriter treeWriter=new TreeWriter(runtime);
  treeWriter.startDocument(docBaseURI);
  treeWriter.addStartElement(XProcConstants.c_error);
  if (e.getLineNumber() != -1) {
    treeWriter.addAttribute(_line,"" + e.getLineNumber());
  }
  if (e.getColumnNumber() != -1) {
    treeWriter.addAttribute(_column,"" + e.getColumnNumber());
  }
  treeWriter.startContent();
  treeWriter.addText(e.toString());
  treeWriter.addEndElement();
  treeWriter.endDocument();
  step.reportError(treeWriter.getResult());
  if (err != null) {
    err=e;
  }
}