/** * Tests the correct behaviour with no context. */ @Test public void testParseNoContext() throws RDFHandlerException, IOException, RDFParseException { final ByteArrayInputStream bais = new ByteArrayInputStream( "<http://s> <http://p> <http://o> .".getBytes()); parser.parse(bais, "http://base-uri"); }
private void verifyStatementWithInvalidDatatype(boolean useDatatypeVerification) throws RDFHandlerException, IOException, RDFParseException { TestRDFHandler rdfHandler = new TestRDFHandler(); parser.setRDFHandler(rdfHandler); parser.getParserConfig().set(BasicParserSettings.VERIFY_DATATYPE_VALUES, useDatatypeVerification); parser.getParserConfig().set(BasicParserSettings.FAIL_ON_UNKNOWN_DATATYPES, useDatatypeVerification); if (!useDatatypeVerification) { parser.getParserConfig().addNonFatalError(BasicParserSettings.VERIFY_DATATYPE_VALUES); parser.getParserConfig().addNonFatalError(BasicParserSettings.FAIL_ON_UNKNOWN_DATATYPES); } final ByteArrayInputStream bais = new ByteArrayInputStream( ("<http://dbpedia.org/resource/Camillo_Benso,_conte_di_Cavour> " + "<http://dbpedia.org/property/mandatofine> " + "\"1380.0\"^^<http://dbpedia.org/invalid/datatype/second> " + "<http://it.wikipedia.org/wiki/Camillo_Benso,_conte_di_Cavour#absolute-line=20> .").getBytes()); parser.parse(bais, "http://base-uri"); rdfHandler.assertHandler(1); }
protected final Set<Statement> readExpectedGraphQueryResult() throws Exception { RDFFormat rdfFormat = Rio.getParserFormatForFileName(resultFileURL).orElseThrow( Rio.unsupportedFormat(resultFileURL)); RDFParser parser = Rio.createParser(rdfFormat); parser.setDatatypeHandling(DatatypeHandling.IGNORE); parser.setPreserveBNodeIDs(true); parser.setValueFactory(dataRep.getValueFactory()); Set<Statement> result = new LinkedHashSet<Statement>(); parser.setRDFHandler(new StatementCollector(result)); InputStream in = new URL(resultFileURL).openStream(); try { parser.parse(in, resultFileURL); } finally { in.close(); } return result; }
/** * Apply the options to the parser. * * @param p * The parser. */ synchronized public void apply(final RDFParser p) { p.setDatatypeHandling(datatypeHandling); p.setPreserveBNodeIDs(preserveBNodeIDs); p.setStopAtFirstError(stopAtFirstError); p.setVerifyData(verifyData); }
public static void loadDataset(IDataset dataset, InputStream rdf, RDFFormat format,String baseURI,int batchSize) throws Exception { DatasetStatementCollection sc = new DatasetStatementCollection(batchSize,dataset); RDFParser parser = Rio.createParser(format); parser.setRDFHandler(sc); parser.setValueFactory(Constants.valueFactory); parser.parse(rdf,baseURI); }
/** * Creates a new RDFParserBase that will use the supplied ValueFactory to * create RDF model objects. * * @param valueFactory A ValueFactory. */ public GeonamesParser(ValueFactory valueFactory) { super(valueFactory); lineParser = Rio.createParser(RDFFormat.RDFXML); lineParser.setParseErrorListener(this); lineParser.setValueFactory(valueFactory); lineParser.setParserConfig(getParserConfig()); }
/** * Tests parsing of empty lines and comments. */ @Test public void testParseEmptyLinesAndComments() throws RDFHandlerException, IOException, RDFParseException { final ByteArrayInputStream bais = new ByteArrayInputStream( " \n\n\n# This is a comment\n\n#this is another comment.".getBytes()); final TestRDFHandler rdfHandler = new TestRDFHandler(); parser.setRDFHandler(rdfHandler); parser.parse(bais, "http://test.base.uri"); Assert.assertEquals(rdfHandler.getStatements().size(), 0); }
@Test public void testStatementWithInvalidLiteralContentAndIgnoreValidation() throws RDFHandlerException, IOException, RDFParseException { // Note: Float declare as int. final ByteArrayInputStream bais = new ByteArrayInputStream( ("<http://dbpedia.org/resource/Camillo_Benso,_conte_di_Cavour> " + "<http://dbpedia.org/property/mandatofine> " + "\"1380.0\"^^<http://www.w3.org/2001/XMLSchema#int> " + "<http://it.wikipedia.org/wiki/Camillo_Benso,_conte_di_Cavour#absolute-line=20> .").getBytes()); parser.getParserConfig().set(BasicParserSettings.VERIFY_DATATYPE_VALUES, false); parser.getParserConfig().set(BasicParserSettings.FAIL_ON_UNKNOWN_DATATYPES, false); parser.parse(bais, "http://base-uri"); }
/** * Tests the correct support for literal escaping. */ @Test public void testLiteralEscapeManagement1() throws RDFHandlerException, IOException, RDFParseException { TestParseLocationListener parseLocationListener = new TestParseLocationListener(); TestRDFHandler rdfHandler = new TestRDFHandler(); parser.setParseLocationListener(parseLocationListener); parser.setRDFHandler(rdfHandler); final ByteArrayInputStream bais = new ByteArrayInputStream( "<http://a> <http://b> \"\\\\\" <http://c> .".getBytes()); parser.parse(bais, "http://base-uri"); rdfHandler.assertHandler(1); // parseLocationListener.assertListener(1, 40); // FIXME: Enable column numbers when parser supports them parseLocationListener.assertListener(1, 1); }
private void testSES2030BNodeCollisionsInternal(boolean preserveBNodeIDs) throws Exception { ByteArrayOutputStream output = new ByteArrayOutputStream(); RDFWriter rdfWriter = rdfWriterFactory.getWriter(output); setupWriterConfig(rdfWriter.getWriterConfig()); rdfWriter.startRDF(); int count = 18; for (int i = 0; i < count; i++) { BNode bNode2 = vf.createBNode("a" + Integer.toHexString(i).toUpperCase()); // System.out.println(bNode2.getID()); rdfWriter.handleStatement(vf.createStatement(uri1, uri2, bNode2)); } rdfWriter.endRDF(); RDFParser rdfParser = rdfParserFactory.getParser(); setupParserConfig(rdfParser.getParserConfig()); if (preserveBNodeIDs) { rdfParser.getParserConfig().set(BasicParserSettings.PRESERVE_BNODE_IDS, true); } Model parsedModel = new LinkedHashModel(); rdfParser.setRDFHandler(new StatementCollector(parsedModel)); rdfParser.parse(new ByteArrayInputStream(output.toByteArray()), ""); // if(potentialObjects.size() != parsedModel.size()) { if (count != parsedModel.size()) { Rio.write(parsedModel, System.out, RDFFormat.NQUADS); } assertEquals(count, parsedModel.size()); // assertEquals(potentialObjects.size(), parsedModel.size()); }
@Test public void testBlankNodeIdentifiersRDF11() throws Exception { RDFParser ntriplesParser = createRDFParser(); Model model = new LinkedHashModel(); ntriplesParser.setRDFHandler(new StatementCollector(model)); ntriplesParser.parse(new StringReader("_:123 <urn:test:predicate> _:456 ."), "http://example/"); assertEquals(1, model.size()); }
/** * Load triples from TURTLE file to graph * * @param handler * @param format * @throws java.io.IOException * @throws org.openrdf.rio.RDFParseException * @throws org.openrdf.rio.RDFHandlerException */ public void loadWithSesame(RDFHandlerBase handler, RDFFormat format) throws IOException, RDFParseException, RDFHandlerException { RDFParser parser = Rio.createParser(format); ParserConfig config = new ParserConfig(); config.set(BasicParserSettings.PRESERVE_BNODE_IDS, true); config.addNonFatalError(NTriplesParserSettings.FAIL_ON_NTRIPLES_INVALID_LINES); parser.setParserConfig(config); parser.setRDFHandler(handler); //System.out.println(this.base+format); parser.parse(this.reader, this.base); } }
@Test public void testNTriplesFile() throws Exception { RDFParser ntriplesParser = createRDFParser(); ntriplesParser.setDatatypeHandling(RDFParser.DatatypeHandling.IGNORE); Model model = new LinkedHashModel(); ntriplesParser.setRDFHandler(new StatementCollector(model)); InputStream in = this.getClass().getResourceAsStream(NTRIPLES_TEST_FILE); try { ntriplesParser.parse(in, NTRIPLES_TEST_URL); } catch (RDFParseException e) { fail("Failed to parse N-Triples test document: " + e.getMessage()); } finally { in.close(); } assertEquals(30, model.size()); assertEquals(28, model.subjects().size()); assertEquals(1, model.predicates().size()); assertEquals(23, model.objects().size()); }
@Test public void testExceptionHandlingWithoutStopAtFirstError() throws Exception { String data = "invalid nt"; RDFParser ntriplesParser = createRDFParser(); ntriplesParser.getParserConfig().addNonFatalError(NTriplesParserSettings.FAIL_ON_NTRIPLES_INVALID_LINES); ntriplesParser.getParserConfig().set(NTriplesParserSettings.FAIL_ON_NTRIPLES_INVALID_LINES, Boolean.TRUE); Model model = new LinkedHashModel(); ntriplesParser.setRDFHandler(new StatementCollector(model)); ntriplesParser.parse(new StringReader(data), NTRIPLES_TEST_URL); assertEquals(0, model.size()); assertEquals(0, model.subjects().size()); assertEquals(0, model.predicates().size()); assertEquals(0, model.objects().size()); }
throws IOException, RDFParseException, UnsupportedRDFormatException Model result = new LinkedHashModel(); RDFParser parser = createParser(dataFormat, valueFactory); parser.setParserConfig(settings); parser.setParseErrorListener(errors); parser.setRDFHandler(new ContextStatementCollector(result, valueFactory, contexts)); parser.parse(in, baseURI); return result;
private void addData(final RepositoryConnection conn) throws IOException, RDFParseException, RepositoryException, RDFHandlerException { final RDFParser rdfParser = Rio.createParser(RDFFormat.NTRIPLES, conn.getValueFactory()); rdfParser.setVerifyData(true); rdfParser.setStopAtFirstError(true); rdfParser.setDatatypeHandling(RDFParser.DatatypeHandling.IGNORE); rdfParser.setRDFHandler(new RDFHandlerBase() { @Override public void handleStatement(Statement st) throws RDFHandlerException { try { conn.add(st); } catch (OpenRDFException e) { throw new RDFHandlerException(e); } } }); rdfParser.parse(getClass().getResourceAsStream("TestTicket276.n3"), ""); } }
private long parseRdfContent(final InputStream content, final RDFFormat format) throws RDFParseException, IOException, RDFHandlerException { RDFParser parser = Rio.createParser(format); parser.getParserConfig().set(BasicParserSettings.VERIFY_DATATYPE_VALUES, false); ParsedRDFHandler parsedRDFHandler = new ParsedRDFHandler(); parsedRDFHandler.clear(); parser.setRDFHandler(parsedRDFHandler); parser.parse(content, BASE_IRI); return parsedRDFHandler.getCount(); }
/** * Constructor to start parsing R2RML mappings from file. * @param file - the File object */ public R2RMLManager(File file) throws Exception { myModel = new LinkedHashModel(); RDFParser parser = Rio.createParser(RDFFormat.TURTLE); InputStream in = new FileInputStream(file); URL documentUrl = new URL("file://" + file); StatementCollector collector = new StatementCollector(myModel); parser.setRDFHandler(collector); parser.parse(in, documentUrl.toString()); r2rmlParser = new R2RMLParser(); }
public static void parse(final InputStream is, final RDFSink sink, final String baseUri, final RDFFormat format) throws RippleException { RDFParser parser = Rio.createParser(format); parser.setRDFHandler(new SesameInputAdapter(sink)); try { parser.parse(is, baseUri); } catch (IOException | RDFParseException | RDFHandlerException e) { throw new RippleException(e); } } }
RDFParser parser = Rio.createParser(format, valueFactory); parser.setParserConfig(parser.getParserConfig()); StatementCollector collector = new StatementCollector(); parser.setRDFHandler(collector); _classUnderTest.service(request, response); parser.parse(new FileInputStream(tmp), method.getURI().getURI()); assertTrue(!collector.getStatements().isEmpty()); verify(response).setStatus(HttpServletResponse.SC_OK);