Repository: jena Updated Branches: refs/heads/master c5fbfdc1b -> e80f6fa4e
JENA-1370: Provide term-only GraphPlain. Use GraphPlain for Delta graph Project: http://git-wip-us.apache.org/repos/asf/jena/repo Commit: http://git-wip-us.apache.org/repos/asf/jena/commit/54d74a72 Tree: http://git-wip-us.apache.org/repos/asf/jena/tree/54d74a72 Diff: http://git-wip-us.apache.org/repos/asf/jena/diff/54d74a72 Branch: refs/heads/master Commit: 54d74a723d5371d740c623aef52933d785b2492b Parents: b6d83d7 Author: Andy Seaborne <[email protected]> Authored: Thu Jul 13 15:43:42 2017 +0100 Committer: Andy Seaborne <[email protected]> Committed: Thu Jul 13 16:04:00 2017 +0100 ---------------------------------------------------------------------- .../apache/jena/sparql/graph/GraphFactory.java | 5 +- .../apache/jena/sparql/graph/GraphMemPlain.java | 164 +------------------ .../iterator/TestSortedDataBagCancellation.java | 9 +- .../org/apache/jena/graph/compose/Delta.java | 20 ++- .../org/apache/jena/graph/impl/GraphPlain.java | 153 +++++++++++++++++ .../jena/graph/impl/WrappedCapabilities.java | 77 +++++++++ .../jena/graph/compose/test/TestDelta.java | 65 ++++++++ .../apache/jena/graph/test/GraphTestBase.java | 4 +- .../apache/jena/graph/test/TestGraphPlain.java | 113 +++++++++++++ .../org/apache/jena/graph/test/TestPackage.java | 2 + 10 files changed, 442 insertions(+), 170 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/jena/blob/54d74a72/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphFactory.java ---------------------------------------------------------------------- diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphFactory.java b/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphFactory.java index c9683bb..f07996c 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphFactory.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphFactory.java @@ -22,6 +22,7 @@ import org.apache.jena.atlas.data.ThresholdPolicy ; import org.apache.jena.graph.Factory ; import org.apache.jena.graph.Graph ; import org.apache.jena.graph.Triple ; +import org.apache.jena.graph.impl.GraphPlain ; import org.apache.jena.rdf.model.Model ; import org.apache.jena.rdf.model.ModelFactory ; import org.apache.jena.sparql.SystemARQ ; @@ -54,10 +55,10 @@ public class GraphFactory return Factory.createDefaultGraph() ; } - /** Very simple graph that uses same-term for find() (small-scale use only) */ + /** Graph that uses same-term for find() and contains(). */ public static Graph createPlainGraph() { - return new GraphMemPlain() ; + return GraphPlain.plain() ; } public static Graph sinkGraph() http://git-wip-us.apache.org/repos/asf/jena/blob/54d74a72/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphMemPlain.java ---------------------------------------------------------------------- diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphMemPlain.java b/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphMemPlain.java index 8630b8b..9b053fd 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphMemPlain.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphMemPlain.java @@ -18,164 +18,18 @@ package org.apache.jena.sparql.graph; -import java.util.HashSet ; -import java.util.Iterator ; -import java.util.Locale ; -import java.util.Set ; -import java.util.function.Predicate; - -import org.apache.jena.graph.Capabilities ; -import org.apache.jena.graph.Node ; -import org.apache.jena.graph.NodeFactory ; -import org.apache.jena.graph.Triple ; -import org.apache.jena.graph.impl.GraphBase ; -import org.apache.jena.graph.impl.SimpleEventManager ; -import org.apache.jena.util.iterator.ClosableIterator ; -import org.apache.jena.util.iterator.ExtendedIterator ; +import org.apache.jena.graph.impl.GraphPlain ; +import org.apache.jena.mem.GraphMem ; /** - * A version of Graph that does term equality only + * A version of Graph that does term equality only + * @deprecated Do not use - see GraphPlain. + * @see GraphPlain */ -public class GraphMemPlain extends GraphBase +@Deprecated +public class GraphMemPlain extends GraphPlain { - private Set<Triple> triples = new HashSet<>() ; - - public GraphMemPlain() {} - - @Override - public Capabilities getCapabilities() { - return gmpCapabilities; - } - - @Override - public void performAdd( Triple t ) - { triples.add(t) ; } - - @Override - public void performDelete( Triple t ) - { triples.remove(t) ; } - - @Override - public boolean graphBaseContains( Triple t ) - { - if ( t.isConcrete() ) - return triples.contains( t ) ; - - ClosableIterator<Triple> it = find( t ); - try { - for ( ; it.hasNext() ; ) - { - Triple t2 = it.next() ; - if ( tripleContained(t, t2) ) - return true ; - } - } finally { it.close(); } - return false ; - } - - @Override - protected ExtendedIterator<Triple> graphBaseFind(Triple m) - { - Iterator<Triple> iter = triples.iterator() ; - return - SimpleEventManager.notifyingRemove( this, iter ) - .filterKeep ( new TripleMatchFilterEquality( m ) ); - } - - static boolean tripleContained(Triple patternTriple, Triple dataTriple) - { - return - equalNode(patternTriple.getSubject(), dataTriple.getSubject()) && - equalNode(patternTriple.getPredicate(), dataTriple.getPredicate()) && - equalNode(patternTriple.getObject(), dataTriple.getObject()) ; - } - - private static boolean equalNode(Node m, Node n) - { - // m should not be null unless .getMatchXXXX used to get the node. - // Language tag canonicalization - n = fixupNode(n) ; - m = fixupNode(m) ; - return (m==null) || (m == Node.ANY) || m.equals(n) ; + public GraphMemPlain() { + super(new GraphMem()) ; } - - private static Node fixupNode(Node node) - { - if ( node == null || node == Node.ANY ) - return node ; - - // RDF says ... language tags should be canonicalized to lower case. - if ( node.isLiteral() ) - { - String lang = node.getLiteralLanguage() ; - if ( lang != null && ! lang.equals("") ) - node = NodeFactory.createLiteral(node.getLiteralLexicalForm(), lang.toLowerCase(Locale.ROOT)) ; - } - return node ; - } - - static class TripleMatchFilterEquality implements Predicate<Triple> - { - final protected Triple tMatch; - - /** Creates new TripleMatchFilter */ - public TripleMatchFilterEquality(Triple tMatch) - { this.tMatch = tMatch; } - - @Override - public boolean test(Triple t) - { - return tripleContained(tMatch, t) ; - } - - } - - private static Capabilities gmpCapabilities = new Capabilities() { - - @Override - public boolean sizeAccurate() { - return true; - } - - @Override - public boolean addAllowed() { - return true; - } - - @Override - public boolean addAllowed(boolean everyTriple) { - return true; - } - - @Override - public boolean deleteAllowed() { - return true; - } - - @Override - public boolean deleteAllowed(boolean everyTriple) { - return true; - } - - @Override - public boolean iteratorRemoveAllowed() { - return true; - } - - @Override - public boolean canBeEmpty() { - return true; - } - - @Override - public boolean findContractSafe() { - return true; - } - - @Override - public boolean handlesLiteralTyping() { - return false; - } - - }; } http://git-wip-us.apache.org/repos/asf/jena/blob/54d74a72/jena-arq/src/test/java/org/apache/jena/sparql/engine/iterator/TestSortedDataBagCancellation.java ---------------------------------------------------------------------- diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/engine/iterator/TestSortedDataBagCancellation.java b/jena-arq/src/test/java/org/apache/jena/sparql/engine/iterator/TestSortedDataBagCancellation.java index 2d77ccf..8227e89 100644 --- a/jena-arq/src/test/java/org/apache/jena/sparql/engine/iterator/TestSortedDataBagCancellation.java +++ b/jena-arq/src/test/java/org/apache/jena/sparql/engine/iterator/TestSortedDataBagCancellation.java @@ -22,9 +22,11 @@ import java.util.HashSet; import java.util.List; import java.util.Set; +import junit.framework.TestCase; import org.apache.jena.atlas.io.IndentedWriter; import org.apache.jena.graph.Graph; import org.apache.jena.graph.NodeFactory; +import org.apache.jena.graph.impl.GraphPlain ; import org.apache.jena.query.QueryCancelledException; import org.apache.jena.query.SortCondition; import org.apache.jena.sparql.core.DatasetGraph; @@ -35,17 +37,12 @@ import org.apache.jena.sparql.engine.binding.Binding; import org.apache.jena.sparql.engine.binding.BindingComparator; import org.apache.jena.sparql.engine.binding.BindingFactory; import org.apache.jena.sparql.engine.binding.BindingMap; -import org.apache.jena.sparql.engine.iterator.QueryIterSort; -import org.apache.jena.sparql.engine.iterator.QueryIteratorBase; import org.apache.jena.sparql.engine.main.OpExecutor; import org.apache.jena.sparql.engine.main.OpExecutorFactory; -import org.apache.jena.sparql.graph.GraphMemPlain; import org.apache.jena.sparql.serializer.SerializationContext; import org.apache.jena.sparql.util.Context; import org.junit.Test; -import junit.framework.TestCase; - /* Test that a SortedDataBag used inside a QueryIterSort does indeed cut off when cancelled. @@ -79,7 +76,7 @@ public class TestSortedDataBagCancellation extends TestCase { } }; - final Graph activeGraph = new GraphMemPlain(); + final Graph activeGraph = GraphPlain.plain(); final DatasetGraph dataset = DatasetGraphFactory.create(); http://git-wip-us.apache.org/repos/asf/jena/blob/54d74a72/jena-core/src/main/java/org/apache/jena/graph/compose/Delta.java ---------------------------------------------------------------------- diff --git a/jena-core/src/main/java/org/apache/jena/graph/compose/Delta.java b/jena-core/src/main/java/org/apache/jena/graph/compose/Delta.java index b35ff68..62c1795 100644 --- a/jena-core/src/main/java/org/apache/jena/graph/compose/Delta.java +++ b/jena-core/src/main/java/org/apache/jena/graph/compose/Delta.java @@ -18,9 +18,13 @@ package org.apache.jena.graph.compose ; -import org.apache.jena.graph.* ; +import org.apache.jena.graph.Capabilities ; +import org.apache.jena.graph.Graph ; +import org.apache.jena.graph.GraphUtil ; +import org.apache.jena.graph.Triple ; +import org.apache.jena.graph.impl.GraphPlain ; import org.apache.jena.graph.impl.SimpleEventManager ; -import org.apache.jena.util.iterator.* ; +import org.apache.jena.util.iterator.ExtendedIterator ; /** * Graph operation for wrapping a base graph and leaving it unchanged while @@ -40,9 +44,15 @@ public class Delta extends CompositionBase implements Graph public Delta(Graph base) { super() ; - this.base = base ; - this.additions = Factory.createGraphMem(); - this.deletions = Factory.createGraphMem(); + this.base = GraphPlain.plain(base); + this.additions = GraphPlain.plain(); + this.deletions = GraphPlain.plain(); + } + + @Override + public Capabilities getCapabilities() { + // Not stricly accurate. + return base.getCapabilities(); } /** http://git-wip-us.apache.org/repos/asf/jena/blob/54d74a72/jena-core/src/main/java/org/apache/jena/graph/impl/GraphPlain.java ---------------------------------------------------------------------- diff --git a/jena-core/src/main/java/org/apache/jena/graph/impl/GraphPlain.java b/jena-core/src/main/java/org/apache/jena/graph/impl/GraphPlain.java new file mode 100644 index 0000000..4ec8a26 --- /dev/null +++ b/jena-core/src/main/java/org/apache/jena/graph/impl/GraphPlain.java @@ -0,0 +1,153 @@ +/* + * 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.impl; + +import java.util.function.Predicate; + +import org.apache.jena.graph.* ; +import org.apache.jena.rdf.model.impl.Util ; +import org.apache.jena.util.iterator.ExtendedIterator ; + +/** + * A version of Graph that enforces term equality even if the base graph uses value-indexing. + * With value-indexing, one value may have several object terms that represent it when the graph store + * RDF terms, and but matches by value. + * + * This only affects the object field of a triple in RDF but in + * <a href="https://www.w3.org/TR/rdf11-concepts/#section-generalized-rdf";>"generalized RDF"</a> + * literals can appear in any triple slot. + * <p> + */ +public class GraphPlain extends WrappedGraph +{ + /** Return a graph that only has term-equality + * and storage in the {@code base} graph. + * Update affects the base graph. + */ + public static Graph plain(Graph base) { + if ( ! base.getCapabilities().handlesLiteralTyping() ) + return base; + return new GraphPlain(base); + } + + /** Return a graph that only has term-equality. */ + public static Graph plain() { + return plain(Factory.createDefaultGraph()); + } + + private final Capabilities capabilities; + + protected GraphPlain(Graph other) { + super(other); + capabilities = new WrappedCapabilities(base.getCapabilities()) { + @Override public boolean handlesLiteralTyping() { return false; } + }; + } + + @Override + public Capabilities getCapabilities() { + return capabilities; + } + + @Override + public void remove( Node s, Node p, Node o ) { + GraphUtil.remove(this, s, p, o) ; + } + +// @Override +// public void clear() { +// GraphUtil.remove(this, Node.ANY, Node.ANY, Node.ANY); +// } + + @Override + public boolean contains( Triple t ) { + return contains(t.getSubject(), t.getPredicate(), t.getObject()); + } + + @Override + public boolean contains(Node s, Node p, Node o) { + // Do direct for efficiency. + if ( ! base.contains(s,p,o) ) + return false; + // May have matched by value. Do a term test find to restrict to RDF terms. + ExtendedIterator<Triple> iter = find(s, p, o); + boolean b = iter.hasNext(); + iter.close(); + return b; + } + + @Override + public ExtendedIterator<Triple> find(Triple m) { + return find(m.getSubject(), m.getPredicate(), m.getObject()); + } + + @Override + public ExtendedIterator<Triple> find(Node subj, Node pred, Node obj) { + // Use the base graph and it's indexing (which presumably is efficient) + // then filter for term match. If two terms match they must be same-value + // so retrieve-by-value will find matches, and maybe some more. + ExtendedIterator<Triple> iter = base.find(subj, pred, obj) ; + + // Add a term filter. + // Whole triple. + Predicate<Triple> predicate = (dataTriple) -> sameTermMatch(subj, pred, obj, dataTriple); + iter = iter.filterKeep(predicate) ; +// // For reference - just object +// if ( !obj.isConcrete() || obj.isLiteral() ) { +// Predicate<Triple> predicate = (t) -> sameTermMatch(obj, t.getObject()) ; +// iter = iter.filterKeep(predicate) ; +// } + return iter; + } + + @Override + public String toString() { + return this.getClass().getSimpleName()+" "+base.toString(); + } + + /** + * Match a ground triple (even ANY and variablesare considered ground terms in the + * data triple) with S/P/O which can be wildcards (ANY or null). + */ + private static boolean sameTermMatch(Node matchSubj, Node matchPred, Node matchObj, Triple dataTriple) { + return + sameTermMatch(matchSubj, dataTriple.getSubject()) && + sameTermMatch(matchPred, dataTriple.getPredicate()) && + sameTermMatch(matchObj, dataTriple.getObject()); + } + + /** + * Match a ground RDF Term (ANY and variables are considered ground terms in the + * data term) with a node which can be a wildcard (ANY or null). + * Language tags compare case-insensitively. + */ + private static boolean sameTermMatch(Node match, Node data) { + if ( ! Util.isLangString(data) || ! Util.isLangString(match) ) + // No lang tag + return (match==null) || (match == Node.ANY) || match.equals(data) ; + + // Concrete match, which is a lang tag literal. + // Language tags compare case insensitively. + String lex1 = data.getLiteralLexicalForm(); + String lex2 = data.getLiteralLexicalForm(); + String lang1 = data.getLiteralLanguage(); + String lang2 = data.getLiteralLanguage(); + return lex1.equals(lex2) && lang1.equalsIgnoreCase(lang2); + } +} http://git-wip-us.apache.org/repos/asf/jena/blob/54d74a72/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedCapabilities.java ---------------------------------------------------------------------- diff --git a/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedCapabilities.java b/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedCapabilities.java new file mode 100644 index 0000000..f0a217f --- /dev/null +++ b/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedCapabilities.java @@ -0,0 +1,77 @@ +/* + * 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.impl; + +import org.apache.jena.graph.Capabilities ; + +@SuppressWarnings("deprecation") +public class WrappedCapabilities implements Capabilities { + + protected final Capabilities other ; + + public WrappedCapabilities(Capabilities other) { + this.other = other; + } + + @Override + public boolean sizeAccurate() { + return other.sizeAccurate() ; + } + + @Override + public boolean addAllowed() { + return other.addAllowed() ; + } + + @Override + public boolean deleteAllowed() { + return other.deleteAllowed() ; + } + + @Override + public boolean addAllowed(boolean everyTriple) { + return other.addAllowed(everyTriple) ; + } + + @Override + public boolean deleteAllowed(boolean everyTriple) { + return other.deleteAllowed(everyTriple) ; + } + + @Override + public boolean iteratorRemoveAllowed() { + return other.iteratorRemoveAllowed() ; + } + + @Override + public boolean canBeEmpty() { + return other.canBeEmpty() ; + } + + @Override + public boolean findContractSafe() { + return other.findContractSafe() ; + } + + @Override + public boolean handlesLiteralTyping() { + return other.handlesLiteralTyping() ; + } + +} http://git-wip-us.apache.org/repos/asf/jena/blob/54d74a72/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestDelta.java ---------------------------------------------------------------------- diff --git a/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestDelta.java b/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestDelta.java index 44a9d03..0ab76a7 100755 --- a/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestDelta.java +++ b/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestDelta.java @@ -20,6 +20,7 @@ package org.apache.jena.graph.compose.test; import junit.framework.TestSuite ; import org.apache.jena.graph.Graph ; +import org.apache.jena.graph.Triple ; import org.apache.jena.graph.compose.Delta ; import org.apache.jena.graph.test.AbstractTestGraph ; @@ -132,5 +133,69 @@ public class TestDelta extends AbstractTestGraph assertIsomorphic(graphWith( "p S q" ), delta.getDeletions()); assertIsomorphic(graphWith( "x R y ; x R z; a T b" ), delta); } + + public void testTerms1() + { + Triple t1 = triple("s p 1"); + Triple t01 = triple("s p 01"); + Graph base = newGraph(); + base.add(t1); + Delta delta = new Delta( base ) ; + + delta.add(t01); + assertTrue(delta.getAdditions().contains(triple("s p 01"))); + assertFalse(delta.getAdditions().contains(triple("s p 1"))); + assertTrue(delta.contains(t1)); + assertTrue(delta.contains(t01)); + } + + public void testTerms2() + { + Triple t1 = triple("s p 1"); + Triple t01 = triple("s p 01"); + Graph base = newGraph(); + base.add(t1); + Delta delta = new Delta( base ) ; + + delta.delete(t01); + + assertFalse(delta.getDeletions().contains(triple("s p 01"))); + assertFalse(delta.getAdditions().contains(triple("s p 1"))); + } + + public void testTerms3() + { + Triple t1 = triple("s p 1"); + Triple t01 = triple("s p 01"); + Graph base = newGraph(); + base.add(t1); + Delta delta = new Delta( base ) ; + + delta.add(t01); + delta.delete(t01); + delta.delete(t1); + + assertFalse(delta.getDeletions().contains(t01)); + assertTrue(delta.getDeletions().contains(t1)); + assertFalse(delta.getDeletions().contains(t01)); + assertFalse(delta.getAdditions().contains(t01)); + } + + public void testTerms4() + { + Triple t1 = triple("s p 1"); + Triple t01 = triple("s p 01"); + Graph base = newGraph(); + Delta delta = new Delta( base ) ; + + delta.add(t1); + delta.delete(t01); + + assertFalse(delta.getDeletions().contains(triple("s p 01"))); + assertTrue(delta.getDeletions().isEmpty()); + + assertTrue(delta.getAdditions().contains(triple("s p 1"))); + assertFalse(delta.getAdditions().isEmpty()); + } } http://git-wip-us.apache.org/repos/asf/jena/blob/54d74a72/jena-core/src/test/java/org/apache/jena/graph/test/GraphTestBase.java ---------------------------------------------------------------------- diff --git a/jena-core/src/test/java/org/apache/jena/graph/test/GraphTestBase.java b/jena-core/src/test/java/org/apache/jena/graph/test/GraphTestBase.java index caa1f74..7904e4f 100644 --- a/jena-core/src/test/java/org/apache/jena/graph/test/GraphTestBase.java +++ b/jena-core/src/test/java/org/apache/jena/graph/test/GraphTestBase.java @@ -64,7 +64,7 @@ public class GraphTestBase extends JenaTestBase /** Answer a Node as described by <code>x</code>; a shorthand for - <code>Node.create(x)</code>, which see. + <code>NodeCreateUtils.create(x)</code>, which see. */ public static Node node( String x ) { return NodeCreateUtils.create( x ); } @@ -105,7 +105,7 @@ public class GraphTestBase extends JenaTestBase /** Answer a triple described by the three space-separated node descriptions - in <code>fact</code>; a shorthand for <code>Triple.create(fact)</code>, + in <code>fact</code>; a shorthand for <code>NodeCreateUtils.createTriple(fact)</code>, which see. */ public static Triple triple( String fact ) http://git-wip-us.apache.org/repos/asf/jena/blob/54d74a72/jena-core/src/test/java/org/apache/jena/graph/test/TestGraphPlain.java ---------------------------------------------------------------------- diff --git a/jena-core/src/test/java/org/apache/jena/graph/test/TestGraphPlain.java b/jena-core/src/test/java/org/apache/jena/graph/test/TestGraphPlain.java new file mode 100644 index 0000000..daaf984 --- /dev/null +++ b/jena-core/src/test/java/org/apache/jena/graph/test/TestGraphPlain.java @@ -0,0 +1,113 @@ +/* + * 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 static org.apache.jena.graph.test.GraphTestBase.graphAdd ; +import static org.apache.jena.graph.test.GraphTestBase.node ; +import static org.apache.jena.graph.test.GraphTestBase.triple ; +import static org.junit.Assert.assertEquals ; +import static org.junit.Assert.assertFalse ; +import static org.junit.Assert.assertTrue ; + +import java.util.List ; + +import org.apache.jena.graph.Graph ; +import org.apache.jena.graph.Node ; +import org.apache.jena.graph.Triple ; +import org.apache.jena.graph.impl.GraphPlain ; +import org.apache.jena.mem.GraphMem ; +import org.apache.jena.util.iterator.ExtendedIterator ; +import org.junit.BeforeClass ; +import org.junit.Test ; + +public class TestGraphPlain { + + private static Graph graph; + + @BeforeClass public static void setUp() { + graph = new GraphMem(); + + if ( ! graph.getCapabilities().handlesLiteralTyping() ) + throw new IllegalArgumentException("Test graph does not do the value thing"); + graphAdd(graph, "s p o ; s p 1 ; s p 01"); + } + + @Test public void contains1() { + Triple triple = triple("s p 001"); + assertTrue(graph.contains(triple)); + Graph plain = GraphPlain.plain(graph); + assertFalse(plain.contains(triple)); + } + + @Test public void contains2() { + Triple triple = triple("s p 1"); + assertTrue(graph.contains(triple)); + Graph plain = GraphPlain.plain(graph); + assertTrue(plain.contains(triple)); + } + + @Test public void contains3() { + Triple triple = triple("s1 p 1"); + assertFalse(graph.contains(triple)); + Graph plain = GraphPlain.plain(graph); + assertFalse(plain.contains(triple)); + } + + @Test public void contains4() { + Node s = node("s"); + Node p = node("p"); + Node x = node("001"); + + assertTrue(graph.contains(s,p,x)); + Graph plain = GraphPlain.plain(graph); + assertFalse(plain.contains(s,p,x)); + } + + @Test public void find1() { + find_test(graph, 2); + Graph plain = GraphPlain.plain(graph); + find_test(plain, 1); + } + + @Test public void find2() { + Graph plain = GraphPlain.plain(graph); + Node s = node("s"); + Node p = node("p"); + Node x = node("001"); + List<Triple> list = plain.find(s,p,x).toList(); + assertEquals(0, list.size()); + } + + @Test public void find3() { + Graph plain = GraphPlain.plain(graph); + Node s = node("s"); + Node p = node("p"); + Node x = node("??"); + List<Triple> list = plain.find(s,p,x).toList(); + assertEquals(3, list.size()); + } + + private static void find_test(Graph testGraph, int n) { + Triple triple = triple("?? p 1"); + ExtendedIterator<Triple> iter = testGraph.find(triple); + //assertTrue(iter.hasNext()); + List<Triple> list = iter.toList(); + assertEquals(n, list.size()); + } +} http://git-wip-us.apache.org/repos/asf/jena/blob/54d74a72/jena-core/src/test/java/org/apache/jena/graph/test/TestPackage.java ---------------------------------------------------------------------- diff --git a/jena-core/src/test/java/org/apache/jena/graph/test/TestPackage.java b/jena-core/src/test/java/org/apache/jena/graph/test/TestPackage.java index c070ca6..08aeda1 100644 --- a/jena-core/src/test/java/org/apache/jena/graph/test/TestPackage.java +++ b/jena-core/src/test/java/org/apache/jena/graph/test/TestPackage.java @@ -18,6 +18,7 @@ package org.apache.jena.graph.test; +import junit.framework.JUnit4TestAdapter ; import junit.framework.TestSuite ; /** @@ -45,6 +46,7 @@ public class TestPackage extends TestSuite { addTest( TestDateTime.suite() ); addTest( TestFactory.suite() ); addTest( TestGraph.suite() ); + addTest( new JUnit4TestAdapter(TestGraphPlain.class ) ); addTest( TestSimpleGraphMaker.suite() ); addTest( TestGraphExtract.suite() ); addTest( TestCapabilities.suite() );
