/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jena.riot;
import java.io.FileInputStream ;
import java.io.IOException ;
import java.io.StringReader ;
import java.nio.file.Paths ;
import org.apache.jena.atlas.junit.BaseTest ;
import org.apache.jena.atlas.lib.IRILib ;
import org.apache.jena.atlas.lib.StrUtils ;
import org.apache.jena.atlas.web.TypedInputStream ;
import org.apache.jena.rdf.model.Model ;
import org.apache.jena.rdf.model.ModelFactory ;
import org.apache.jena.rdf.model.Resource ;
import org.apache.jena.riot.adapters.RDFReaderFactoryRIOT ;
import org.apache.jena.sparql.util.Context ;
import org.apache.jena.util.FileUtils ;
import org.junit.Test ;
/* Test of integration with Jena via model.read.
* Also tests triples format reading of RDFDataMgr */
public class TestJenaReaderRIOT extends BaseTest
{
private static final String directory = "testing/RIOT/Reader" ;
private static Context context = new Context() ;
@Test public void read_01() { jenaread("D.nt") ; }
@Test public void read_02() { jenaread("D.ttl") ; }
@Test public void read_03() { jenaread("D.rdf") ; }
@Test public void read_04() { jenaread("D.rdf") ; }
@Test public void read_05() { jenaread("D.rj") ; }
@Test public void read_06() { jenaread("D.jsonld") ; }
@Test public void read_11() { jenaread("D.nt", "N-TRIPLES") ; }
@Test public void read_12() { jenaread("D.ttl", "TTL") ; }
@Test public void read_13() { jenaread("D.rdf", "RDF/XML") ; }
@Test public void read_14() { jenaread("D.rdf", "RDF/XML-ABBREV") ; }
@Test public void read_15() { jenaread("D.rj", "RDF/JSON") ; }
@Test public void read_16() { jenaread("D.jsonld", "JSON-LD") ; }
@Test public void read_21a() { jenaread("D-nt", "N-TRIPLES") ; }
@Test public void read_21b() { jenaread("D-nt", "NTRIPLES") ; }
@Test public void read_21c() { jenaread("D-nt", "NT") ; }
@Test public void read_21d() { jenaread("D-nt", "N-Triples") ; }
@Test public void read_22a() { jenaread("D-ttl", "TURTLE") ; }
@Test public void read_22b() { jenaread("D-ttl", "TTL") ; }
@Test public void read_23a() { jenaread("D-rdf", "RDF/XML") ; }
@Test public void read_23b() { jenaread("D-rdf", "RDFXML") ; }
@Test public void read_24() { jenaread("D-json", "RDF/JSON") ; }
@Test public void read_30()
{
{
TypedInputStream in = RDFDataMgr.open(filename("D-not-TTL.ttl") );
Model m0 = ModelFactory.createDefaultModel() ;
RDFDataMgr.read(m0, in, RDFLanguages.RDFXML) ;
}
TypedInputStream in1 = RDFDataMgr.open(filename("D-not-TTL.ttl") );
Model m1 = ModelFactory.createDefaultModel() ;
// Fails until integration with jena-core as hintlang gets lost.
m1.read(in1, null, "RDF/XML") ;
}
// test read from StringReader..
@Test public void read_StringReader_31()
{
String x = "<s> <p> <p> ." ;
{
StringReader s = new StringReader(x) ;
Model m = ModelFactory.createDefaultModel() ;
RDFDataMgr.read(m, s, null, RDFLanguages.NTRIPLES) ;
}
StringReader s1 = new StringReader("<s> <p> <p> .") ;
Model m1 = ModelFactory.createDefaultModel() ;
m1.read(s1, null, "N-TRIPLES") ;
}
@Test public void read_StringReader_32()
{
String x = StrUtils.strjoinNL(
"<rdf:RDF",
" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"",
" xmlns:j.0=\"http://example/\">" ,
" <rdf:Description rdf:about=\"http://example/s\">" ,
" <j.0:p rdf:resource=\"http://example/o\"/>" ,
" </rdf:Description>" ,
"</rdf:RDF>") ;
{
StringReader s = new StringReader(x) ;
Model m = ModelFactory.createDefaultModel() ;
RDFDataMgr.read(m, s, null, RDFLanguages.RDFXML) ;
}
StringReader s1 = new StringReader(x) ;
Model m = ModelFactory.createDefaultModel() ;
m.read(s1, null, "RDF/XML") ;
}
// Stream opening is hardwired into jena!
@Test public void read_base_1()
{ jenaread("D-no-base.ttl", "TTL", "http://baseuri/") ; }
@Test public void read_input_1() throws IOException
{ jenaread_stream("D.ttl", "TTL") ; }
@Test public void read_input_2() throws IOException
{ jenaread_stream("D.rdf", "RDF/XML") ; }
private static String plainRelFnTTL = directory+"/D.ttl" ;
private static String plainRelFnRDFXML = directory+"/D.rdf" ;
// Ways to pass in the filename.
// The RDF/XML path is slightly different so test it as well.
@Test public void read_url_1() {
modelRead(plainRelFnTTL) ;
}
@Test public void read_url_1x() {
modelRead(plainRelFnRDFXML) ;
}
@Test public void read_url_2() {
modelRead("file:"+plainRelFnTTL) ;
}
@Test public void read_url_2x() {
modelRead("file:"+plainRelFnRDFXML) ;
}
@Test public void read_url_3() {
String cwd = Paths.get(".").toAbsolutePath().normalize().toString() ;
modelRead("file:"+cwd+"/"+plainRelFnTTL) ;
}
@Test public void read_url_3x() {
String cwd = Paths.get(".").toAbsolutePath().normalize().toString() ;
modelRead("file:"+cwd+"/"+plainRelFnRDFXML) ;
}
@Test public void read_url_4() {
String cwd = Paths.get(".").toAbsolutePath().normalize().toString() ;
String fn = "file:"+cwd+"/"+plainRelFnTTL ;
String fn2 = IRILib.filenameToIRI(fn) ;
modelRead(fn2) ;
}
@Test public void read_url_4x() {
String cwd = Paths.get(".").toAbsolutePath().normalize().toString() ;
String fn = "file:"+cwd+"/"+plainRelFnRDFXML ;
String fn2 = IRILib.filenameToIRI(fn) ;
modelRead(fn2) ;
}
private static Model modelRead(String fn) {
Model m = ModelFactory.createDefaultModel();
m.read(fn) ;
return m ;
}
// -----------------------------------------
private static String filename(String filename) { return directory+"/"+filename ; }
private static void jenaread_stream(String filename, String lang) throws IOException {
filename = filename(filename);
// Read with a base
try (FileInputStream in0 = new FileInputStream(filename)) {
Model m0 = ModelFactory.createDefaultModel();
RDFDataMgr.read(m0, in0, "http://example/base2", RDFLanguages.nameToLang(lang));
}
// Read again, but without base
try (FileInputStream in1 = new FileInputStream(filename)) {
Model m1 = ModelFactory.createDefaultModel();
RDFDataMgr.read(m1, in1, RDFLanguages.nameToLang(lang));
}
// Read via Jena API.
Model m2 = ModelFactory.createDefaultModel();
try (FileInputStream in2 = new FileInputStream(filename)) {
m2.read(in2, "http://example/base3", lang);
}
String x = FileUtils.readWholeFileAsUTF8(filename);
Model m3 = ModelFactory.createDefaultModel();
m2.read(new StringReader(x), "http://example/base4", lang);
}
private static void jenaread(String dataurl) {
dataurl = filename(dataurl);
Model m = ModelFactory.createDefaultModel();
m.read(dataurl);
assertTrue(m.size() != 0);
}
private static void jenaread(String dataurl, String lang) {
// read via WebReader to make sure the test setup is right.
dataurl = filename(dataurl);
Model m0 = ModelFactory.createDefaultModel();
RDFDataMgr.read(m0, dataurl, RDFLanguages.nameToLang(lang));
assertTrue(m0.size() != 0);
Model m1 = ModelFactory.createDefaultModel();
new RDFReaderFactoryRIOT().getReader(lang).read(m1, dataurl);
assertTrue(m1.size() != 0);
// Read via Jena model API.
Model m2 = ModelFactory.createDefaultModel();
// The range of names for mode.read is less - canonicalise the language
// name.
String x = RDFLanguages.nameToLang(lang).getName();
m2.read(dataurl, x);
assertTrue(m2.size() != 0);
}
private static void jenaread(String dataurl, String lang, String base) {
dataurl = filename(dataurl) ;
Model m1 = ModelFactory.createDefaultModel() ;
Model m2 = ModelFactory.createDefaultModel() ;
// This call
RDFDataMgr.read(m1, dataurl, base, RDFLanguages.nameToLang(lang)) ;
// should be an implementation of:
m2.read("file:"+dataurl, base, lang) ;
assertTrue(m1.size() != 0 ) ;
assertTrue(m2.size() != 0 ) ;
assertTrue(m1.isIsomorphicWith(m2)) ;
// and check base processing ...
Resource s = m1.listStatements().next().getSubject() ;
assertTrue(s.getURI().startsWith("http://")) ;
assertTrue(s.getURI().equals("http://baseuri/s")) ;
}
}