import org.openrdf.rio.UnsupportedRDFormatException; //导入依赖的package包/类
@Parameters(name = "{0}")
public static Collection<Object[]> data() {
    Collection<Object[]> result = new ArrayList<>();
    for (RDFFormat nextParserFormat : RDFParserRegistry.getInstance().getKeys()) {
        try {
            // Try to create a writer, as not all formats (RDFa for example) have writers,
            // and we can't automatically test those formats like this
            OutputStream out = new ByteArrayOutputStream();
            Rio.createWriter(nextParserFormat, out);
            // If the writer creation did not throw an exception, add it to the list
            result.add(new Object[]{nextParserFormat});
        } catch(UnsupportedRDFormatException e) {
            // Ignore to drop this format from the list
        }
    }
    assertFalse("No RDFFormats found with RDFParser implementations on classpath", result.isEmpty());
    return result;
}
 

import org.openrdf.rio.UnsupportedRDFormatException; //导入依赖的package包/类
@Test(expected = UnsupportedRDFormatException.class)
public void test_invalidFile() throws Exception {
    try(final Producer<?, VisibilityStatement> producer =
            KafkaTestUtil.makeProducer(rule, StringSerializer.class, VisibilityStatementSerializer.class)) {
        final KafkaLoadStatements command = new KafkaLoadStatements(rule.getKafkaTopicName(), producer);
        command.fromFile(INVALID, "a|b|c");
    }
}
 

import org.openrdf.rio.UnsupportedRDFormatException; //导入依赖的package包/类
public static void main(String[] args) throws RDFParseException, UnsupportedRDFormatException, IOException,
        RepositoryException, ReferringExpressionException, RDFHandlerException {

    Options options = new Options();
    new JCommander(options, args);

    FileInputStream in = new FileInputStream(options.rdf);

    Model m = Rio.parse(in, "http://localhost/", RDFFormat.NTRIPLES);

    ReferringExpressionAlgorithm algorithm = null;
    if (options.algorithm.equals(DaleReiterAlgorithm.class.getName())) {
        algorithm = new DaleReiterAlgorithm(TypePriorities.dbPediaPriorities, TypePriorities.dbPediaIgnored);
        if (options.verbose)
            ((ch.qos.logback.classic.Logger) DaleReiterAlgorithm.logger).setLevel(Level.DEBUG);
    } else if (options.algorithm.equals(GardentAlgorithm.class.getName())) {
        algorithm = new GardentAlgorithm(TypePriorities.dbPediaPriorities, TypePriorities.dbPediaIgnored);
        if (options.verbose)
            ((ch.qos.logback.classic.Logger) GardentAlgorithm.logger).setLevel(Level.DEBUG);
    } else if (options.algorithm.equals(GraphAlgorithm.class.getName())) {
        algorithm = new GraphAlgorithm(TypePriorities.dbPediaPriorities, TypePriorities.dbPediaIgnored);
        if (options.verbose)
            ((ch.qos.logback.classic.Logger) GraphAlgorithm.logger).setLevel(Level.DEBUG);
    } else {
        System.err.println("Unknown algorithm '" + options.algorithm + "'");
        System.exit(-1);
    }

    Repository rep = new SailRepository(new MemoryStore());
    rep.initialize();
    ValueFactory f = rep.getValueFactory();

    List<URI> confusors = new ArrayList<URI>(options.confusors.size());
    for (String confusor : options.confusors)
        confusors.add(f.createURI(confusor));

    RepositoryConnection conn = rep.getConnection();
    try {
        conn.add(m);

        URI referent = f.createURI(options.referent);

        if (options.type != null)
            conn.add(referent, RDF.TYPE, f.createURI(options.type));

        ReferringExpression r = algorithm.resolve(referent, confusors, conn);
        System.out.println(r);
    } finally {
        conn.close();
    }

}
 

import org.openrdf.rio.UnsupportedRDFormatException; //导入依赖的package包/类
public RdfWriter(RDFFormat format, OutputStream output)
		throws UnsupportedRDFormatException {
	this.writer = Rio.createWriter(format, output);
}
 

import org.openrdf.rio.UnsupportedRDFormatException; //导入依赖的package包/类
/**
 * Wrap a {@link org.apache.marmotta.commons.sesame.test.base.AbstractRepositoryConnectionMatcher} with a {@link org.apache.marmotta.commons.sesame.test.base.RdfStringMatcher},
 * to match the provided matcher against an serialized RDF-String.
 *
 * @param mimeType the MimeType used to guess the RDFFormat for de-serializing the RDF
 * @param baseUri  the baseUri used for de-serializing the RDF
 * @param matchers the Matchers to wrap
 * @see Rio#getParserFormatForMIMEType(String)
 * @see org.apache.marmotta.commons.sesame.test.base.RdfStringMatcher#wrap(org.openrdf.rio.RDFFormat, String, org.hamcrest.Matcher)
 */
@SafeVarargs
public static <T extends String, V extends RepositoryConnection> Matcher<T> rdfStringMatches(String mimeType, String baseUri, Matcher<V>... matchers) {
    final RDFFormat format = Rio.getParserFormatForMIMEType(mimeType);
    if (format == null) throw new UnsupportedRDFormatException(mimeType);
    return RdfStringMatcher.wrap(format, baseUri, CoreMatchers.allOf(matchers));
}