public boolean canLoad(OWLOntologyDocumentSource documentSource) {
   if (documentSource.isReaderAvailable()) {
     return true;
   }
   if (documentSource.isInputStreamAvailable()) {
     return true;
   }
   if (parsableSchemes.contains(documentSource.getDocumentIRI().getScheme())) {
     return true;
   }
   // If we can open an input stream then we can attempt to parse the ontology
   // TODO: Take into consideration the request type!
   try {
     InputStream is = documentSource.getDocumentIRI().toURI().toURL().openStream();
     is.close();
     return true;
   } catch (UnknownHostException e) {
     logger.info("Unknown host: " + e.getMessage());
   } catch (MalformedURLException e) {
     logger.info("Malformed URL: " + e.getMessage());
   } catch (FileNotFoundException e) {
     logger.info("File not found: " + e.getMessage());
   } catch (IOException e) {
     logger.info("IO Exception: " + e.getMessage());
   }
   return false;
 }
  public OWLOntology loadOWLOntology(
      OWLOntologyDocumentSource documentSource, final OWLOntologyCreationHandler mediator)
      throws OWLOntologyCreationException {
    // Attempt to parse the ontology by looping through the parsers.  If the
    // ontology is parsed successfully then we break out and return the ontology.
    // I think that this is more reliable than selecting a parser based on a file extension
    // for example (perhaps the parser list could be ordered based on most likely parser, which
    // could be determined by file extension).
    Map<OWLParser, OWLParserException> exceptions =
        new LinkedHashMap<OWLParser, OWLParserException>();
    // Call the super method to create the ontology - this is needed, because
    // we throw an exception if someone tries to create an ontology directly

    OWLOntology existingOntology = null;
    IRI iri = documentSource.getDocumentIRI();
    if (getOWLOntologyManager().contains(iri)) {
      existingOntology = getOWLOntologyManager().getOntology(iri);
    }
    OWLOntologyID ontologyID = new OWLOntologyID();
    OWLOntology ont =
        super.createOWLOntology(ontologyID, documentSource.getDocumentIRI(), mediator);
    // Now parse the input into the empty ontology that we created
    for (final OWLParser parser : getParsers()) {
      try {
        if (existingOntology == null && !ont.isEmpty()) {
          // Junk from a previous parse.  We should clear the ont
          getOWLOntologyManager().removeOntology(ont);
          ont = super.createOWLOntology(ontologyID, documentSource.getDocumentIRI(), mediator);
        }
        OWLOntologyFormat format = parser.parse(documentSource, ont);
        mediator.setOntologyFormat(ont, format);
        return ont;
      } catch (IOException e) {
        // No hope of any parsers working?
        // First clean up
        getOWLOntologyManager().removeOntology(ont);
        throw new OWLOntologyCreationIOException(e);
      } catch (UnloadableImportException e) {
        // First clean up
        getOWLOntologyManager().removeOntology(ont);
        throw e;
      } catch (OWLParserException e) {
        // Record this attempts and continue trying to parse.
        exceptions.put(parser, e);
      } catch (RuntimeException e) {
        // Clean up and rethrow
        getOWLOntologyManager().removeOntology(ont);
        throw e;
      }
    }
    if (existingOntology == null) {
      getOWLOntologyManager().removeOntology(ont);
    }
    // We haven't found a parser that could parse the ontology properly.  Throw an
    // exception whose message contains the stack traces from all of the parsers
    // that we have tried.
    throw new UnparsableOntologyException(documentSource.getDocumentIRI(), exceptions);
  }
 @Override
 public OWLOntologyFormat parse(
     OWLOntologyDocumentSource documentSource,
     OWLOntology ontology,
     OWLOntologyLoaderConfiguration configuration)
     throws OWLParserException, IOException, OWLOntologyChangeException,
         UnloadableImportException {
   Reader reader = null;
   InputStream is = null;
   try {
     OWLFunctionalSyntaxParser parser;
     if (documentSource.isReaderAvailable()) {
       reader = documentSource.getReader();
       parser = new OWLFunctionalSyntaxParser(reader);
     } else if (documentSource.isInputStreamAvailable()) {
       is = documentSource.getInputStream();
       parser = new OWLFunctionalSyntaxParser(is);
     } else {
       is = getInputStream(documentSource.getDocumentIRI(), configuration);
       parser = new OWLFunctionalSyntaxParser(is);
     }
     parser.setUp(ontology, configuration);
     return parser.parse();
   } catch (ParseException e) {
     throw new OWLParserException(
         e.getMessage(), e, e.currentToken.beginLine, e.currentToken.beginColumn);
   } finally {
     if (is != null) {
       is.close();
     } else if (reader != null) {
       reader.close();
     }
   }
 }
 @Test
 public void shouldTestInterfaceOWLOntologyDocumentSource() throws Exception {
   OWLOntologyDocumentSource testSubject0 = mock(OWLOntologyDocumentSource.class);
   InputStream result0 = testSubject0.getInputStream();
   boolean result1 = testSubject0.isReaderAvailable();
   Reader result2 = testSubject0.getReader();
   boolean result3 = testSubject0.isInputStreamAvailable();
   IRI result4 = testSubject0.getDocumentIRI();
 }