| /* |
| * 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.graph.test; |
| |
| import org.apache.jena.graph.* ; |
| import org.apache.jena.rdf.model.impl.ReifierStd ; |
| import org.apache.jena.shared.AlreadyReifiedException ; |
| import org.apache.jena.shared.CannotReifyException ; |
| import org.apache.jena.vocabulary.RDF ; |
| |
| /** |
| Abstract base class for reification tests. |
| */ |
| public abstract class AbstractTestReifier extends GraphTestBase |
| { |
| protected static final Triple ALL = Triple.ANY; |
| |
| public AbstractTestReifier( String name ) |
| { super( name ); } |
| |
| public abstract Graph getGraph(); |
| |
| protected final Graph getGraphWith( String facts ) |
| { |
| Graph result = getGraph(); |
| graphAdd( result, facts ); |
| return result; |
| } |
| |
| /** |
| Answer the empty graph if cond is false, otherwise the graph with the given facts. |
| */ |
| protected final Graph graphWithUnless( boolean cond, String facts ) |
| { return graphWith( cond ? "" : facts ); } |
| |
| protected final Graph graphWithIf( boolean cond, String facts ) |
| { return graphWithUnless( !cond, facts ); } |
| |
| public void testGetGraphNotNull() |
| { assertNotNull( getGraph() ); } |
| |
| /** |
| Check that the standard reifier will note, but not hide, reification quads. |
| */ |
| public void testStandard() |
| { |
| Graph g = getGraph( ); |
| assertFalse( ReifierStd.hasTriple(g, triple( "s p o" ) ) ); |
| g.add( NodeCreateUtils.createTriple( "x rdf:subject s" ) ); |
| assertEquals( 1, g.size() ); |
| g.add( NodeCreateUtils.createTriple( "x rdf:predicate p" ) ); |
| assertEquals( 2, g.size() ); |
| g.add( NodeCreateUtils.createTriple( "x rdf:object o" ) ); |
| assertEquals( 3, g.size() ); |
| g.add( NodeCreateUtils.createTriple( "x rdf:type rdf:Statement" ) ); |
| assertEquals( 4, g.size() ); |
| assertTrue( ReifierStd.hasTriple(g, triple( "s p o" ) ) ); |
| } |
| |
| /** |
| Test that the Standard reifier will expose implicit quads arising from reifyAs(). |
| */ |
| public void testStandardExplode() |
| { |
| Graph g = getGraph( ); |
| ReifierStd.reifyAs( g, node( "a" ), triple( "p Q r" ) ); |
| Graph r = Factory.createDefaultGraph( ); |
| graphAdd( r, "a rdf:type rdf:Statement; a rdf:subject p; a rdf:predicate Q; a rdf:object r" ); |
| assertEquals( 4, g.size() ); |
| assertIsomorphic( r, g ); |
| } |
| |
| /** |
| Ensure that over-specifying a reification means that we don't get a triple |
| back. Goodness knows why this test wasn't in right from the beginning. |
| */ |
| public void testOverspecificationSuppressesReification() |
| { |
| Graph g = getGraph(); |
| graphAdd( g, "x rdf:subject A; x rdf:predicate P; x rdf:object O; x rdf:type rdf:Statement" ); |
| assertEquals( triple( "A P O" ), ReifierStd.getTriple(g, node( "x" ) ) ); |
| graphAdd( g, "x rdf:subject BOOM" ); |
| assertEquals( null, ReifierStd.getTriple( g, node( "x" ) ) ); |
| } |
| |
| public void testReificationSubjectClash() |
| { |
| testReificationClash( "x rdf:subject SS" ); |
| } |
| |
| public void testReificationPredicateClash() |
| { |
| testReificationClash( "x rdf:predicate PP" ); |
| } |
| |
| public void testReificationObjectClash() |
| { |
| testReificationClash( "x rdf:object OO" ); |
| } |
| |
| protected void testReificationClash( String clashingStatement ) |
| { |
| Graph g = getGraph(); |
| Triple SPO = NodeCreateUtils.createTriple( "S P O" ); |
| ReifierStd.reifyAs(g, node( "x" ), SPO ); |
| assertTrue( ReifierStd.hasTriple( g , SPO ) ); |
| graphAdd( g, clashingStatement ); |
| assertEquals( null, ReifierStd.getTriple( g , node( "x" ) ) ); |
| // System.err.println( ">> tRC: clashing = " + clashingStatement ); |
| assertFalse( ReifierStd.hasTriple(g, SPO ) ); |
| } |
| |
| /** |
| Test that reifying a triple explicitly has some effect on the graph only for Standard |
| reifiers. |
| */ |
| public void testManifestQuads() |
| { |
| Graph g = getGraph(); |
| ReifierStd.reifyAs(g, node( "A" ), triple( "S P O" ) ) ; |
| String reified = "A rdf:type rdf:Statement; A rdf:subject S; A rdf:predicate P; A rdf:object O"; |
| assertIsomorphic( graphWith( reified ), g ); |
| } |
| |
| public void testHiddenVsReification() |
| { |
| Graph g = getGraph(); |
| ReifierStd.reifyAs( g, node( "A" ), triple( "S P O" ) ); |
| assertTrue( ReifierStd.findEither( g , ALL, false ).hasNext() ); |
| } |
| |
| public void testRetrieveTriplesByNode() |
| { |
| Graph G = getGraph(); |
| Node N = NodeFactory.createBlankNode(), M = NodeFactory.createBlankNode(); |
| ReifierStd.reifyAs( G , N, triple( "x R y" ) ); |
| assertEquals( "gets correct triple", triple( "x R y" ), ReifierStd.getTriple( G , N ) ); |
| ReifierStd.reifyAs( G, M, triple( "p S q" ) ); |
| assertDiffer( "the anon nodes must be distinct", N, M ); |
| assertEquals( "gets correct triple", triple( "p S q" ), ReifierStd.getTriple( G , M ) ); |
| |
| assertTrue( "node is known bound", ReifierStd.hasTriple( G, M ) ); |
| assertTrue( "node is known bound", ReifierStd.hasTriple( G, N ) ); |
| assertFalse( "node is known unbound", ReifierStd.hasTriple( G, NodeFactory.createURI( "any:thing" ) ) ); |
| } |
| |
| public void testRetrieveTriplesByTriple() |
| { |
| Graph G = getGraph(); |
| Triple T = triple( "x R y" ), T2 = triple( "y R x" ); |
| Node N = node( "someNode" ); |
| ReifierStd.reifyAs( G, N, T ); |
| assertTrue( "R must have T", ReifierStd.hasTriple( G, T ) ); |
| assertFalse( "R must not have T2", ReifierStd.hasTriple( G, T2 ) ); |
| } |
| |
| public void testReifyAs() |
| { |
| Graph G = getGraph(); |
| Node X = NodeFactory.createURI( "some:uri" ); |
| assertEquals( "node used", X, ReifierStd.reifyAs( G, X, triple( "x R y" ) ) ); |
| assertEquals( "retrieves correctly", triple( "x R y" ), ReifierStd.getTriple( G, X ) ); |
| } |
| |
| public void testAllNodes() |
| { |
| Graph G = getGraph(); |
| ReifierStd.reifyAs( G, node("x"), triple( "cows eat grass" ) ); |
| ReifierStd.reifyAs( G, node("y"), triple( "pigs can fly" ) ); |
| ReifierStd.reifyAs( G, node("z"), triple( "dogs may bark" ) ); |
| assertEquals( "", nodeSet( "z y x" ), iteratorToSet( ReifierStd.allNodes(G) ) ); |
| } |
| |
| public void testRemoveByNode() |
| { |
| Graph G = getGraph(); |
| Node X = node( "x" ), Y = node( "y" ); |
| ReifierStd.reifyAs( G, X, triple( "x R a" ) ); |
| ReifierStd.reifyAs( G, Y, triple( "y R a" ) ); |
| ReifierStd.remove( G, X, triple( "x R a" ) ); |
| assertFalse( "triple X has gone", ReifierStd.hasTriple( G, X ) ); |
| assertEquals( "triple Y still there", triple( "y R a" ), ReifierStd.getTriple( G, Y ) ); |
| } |
| |
| public void testRemoveFromNothing() |
| { |
| Graph G = getGraph(); |
| G.delete( triple( "quint rdf:subject S" ) ); |
| } |
| |
| public void testException() |
| { |
| Graph G = getGraph(); |
| Node X = node( "x" ); |
| ReifierStd.reifyAs( G, X, triple( "x R y" ) ); |
| ReifierStd.reifyAs( G, X, triple( "x R y" ) ); |
| try { ReifierStd.reifyAs( G, X, triple( "x R z" ) ); fail( "did not detect already reified node" ); } |
| catch (AlreadyReifiedException e) { } |
| } |
| |
| public void testKevinCaseA() |
| { |
| Graph G = getGraph(); |
| Node X = node( "x" ), a = node( "a" ), b = node( "b" ), c = node( "c" ); |
| G.add( Triple.create( X, RDF.Nodes.type, RDF.Nodes.Statement ) ); |
| ReifierStd.reifyAs( G, X, Triple.create( a, b, c ) ); |
| } |
| |
| public void testKevinCaseB() |
| { |
| Graph G = getGraph(); |
| Node X = node( "x" ), Y = node( "y" ); |
| Node a = node( "a" ), b = node( "b" ), c = node( "c" ); |
| G.add( Triple.create( X, RDF.Nodes.subject, Y ) ); |
| try |
| { |
| ReifierStd.reifyAs( G, X, Triple.create( a, b, c ) ); |
| fail( "X already has subject Y: cannot make it a" ); |
| } |
| catch (CannotReifyException e) |
| { pass(); } |
| } |
| |
| public void testQuadRemove() |
| { |
| Graph g = getGraph(); |
| assertEquals( 0, g.size() ); |
| Triple s = NodeCreateUtils.createTriple( "x rdf:subject s" ); |
| Triple p = NodeCreateUtils.createTriple( "x rdf:predicate p" ); |
| Triple o = NodeCreateUtils.createTriple( "x rdf:object o" ); |
| Triple t = NodeCreateUtils.createTriple( "x rdf:type rdf:Statement"); |
| g.add(s); g.add(p); g.add(o); g.add(t); |
| assertEquals( 4, g.size() ); |
| g.delete(s); g.delete(p); g.delete(o); g.delete(t); |
| assertEquals( 0, g.size() ); |
| } |
| |
| public void testEmpty() |
| { |
| Graph g = getGraph(); |
| assertTrue( g.isEmpty() ); |
| graphAdd( g, "x rdf:type rdf:Statement" ); assertFalse( g.isEmpty() ); |
| graphAdd( g, "x rdf:subject Deconstruction" ); assertFalse( g.isEmpty() ); |
| graphAdd( g, "x rdf:predicate rdfs:subTypeOf" ); assertFalse( g.isEmpty() ); |
| graphAdd( g, "x rdf:object LiteraryCriticism" ); assertFalse( g.isEmpty() ); |
| } |
| |
| public void testReifierEmptyFind() |
| { |
| Graph g = getGraph(); |
| assertEquals( tripleSet( "" ), ReifierStd.findExposed( g , Triple.ANY ).toSet() ); |
| } |
| |
| public void testReifierFindSubject() |
| { testReifierFind( "x rdf:subject S" ); } |
| |
| public void testReifierFindObject() |
| { testReifierFind( "x rdf:object O" ); } |
| |
| public void testReifierFindPredicate() |
| { testReifierFind( "x rdf:predicate P" ); } |
| |
| public void testReifierFindComplete() |
| { testReifierFind( "x rdf:predicate P; x rdf:subject S; x rdf:object O; x rdf:type rdf:Statement" ); } |
| |
| public void testReifierFindFilter() |
| { |
| Graph g = getGraph(); |
| graphAdd( g, "s rdf:subject S" ); |
| assertEquals( tripleSet( "" ), ReifierStd.findExposed( g, triple( "s otherPredicate S" ) ).toSet() ); |
| } |
| |
| protected void testReifierFind( String triples ) |
| { testReifierFind( triples, "?? ?? ??" ); } |
| |
| protected void testReifierFind( String triples, String pattern ) |
| { |
| Graph g = getGraph(); |
| graphAdd( g, triples ); |
| assertEquals( tripleSet( triples ), ReifierStd.findExposed( g, triple( pattern ) ).toSet() ); |
| } |
| } |