Fork of https://github.com/oxigraph/oxigraph.git for the purpose of NextGraph project
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
oxigraph/tests/rdf_test_cases.rs

428 lines
14 KiB

extern crate reqwest;
extern crate rudf;
extern crate url;
use reqwest::Client;
use rudf::model::data::*;
use rudf::model::vocab::rdf;
use rudf::rio::RioError;
use rudf::rio::RioResult;
use rudf::rio::ntriples::read_ntriples;
use rudf::rio::turtle::read_turtle;
use std::collections::BTreeSet;
use std::collections::HashMap;
use std::collections::HashSet;
use std::collections::hash_map::DefaultHasher;
use std::fmt;
use std::hash::Hash;
use std::hash::Hasher;
use std::iter::FromIterator;
use std::str::FromStr;
use url::Url;
struct RDFClient {
client: Client,
}
impl Default for RDFClient {
fn default() -> Self {
Self {
client: Client::new(),
}
}
}
impl RDFClient {
fn load_turtle(&self, uri: Url) -> RioResult<HashSet<Triple>> {
match self.client.get(uri.clone()).send() {
Ok(response) => Ok(HashSet::from_iter(read_turtle(response, Some(uri))?)),
Err(error) => Err(RioError::new(error)),
}
}
fn load_ntriples(&self, uri: Url) -> RioResult<HashSet<Triple>> {
match self.client.get(uri).send() {
Ok(response) => read_ntriples(response).collect(),
Err(error) => Err(RioError::new(error)),
}
}
}
#[derive(Eq, PartialEq, Clone)]
struct Graph(HashSet<Triple>);
impl fmt::Display for Graph {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
for triple in &self.0 {
write!(fmt, "{}\n", triple)?;
}
Ok(())
}
}
#[derive(Eq, PartialEq, Hash, Ord, PartialOrd)]
struct SubjectPredicate<'a> {
subject: &'a NamedOrBlankNode,
predicate: &'a NamedNode,
}
impl<'a> SubjectPredicate<'a> {
fn new(subject: &'a NamedOrBlankNode, predicate: &'a NamedNode) -> Self {
Self { subject, predicate }
}
}
#[derive(Eq, PartialEq, Hash, Ord, PartialOrd)]
struct PredicateObject<'a> {
predicate: &'a NamedNode,
object: &'a Term,
}
impl<'a> PredicateObject<'a> {
fn new(predicate: &'a NamedNode, object: &'a Term) -> Self {
Self { predicate, object }
}
}
fn objects_for_subject_predicate<'a>(
graph: &'a HashSet<Triple>,
subject: &'a NamedOrBlankNode,
predicate: &'a NamedNode,
) -> impl Iterator<Item = &'a Term> {
graph
.iter()
.filter(move |t| t.subject() == subject && t.predicate() == predicate)
.map(|t| t.object())
}
fn object_for_subject_predicate<'a>(
graph: &'a HashSet<Triple>,
subject: &'a NamedOrBlankNode,
predicate: &'a NamedNode,
) -> Option<&'a Term> {
objects_for_subject_predicate(graph, subject, predicate).nth(0)
}
fn subjects_for_predicate_object<'a>(
graph: &'a HashSet<Triple>,
predicate: &'a NamedNode,
object: &'a Term,
) -> impl Iterator<Item = &'a NamedOrBlankNode> {
graph
.iter()
.filter(move |t| t.predicate() == predicate && t.object() == object)
.map(|t| t.subject())
}
fn subject_for_predicate_object<'a>(
graph: &'a HashSet<Triple>,
predicate: &'a NamedNode,
object: &'a Term,
) -> Option<&'a NamedOrBlankNode> {
subjects_for_predicate_object(graph, predicate, object).nth(0)
}
fn subject_predicates_for_object<'a>(
graph: &'a HashSet<Triple>,
object: &'a Term,
) -> impl Iterator<Item = SubjectPredicate<'a>> {
graph
.iter()
.filter(move |t| t.object() == object)
.map(|t| SubjectPredicate::new(t.subject(), t.predicate()))
}
fn predicate_objects_for_subject<'a>(
graph: &'a HashSet<Triple>,
subject: &'a NamedOrBlankNode,
) -> impl Iterator<Item = PredicateObject<'a>> {
graph
.iter()
.filter(move |t| t.subject() == subject)
.map(|t| PredicateObject::new(t.predicate(), t.object()))
}
fn hash_blank_nodes<'a>(
bnodes: HashSet<&'a BlankNode>,
graph: &'a HashSet<Triple>,
) -> HashMap<u64, Vec<&'a BlankNode>> {
let mut bnodes_by_hash: HashMap<u64, Vec<&BlankNode>> = HashMap::default();
// NB: we need to sort the triples to have the same hash
for bnode in bnodes.into_iter() {
let mut hasher = DefaultHasher::new();
{
let subject = NamedOrBlankNode::from(bnode.clone());
let mut po_set: BTreeSet<PredicateObject> = BTreeSet::default();
for po in predicate_objects_for_subject(&graph, &subject) {
if !po.object.is_blank_node() {
po_set.insert(po);
}
}
for po in po_set {
po.hash(&mut hasher);
}
}
{
let object = Term::from(bnode.clone());
let mut sp_set: BTreeSet<SubjectPredicate> = BTreeSet::default();
for sp in subject_predicates_for_object(&graph, &object) {
if !sp.subject.is_blank_node() {
sp_set.insert(sp);
}
}
for sp in sp_set {
sp.hash(&mut hasher);
}
}
bnodes_by_hash
.entry(hasher.finish())
.or_insert_with(Vec::default)
.push(bnode);
}
bnodes_by_hash
}
//TODO: use a better datastructure
fn is_isomorphic(a: &HashSet<Triple>, b: &HashSet<Triple>) -> bool {
if a.len() != b.len() {
return false;
}
let mut a_bnodes: HashSet<&BlankNode> = HashSet::default();
let mut b_bnodes: HashSet<&BlankNode> = HashSet::default();
for t in a {
if let NamedOrBlankNode::BlankNode(subject) = t.subject() {
a_bnodes.insert(subject);
if let Term::BlankNode(object) = t.object() {
a_bnodes.insert(object);
}
} else if let Term::BlankNode(object) = t.object() {
a_bnodes.insert(object);
} else if !b.contains(t) {
return false;
}
}
for t in b {
if let NamedOrBlankNode::BlankNode(subject) = t.subject() {
b_bnodes.insert(subject);
if let Term::BlankNode(object) = t.object() {
b_bnodes.insert(object);
}
} else if let Term::BlankNode(object) = t.object() {
b_bnodes.insert(object);
} else if !a.contains(t) {
return false;
}
}
let a_bnodes_by_hash = hash_blank_nodes(a_bnodes, &a);
let b_bnodes_by_hash = hash_blank_nodes(b_bnodes, &b);
if a_bnodes_by_hash.len() != b_bnodes_by_hash.len() {
return false;
}
for hash in a_bnodes_by_hash.keys() {
if a_bnodes_by_hash.get(hash).map(|l| l.len())
!= b_bnodes_by_hash.get(hash).map(|l| l.len())
{
return false;
}
}
//TODO: proper isomorphism building
true
}
#[test]
fn turtle_w3c_testsuite() {
let manifest_url = Url::parse("http://www.w3.org/2013/TurtleTests/manifest.ttl").unwrap();
let client = RDFClient::default();
let manifest = client.load_turtle(manifest_url.clone()).unwrap();
let mf_action = NamedNode::from_str(
"http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#action",
).unwrap();
let mf_result = NamedNode::from_str(
"http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#result",
).unwrap();
let rdfs_comment = NamedNode::from_str("http://www.w3.org/2000/01/rdf-schema#comment").unwrap();
let rdft_test_turtle_positive_syntax = Term::from(
NamedNode::from_str("http://www.w3.org/ns/rdftest#TestTurtlePositiveSyntax").unwrap(),
);
let rdft_test_turtle_negative_syntax = Term::from(
NamedNode::from_str("http://www.w3.org/ns/rdftest#TestTurtleNegativeSyntax").unwrap(),
);
let rdft_test_turtle_eval =
Term::from(NamedNode::from_str("http://www.w3.org/ns/rdftest#TestTurtleEval").unwrap());
let rdft_test_turtle_negative_eval = Term::from(
NamedNode::from_str("http://www.w3.org/ns/rdftest#TestTurtleNegativeEval").unwrap(),
);
//TODO: make blacklist pass
let test_blacklist: Vec<NamedOrBlankNode> = vec![
//UTF-8 broken surrogates in BNode ids
NamedNode::new(
manifest_url
.join("#prefix_with_PN_CHARS_BASE_character_boundaries")
.unwrap(),
).into(),
NamedNode::new(
manifest_url
.join("#labeled_blank_node_with_PN_CHARS_BASE_character_boundaries")
.unwrap(),
).into(),
NamedNode::new(
manifest_url
.join("#localName_with_assigned_nfc_PN_CHARS_BASE_character_boundaries")
.unwrap(),
).into(),
NamedNode::new(
manifest_url
.join("#localName_with_nfc_PN_CHARS_BASE_character_boundaries")
.unwrap(),
).into(),
];
subjects_for_predicate_object(&manifest, &rdf::TYPE, &rdft_test_turtle_positive_syntax)
.for_each(|test| {
let comment = object_for_subject_predicate(&manifest, test, &rdfs_comment).unwrap();
if let Some(Term::NamedNode(file)) =
object_for_subject_predicate(&manifest, test, &mf_action)
{
if let Err(error) = client.load_turtle(file.url().clone()) {
assert!(
false,
"Failure on positive syntax file {} about {} with error: {}",
file, comment, error
)
}
}
});
subjects_for_predicate_object(&manifest, &rdf::TYPE, &rdft_test_turtle_negative_syntax)
.for_each(|test| {
let comment = object_for_subject_predicate(&manifest, test, &rdfs_comment).unwrap();
if let Some(Term::NamedNode(file)) =
object_for_subject_predicate(&manifest, test, &mf_action)
{
assert!(
client.load_turtle(file.url().clone()).is_err(),
"Failure on negative syntax test file {} about {}",
file,
comment
);
}
});
subjects_for_predicate_object(&manifest, &rdf::TYPE, &rdft_test_turtle_eval).for_each(|test| {
if test_blacklist.contains(test) {
return;
}
let comment = object_for_subject_predicate(&manifest, test, &rdfs_comment).unwrap();
if let Some(Term::NamedNode(input)) =
object_for_subject_predicate(&manifest, test, &mf_action)
{
if let Some(Term::NamedNode(result)) =
object_for_subject_predicate(&manifest, test, &mf_result)
{
match client.load_turtle(input.url().clone()) {
Ok(action_graph) => match client.load_turtle(result.url().clone()) {
Ok(result_graph) => assert!(
is_isomorphic(&action_graph, &result_graph),
"Failure on positive evaluation test file {} against {} about {}. Expected file:\n{}\nParsed file:\n{}\n",
input,
result,
comment,
Graph(action_graph),
Graph(result_graph)
),
Err(error) => assert!(
false,
"Failure to parse the Turtle result file {} about {} with error: {}",
result, comment, error
)
},
Err(error) => assert!(
false,
"Failure to parse the Turtle input file {} about {} with error: {}",
input, comment, error
)
}
}
}
});
subjects_for_predicate_object(&manifest, &rdf::TYPE, &rdft_test_turtle_negative_eval).for_each(
|test| {
let comment = object_for_subject_predicate(&manifest, test, &rdfs_comment).unwrap();
if let Some(Term::NamedNode(file)) =
object_for_subject_predicate(&manifest, test, &mf_action)
{
if let Some(Term::NamedNode(result)) =
object_for_subject_predicate(&manifest, test, &mf_result)
{
let action_graph = client.load_turtle(file.url().clone());
let result_graph = client.load_turtle(result.url().clone());
assert!(
!is_isomorphic(&action_graph.unwrap(), &result_graph.unwrap()),
"Failure on positive evaluation test file {} about {}",
file,
comment
);
}
}
},
);
}
#[test]
fn ntriples_w3c_testsuite() {
let client = RDFClient::default();
let manifest = client
.load_turtle(Url::parse("http://www.w3.org/2013/N-TriplesTests/manifest.ttl").unwrap())
.unwrap();
let mf_action = NamedNode::from_str(
"http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#action",
).unwrap();
let rdfs_comment = NamedNode::from_str("http://www.w3.org/2000/01/rdf-schema#comment").unwrap();
let rdft_test_ntriples_positive_syntax = Term::from(
NamedNode::from_str("http://www.w3.org/ns/rdftest#TestNTriplesPositiveSyntax").unwrap(),
);
let rdft_test_ntriples_negative_syntax = Term::from(
NamedNode::from_str("http://www.w3.org/ns/rdftest#TestNTriplesNegativeSyntax").unwrap(),
);
subjects_for_predicate_object(&manifest, &rdf::TYPE, &rdft_test_ntriples_positive_syntax)
.for_each(|test| {
let comment = object_for_subject_predicate(&manifest, test, &rdfs_comment).unwrap();
if let Some(Term::NamedNode(file)) =
object_for_subject_predicate(&manifest, test, &mf_action)
{
if let Err(error) = client.load_ntriples(file.url().clone()) {
assert!(
false,
"Failure on positive syntax file {} about {} with error: {}",
file, comment, error
)
}
}
});
subjects_for_predicate_object(&manifest, &rdf::TYPE, &rdft_test_ntriples_negative_syntax)
.for_each(|test| {
let comment = object_for_subject_predicate(&manifest, test, &rdfs_comment).unwrap();
if let Some(Term::NamedNode(file)) =
object_for_subject_predicate(&manifest, test, &mf_action)
{
assert!(
client.load_ntriples(file.url().clone()).is_err(),
"Failure on negative syntax test file {} about {}",
file,
comment
);
}
});
}