You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jena.apache.org by an...@apache.org on 2025/05/23 15:24:41 UTC
(jena) 01/05: GH-3194: Deprecation-removal of Graph.getCapabilities
This is an automated email from the ASF dual-hosted git repository.
andy pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/jena.git
commit 2962991f1a819c695d18fa8e12f27c7607c78bdc
Author: Andy Seaborne <an...@apache.org>
AuthorDate: Wed May 14 19:23:48 2025 +0100
GH-3194: Deprecation-removal of Graph.getCapabilities
---
.../org/apache/jena/sparql/graph/GraphWrapper.java | 8 +-
.../org/apache/jena/sparql/core/TestSpecials.java | 34 +-
.../src/main/java/org/apache/jena/graph/Graph.java | 12 +-
.../java/org/apache/jena/graph/compose/Delta.java | 11 +-
.../org/apache/jena/graph/compose/Polyadic.java | 11 +-
.../java/org/apache/jena/graph/impl/GraphBase.java | 5 -
.../org/apache/jena/graph/impl/GraphMatcher.java | 25 +-
.../org/apache/jena/graph/impl/GraphPlain.java | 10 -
.../org/apache/jena/graph/impl/WrappedGraph.java | 1 +
.../main/java/org/apache/jena/mem2/GraphMem2.java | 11 +-
.../org/apache/jena/reasoner/BaseInfGraph.java | 1 +
.../org/apache/jena/graph/GraphContractTest.java | 1525 ++++++++++++++++++++
.../apache/jena/graph/compose/test/TestDelta.java | 2 +-
.../jena/graph/compose/test/TestDifference.java | 2 +-
.../jena/graph/compose/test/TestDisjointUnion.java | 2 +-
.../jena/graph/compose/test/TestIntersection.java | 2 +-
.../jena/graph/compose/test/TestMultiUnion.java | 2 +-
.../apache/jena/graph/compose/test/TestUnion.java | 2 +-
.../apache/jena/graph/test/AbstractTestGraph.java | 199 +--
.../org/apache/jena/graph/test/MetaTestGraph.java | 2 +-
.../apache/jena/graph/test/TestGraphListener.java | 4 +-
.../org/apache/jena/mem/test/TestGraphMem2.java | 2 +-
.../apache/jena/mem/test/TestGraphMemValue.java | 276 +++-
.../apache/jena/ontology/impl/TestOntGraph.java | 2 +-
.../rulesys/test/FRuleEngineIFactoryTest.java | 3 -
.../apache/jena/reasoner/test/TestInfGraph.java | 2 +-
.../contract/graph/SecuredGraphContractTests.java | 2 +-
.../contract/graph/SecuredGraphListenerTest.java | 2 +-
.../graph/SecuredTDBGraphContractTests.java | 2 +-
29 files changed, 1894 insertions(+), 268 deletions(-)
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphWrapper.java b/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphWrapper.java
index 7a58057e62..3c150f58e3 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphWrapper.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/graph/GraphWrapper.java
@@ -50,10 +50,10 @@ public class GraphWrapper implements Graph
return get().getTransactionHandler();
}
- @Override
- public Capabilities getCapabilities() {
- return get().getCapabilities();
- }
+// @Override
+// public Capabilities getCapabilities() {
+// return get().getCapabilities();
+// }
@Override
public GraphEventManager getEventManager() {
diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/core/TestSpecials.java b/jena-arq/src/test/java/org/apache/jena/sparql/core/TestSpecials.java
index b2ac2ad683..2b2882e87c 100644
--- a/jena-arq/src/test/java/org/apache/jena/sparql/core/TestSpecials.java
+++ b/jena-arq/src/test/java/org/apache/jena/sparql/core/TestSpecials.java
@@ -46,26 +46,26 @@ import org.junit.Test;
* {@link GraphSink}
*/
public class TestSpecials {
-
+
private static Quad quad = SSE.parseQuad("(:g :s :p :o)");
private static Triple triple = SSE.parseTriple("(:s :p :o)");
private static Node gn = SSE.parseNode(":gn");
-
+
// -- zero
-
+
@Test public void zero_basic_1() {
DatasetGraph dsg = DatasetGraphZero.create();
assertFalse(dsg.find().hasNext());
assertTrue(dsg.supportsTransactionAbort());
assertEquals(0, dsg.getDefaultGraph().size());
- assertFalse(dsg.getDefaultGraph().getCapabilities().addAllowed());
+ //assertFalse(dsg.getDefaultGraph().getCapabilities().addAllowed());
}
-
+
@Test public void zero_basic_2() {
DatasetGraph dsg = DatasetGraphZero.create();
assertNull(dsg.getGraph(gn));
}
-
+
@Test(expected=UnsupportedOperationException.class)
public void zero_add_1() {
DatasetGraph dsg = DatasetGraphZero.create();
@@ -120,7 +120,7 @@ public class TestSpecials {
DatasetGraph dsg = DatasetGraphZero.create();
dsg.commit();
}
-
+
@Test(expected=JenaTransactionException.class)
public void zero_txn_4() {
DatasetGraph dsg = DatasetGraphZero.create();
@@ -128,7 +128,7 @@ public class TestSpecials {
dsg.commit();
dsg.commit();
}
-
+
@Test public void zero_graph_txn_1() {
DatasetGraph dsg = DatasetGraphZero.create();
Graph g = dsg.getDefaultGraph();
@@ -169,22 +169,22 @@ public class TestSpecials {
TransactionHandler h = g.getTransactionHandler();
h.commit();
}
-
+
// -- sink
-
+
@Test public void sink_basic_1() {
DatasetGraph dsg = DatasetGraphSink.create();
assertFalse(dsg.find().hasNext());
assertTrue(dsg.supportsTransactionAbort());
assertEquals(0, dsg.getDefaultGraph().size());
- assertTrue(dsg.getDefaultGraph().getCapabilities().addAllowed());
+ //assertTrue(dsg.getDefaultGraph().getCapabilities().addAllowed());
}
-
+
@Test public void sink_basic_2() {
DatasetGraph dsg = DatasetGraphSink.create();
assertNull(dsg.getGraph(gn));
}
-
+
@Test public void sink_add_1() {
DatasetGraph dsg = DatasetGraphSink.create();
dsg.add(quad);
@@ -210,7 +210,7 @@ public class TestSpecials {
DatasetGraph dsg = DatasetGraphSink.create();
dsg.getDefaultGraph().add(triple);
}
-
+
@Test
public void sink_delete_3() {
DatasetGraph dsg = DatasetGraphSink.create();
@@ -222,7 +222,7 @@ public class TestSpecials {
Txn.executeRead(dsg, ()->{});
Txn.executeWrite(dsg, ()->{});
}
-
+
@Test(expected=JenaTransactionException.class)
public void sink_txn_2() {
DatasetGraph dsg = DatasetGraphSink.create();
@@ -235,7 +235,7 @@ public class TestSpecials {
DatasetGraph dsg = DatasetGraphSink.create();
dsg.commit();
}
-
+
@Test(expected=JenaTransactionException.class)
public void sink_txn_4() {
DatasetGraph dsg = DatasetGraphSink.create();
@@ -243,7 +243,7 @@ public class TestSpecials {
dsg.commit();
dsg.commit();
}
-
+
@Test public void sink_graph_txn_1() {
DatasetGraph dsg = DatasetGraphSink.create();
Graph g = dsg.getDefaultGraph();
diff --git a/jena-core/src/main/java/org/apache/jena/graph/Graph.java b/jena-core/src/main/java/org/apache/jena/graph/Graph.java
index 330fd62356..bb6c43ae68 100644
--- a/jena-core/src/main/java/org/apache/jena/graph/Graph.java
+++ b/jena-core/src/main/java/org/apache/jena/graph/Graph.java
@@ -22,6 +22,7 @@ import java.util.Objects;
import java.util.stream.Stream;
import org.apache.jena.atlas.iterator.Iter;
+import org.apache.jena.graph.impl.AllCapabilities;
import org.apache.jena.graph.impl.GraphBase ;
import org.apache.jena.shared.AddDeniedException ;
import org.apache.jena.shared.DeleteDeniedException ;
@@ -57,7 +58,7 @@ public interface Graph {
/**
true if this graph's content depends on the other graph. May be
- pessimistic (ie return true if it's not sure). Typically true when a
+ pessimistic (i.e. return true if it's not sure). Typically true when a
graph is a composition of other graphs, eg union.
@param other the graph this graph may depend on
@@ -68,8 +69,13 @@ public interface Graph {
/** returns this Graph's transaction handler */
TransactionHandler getTransactionHandler();
- /** returns this Graph's capabilities */
- Capabilities getCapabilities();
+
+ /**
+ * returns this Graph's capabilities
+ * @deprecated To be removed.
+ */
+ @Deprecated(forRemoval = true)
+ default Capabilities getCapabilities() { return AllCapabilities.updateAllowed; }
/**
Answer this Graph's event manager.
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 a54521cad2..eeea73cee5 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,7 +18,6 @@
package org.apache.jena.graph.compose;
-import org.apache.jena.graph.Capabilities;
import org.apache.jena.graph.Graph;
import org.apache.jena.graph.Triple;
import org.apache.jena.graph.impl.GraphPlain;
@@ -45,11 +44,11 @@ public class Delta extends CompositionBase implements Graph {
this.deletions = GraphPlain.plain();
}
- @Override
- public Capabilities getCapabilities() {
- // Not strictly accurate.
- return base.getCapabilities();
- }
+// @Override
+// public Capabilities getCapabilities() {
+// // Not strictly accurate.
+// return base.getCapabilities();
+// }
/**
* Answer the graph of all triples added.
diff --git a/jena-core/src/main/java/org/apache/jena/graph/compose/Polyadic.java b/jena-core/src/main/java/org/apache/jena/graph/compose/Polyadic.java
index 9f2d6cb600..8c531dcdc1 100755
--- a/jena-core/src/main/java/org/apache/jena/graph/compose/Polyadic.java
+++ b/jena-core/src/main/java/org/apache/jena/graph/compose/Polyadic.java
@@ -27,7 +27,6 @@ import java.util.ArrayList ;
import java.util.Iterator ;
import java.util.List ;
-import org.apache.jena.graph.Capabilities ;
import org.apache.jena.graph.Graph ;
import org.apache.jena.graph.TransactionHandler ;
import org.apache.jena.shared.JenaException ;
@@ -92,10 +91,10 @@ public abstract class Polyadic extends CompositionBase
@Override
protected PrefixMapping createPrefixMapping()
- {
+ {
return new PolyadicPrefixMappingImpl( this );
}
-
+
/**
* <p>
* Construct a composition of all of the given graphs.
@@ -263,10 +262,4 @@ public abstract class Polyadic extends CompositionBase
public TransactionHandler getTransactionHandler() {
return (getBaseGraph() == null) ? super.getTransactionHandler() : getBaseGraph().getTransactionHandler();
}
-
- @Override
- public Capabilities getCapabilities() {
- return (getBaseGraph() == null) ? super.getCapabilities() : getBaseGraph().getCapabilities();
- }
-
}
diff --git a/jena-core/src/main/java/org/apache/jena/graph/impl/GraphBase.java b/jena-core/src/main/java/org/apache/jena/graph/impl/GraphBase.java
index a3d0cb446f..64be06a73d 100644
--- a/jena-core/src/main/java/org/apache/jena/graph/impl/GraphBase.java
+++ b/jena-core/src/main/java/org/apache/jena/graph/impl/GraphBase.java
@@ -127,11 +127,6 @@ public abstract class GraphBase implements GraphWithPerform
public TransactionHandler getTransactionHandler()
{ return new SimpleTransactionHandler(); }
- @Override
- public Capabilities getCapabilities() {
- return AllCapabilities.updateAllowed;
- }
-
/**
Answer the PrefixMapping object for this graph, the same one each time.
*/
diff --git a/jena-core/src/main/java/org/apache/jena/graph/impl/GraphMatcher.java b/jena-core/src/main/java/org/apache/jena/graph/impl/GraphMatcher.java
index a0465b63b1..5d9ebcd0af 100644
--- a/jena-core/src/main/java/org/apache/jena/graph/impl/GraphMatcher.java
+++ b/jena-core/src/main/java/org/apache/jena/graph/impl/GraphMatcher.java
@@ -22,6 +22,7 @@ import static org.apache.jena.util.iterator.WrappedIterator.create;
import java.util.*;
import org.apache.jena.graph.* ;
+import org.apache.jena.reasoner.InfGraph;
import org.apache.jena.shared.* ;
import org.apache.jena.util.CollectionFactory ;
import org.apache.jena.util.iterator.* ;
@@ -153,12 +154,24 @@ public class GraphMatcher extends java.lang.Object {
// check that the size's are the same.
// If the size is not accurate then it is a lower bound
- if (m.getCapabilities().sizeAccurate()
- && m.size() < other.m.size() )
- return null;
- if (other.m.getCapabilities().sizeAccurate()
- && m.size() > other.m.size() )
- return null;
+// @SuppressWarnings("removal")
+// boolean testForSize = m.getCapabilities().sizeAccurate() && other.m.getCapabilities().sizeAccurate() ;
+ boolean testForSize = ! ( m instanceof InfGraph || other.m instanceof InfGraph );
+ if ( testForSize ) {
+ if ( m.size() != -1 && ( m.size() != other.m.size() ) )
+ return null;
+ }
+
+ // Old code up to Jena 5.4.0, prior to removing capabilities.
+ // Size is lower bound
+ // Only InfGraphs have inaccurate size (GraphMatech is not designed for large database-stored graphs.
+
+// if (m.getCapabilities().sizeAccurate()
+// && m.size() < other.m.size() )
+// return null;
+// if (other.m.getCapabilities().sizeAccurate()
+// && m.size() > other.m.size() )
+// return null;
int myPrep = prepare(other.m);
if ( myPrep == -1 || myPrep != other.prepare(m) ) {
return null;
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
index ded3b415c8..5b46af032a 100644
--- 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
@@ -57,20 +57,10 @@ public class GraphPlain extends WrappedGraph
return plain(GraphMemFactory.createDefaultGraph());
}
- private final Capabilities capabilities;
-
private 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) ;
diff --git a/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedGraph.java b/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedGraph.java
index af57d05be4..8de2b3ad92 100644
--- a/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedGraph.java
+++ b/jena-core/src/main/java/org/apache/jena/graph/impl/WrappedGraph.java
@@ -43,6 +43,7 @@ public class WrappedGraph implements GraphWithPerform
public TransactionHandler getTransactionHandler()
{ return base.getTransactionHandler(); }
+ @Deprecated(forRemoval = true)
@Override
public Capabilities getCapabilities()
{ return base.getCapabilities(); }
diff --git a/jena-core/src/main/java/org/apache/jena/mem2/GraphMem2.java b/jena-core/src/main/java/org/apache/jena/mem2/GraphMem2.java
index cb2be229ce..04750138e6 100644
--- a/jena-core/src/main/java/org/apache/jena/mem2/GraphMem2.java
+++ b/jena-core/src/main/java/org/apache/jena/mem2/GraphMem2.java
@@ -18,18 +18,16 @@
package org.apache.jena.mem2;
+import java.util.stream.Stream;
+
import org.apache.jena.atlas.lib.Copyable;
-import org.apache.jena.graph.Capabilities;
import org.apache.jena.graph.Node;
import org.apache.jena.graph.Triple;
-import org.apache.jena.graph.impl.AllCapabilities;
import org.apache.jena.graph.impl.GraphWithPerform;
import org.apache.jena.mem.GraphMemBase;
import org.apache.jena.mem2.store.TripleStore;
import org.apache.jena.util.iterator.ExtendedIterator;
-import java.util.stream.Stream;
-
/**
* A graph that stores triples in memory. This class is not thread-safe.
* All triples are stored in a {@link TripleStore}.
@@ -143,11 +141,6 @@ public class GraphMem2 extends GraphMemBase implements GraphWithPerform, Copyabl
return this.tripleStore.countTriples();
}
- @Override
- public Capabilities getCapabilities() {
- return AllCapabilities.updateAllowed;
- }
-
/**
* Creates a copy of this graph.
* Since the triples and nodes are immutable, the copy contains the same triples and nodes as this graph.
diff --git a/jena-core/src/main/java/org/apache/jena/reasoner/BaseInfGraph.java b/jena-core/src/main/java/org/apache/jena/reasoner/BaseInfGraph.java
index c3f3ee72b6..1412b21d54 100644
--- a/jena-core/src/main/java/org/apache/jena/reasoner/BaseInfGraph.java
+++ b/jena-core/src/main/java/org/apache/jena/reasoner/BaseInfGraph.java
@@ -74,6 +74,7 @@ public abstract class BaseInfGraph extends GraphBase implements InfGraph {
private Capabilities calcCapabilitiesFrom(Graph data) {
if ( data == null )
return reasonerInfCapabilities;
+
// Same as data graph except size is not accurate.
Capabilities baseCapabilities = data.getCapabilities();
return AllCapabilities.create(false,
diff --git a/jena-core/src/test/java/org/apache/jena/graph/GraphContractTest.java b/jena-core/src/test/java/org/apache/jena/graph/GraphContractTest.java
new file mode 100644
index 0000000000..6a1353ba13
--- /dev/null
+++ b/jena-core/src/test/java/org/apache/jena/graph/GraphContractTest.java
@@ -0,0 +1,1525 @@
+/*
+ * 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;
+
+import static org.apache.jena.testing_framework.GraphHelper.*;
+import static org.junit.Assert.*;
+
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URISyntaxException;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
+
+import org.apache.jena.mem.TrackingTripleIterator;
+import org.apache.jena.rdf.model.Model;
+import org.apache.jena.rdf.model.ModelFactory;
+import org.apache.jena.rdf.model.impl.ReifierStd;
+import org.apache.jena.shared.ClosedException;
+import org.apache.jena.shared.DeleteDeniedException;
+import org.apache.jena.shared.PrefixMapping;
+import org.apache.jena.testing_framework.AbstractGraphProducer;
+import org.apache.jena.testing_framework.NodeCreateUtils;
+import org.apache.jena.util.iterator.ClosableIterator;
+import org.apache.jena.util.iterator.ExtendedIterator;
+import org.junit.After;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.xenei.junit.contract.Contract;
+import org.xenei.junit.contract.ContractTest;
+
+/**
+ * Graph contract test.
+ */
+@Contract(Graph.class)
+public class GraphContractTest<T extends Graph>
+{
+
+ private static final Logger LOG = LoggerFactory
+ .getLogger(GraphContractTest.class);
+
+ private AbstractGraphProducer<T> producer;
+
+ protected RecordingGraphListener GL = new RecordingGraphListener();
+
+ @Contract.Inject
+ public final void setGraphContractTestProducer(
+ AbstractGraphProducer<T> graphProducer)
+ {
+ producer = graphProducer;
+ }
+
+ @After
+ public final void afterGraphContractTest()
+ {
+ producer.cleanUp();
+ GL.clear();
+ }
+
+ @ContractTest
+ public void testAdd_Triple()
+ {
+ Graph graph = producer.newInstance();
+ graph.getEventManager().register(GL);
+ txnBegin(graph);
+ graph.add(triple("S P O"));
+ txnCommit(graph);
+ GL.assertHasStart("add", graph, triple("S P O"));
+ txnRun(graph, () -> assertTrue("Graph should contain <S P O>",
+ graph.contains(triple("S P O"))));
+
+ }
+
+ /**
+ * Inference graphs can not be truly empty.
+ *
+ * @param g
+ * @param b
+ */
+ private void assertEmpty(Graph g, Graph b)
+ {
+ if (b.isEmpty())
+ {
+ assertTrue("Graph should be empty", g.isEmpty());
+ } else
+ {
+ assertEquals("Graph should be in base state",
+ b.find(Triple.ANY).toList(), g.find(Triple.ANY).toList());
+ }
+ }
+
+ /**
+ * Inference graphs can not be truly empty
+ *
+ * @param g
+ * @param b
+ */
+ private void assertNotEmpty(Graph g, Graph b)
+ {
+ if (b.isEmpty())
+ {
+ assertFalse("Graph not should be empty", g.isEmpty());
+ } else
+ {
+ assertNotEquals("Graph should not be in base state",
+ b.find(Triple.ANY).toList(), g.find(Triple.ANY).toList());
+ }
+ }
+
+ @SuppressWarnings("deprecation")
+ private static boolean xsupportsLiteralTyping(Graph g) {
+ //return g.getCapabilities().handlesLiteralTyping();
+ return g instanceof org.apache.jena.mem.GraphMem;
+ }
+
+ /**
+ * Test that clear works, in the presence of inferencing graphs that mean
+ * emptyness isn't available. This is why we go round the houses and test
+ * that expected ~= initialContent + addedStuff - removed - initialContent.
+ */
+ @ContractTest
+ public void testClear_Empty()
+ {
+ Graph graph = producer.newInstance();
+ Graph base = copy(graph);
+
+ graph.getEventManager().register(GL);
+ txnRun(graph, () -> graph.clear());
+
+ txnRun(graph, () -> assertEmpty(graph, base));
+ GL.assertHasStart("someEvent", graph, GraphEvents.removeAll);
+ GL.clear();
+ }
+
+ @ContractTest
+ public void testClear()
+ {
+ Graph graph = producer.newInstance();
+ Graph base = copy(graph);
+ // test after adding
+ graphWith(graph, "S P O; S e:ff 27; _1 P P3; S4 P4 'en'");
+ graph.getEventManager().register(GL);
+ txnRun(graph, () -> graph.clear());
+
+ txnRun(graph, () -> assertEmpty(graph, base));
+ if (GL.contains("delete"))
+ {
+ // deletes are listed -- ensure all deletes are listed
+ GL.assertContains("delete", graph, triple("S P O"));
+ GL.assertContains("delete", graph, triple("S e:ff 27"));
+ GL.assertContains("delete", graph, triple("_1 P P3"));
+ GL.assertContains("delete", graph, triple("S4 P4 'en'"));
+ }
+ GL.assertHasEnd("someEvent", graph, GraphEvents.removeAll);
+ GL.clear();
+
+ }
+
+ @ContractTest
+ public void testClose()
+ {
+ Graph graph = graphWith(producer.newInstance(),
+ "S P O; S P2 O2; S3 P P3");
+ graph.getEventManager().register(GL);
+ assertFalse("Graph was constructed closed", graph.isClosed());
+
+ txnRun(graph, () -> graph.close());
+
+ assertTrue("Graph should be closed", graph.isClosed());
+
+ // exception may be thrown on begin or on execution.
+ try
+ {
+ txnBegin(graph);
+ try
+ {
+ graph.add(triple("S P O"));
+ fail("added when closed");
+ } catch (Exception expected)
+ {
+ GL.assertEmpty();
+ // expected
+ } finally
+ {
+ txnRollback(graph);
+ }
+ } catch (Exception expected)
+ {
+ GL.assertEmpty();
+ // expected
+ }
+
+ try
+ {
+ txnBegin(graph);
+ try
+ {
+ graph.delete(triple("x R y"));
+ fail("delete when closed");
+ } catch (ClosedException c)
+ {
+ // Expected
+ } finally
+ {
+ txnRollback(graph);
+ GL.assertEmpty();
+ }
+ } catch (Exception expected)
+ {
+ GL.assertEmpty();
+ // expected
+ }
+
+ try
+ {
+ txnBegin(graph);
+
+ try
+ {
+ graph.add(triple("x R y"));
+ fail("add when closed");
+ } catch (ClosedException c)
+ { /* as required */
+ } finally
+ {
+ txnRollback(graph);
+ GL.assertEmpty();
+ }
+ } catch (Exception expected)
+ {
+ GL.assertEmpty();
+ // expected
+ }
+
+ try
+ {
+ txnBegin(graph);
+ try
+ {
+ graph.contains(triple("x R y"));
+ fail("contains[triple] when closed");
+ } catch (ClosedException c)
+ { /* as required */
+ } finally
+ {
+ txnRollback(graph);
+ GL.assertEmpty();
+ }
+ } catch (Exception expected)
+ {
+ GL.assertEmpty();
+ // expected
+ }
+
+ try
+ {
+ txnBegin(graph);
+ try
+ {
+ graph.contains(Node.ANY, Node.ANY, Node.ANY);
+ fail("contains[SPO] when closed");
+ } catch (ClosedException c)
+ { /* as required */
+ } finally
+ {
+ txnRollback(graph);
+ GL.assertEmpty();
+ }
+ } catch (Exception expected)
+ {
+ GL.assertEmpty();
+ // expected
+ }
+
+ try
+ {
+ txnBegin(graph);
+ try
+ {
+ graph.find(triple("x R y"));
+ fail("find [triple] when closed");
+ } catch (ClosedException c)
+ { /* as required */
+ } finally
+ {
+ txnRollback(graph);
+ GL.assertEmpty();
+ }
+ } catch (Exception expected)
+ {
+ GL.assertEmpty();
+ // expected
+ }
+
+ try
+ {
+ txnBegin(graph);
+ try
+ {
+ graph.find(Node.ANY, Node.ANY, Node.ANY);
+ fail("find[SPO] when closed");
+ } catch (ClosedException c)
+ { /* as required */
+ } finally
+ {
+ txnRollback(graph);
+ GL.assertEmpty();
+ }
+ } catch (Exception expected)
+ {
+ GL.assertEmpty();
+ // expected
+ }
+
+ try
+ {
+ txnBegin(graph);
+ try
+ {
+ graph.size();
+ fail("size when closed (" + this.getClass() + ")");
+ } catch (ClosedException c)
+ { /* as required */
+ } finally
+ {
+ txnRollback(graph);
+ GL.assertEmpty();
+ }
+ } catch (Exception expected)
+ {
+ GL.assertEmpty();
+ // expected
+ }
+ }
+
+ @ContractTest
+ public void testContains_Node_Node_Node()
+ {
+ Graph graph = graphWith(producer.newInstance(),
+ "S P O; S2 P2 O2; S3 P3 O3");
+
+ txnRun(graph, () -> {
+ assertTrue(graph.contains(node("S"), node("P"), node("O")));
+ assertFalse(graph.contains(node("S"), node("P"), node("O2")));
+ assertFalse(graph.contains(node("S"), node("P2"), node("O")));
+ assertFalse(graph.contains(node("S2"), node("P"), node("O")));
+ assertTrue(graph.contains(Node.ANY, Node.ANY, Node.ANY));
+ assertTrue(graph.contains(Node.ANY, Node.ANY, node("O")));
+ assertTrue(graph.contains(Node.ANY, node("P"), Node.ANY));
+ assertTrue(graph.contains(node("S"), Node.ANY, Node.ANY));
+ });
+ }
+
+ @ContractTest
+ public void testContains_Node_Node_Node_RepeatedSubjectDoesNotConceal()
+ {
+
+ Graph g = graphWith(producer.newInstance(), "s P o; s Q r");
+ Node s = node("s");
+ Node P = node("P");
+ Node o = node("o");
+ Node Q = node("Q");
+ Node r = node("r");
+ Node any = node("??");
+ txnRun(g, () -> {
+ assertTrue(g.contains(s, P, o));
+ assertTrue(g.contains(s, Q, r));
+ assertTrue(g.contains(any, P, o));
+ assertTrue(g.contains(any, Q, r));
+ assertTrue(g.contains(any, P, any));
+ assertTrue(g.contains(any, Q, any));
+ });
+ }
+
+ @ContractTest
+ public void testContains_Node_Node_Node_Concrete()
+ {
+ Node s = node("s");
+ Node P = node("P");
+ Node o = node("o");
+
+ Node _x = node("_x");
+ Node R = node("R");
+ Node _y = node("_y");
+
+ Node x = node("x");
+ Node S = node("S");
+
+ Graph g = graphWith(producer.newInstance(), "s P o; _x R _y; x S 0");
+ txnRun(g, () -> {
+
+ assertTrue("Graph should have contained s P o",
+ g.contains(s, P, o));
+ assertTrue("Graph should have contained _x _R _y",
+ g.contains(_x, R, _y));
+ assertTrue("Graph should have contained x S 'O'",
+ g.contains(x, S, node("0")));
+ /* */
+ assertFalse(g.contains(s, P, node("Oh")));
+ assertFalse(g.contains(S, P, node("O")));
+ assertFalse(g.contains(s, node("p"), o));
+ assertFalse(g.contains(_x, node("_r"), _y));
+ assertFalse(g.contains(x, S, node("1")));
+ });
+ }
+
+ @ContractTest
+ public void testContains_Node_Node_Node_Concrete_BlankPredicate()
+ {
+ Node s = node("s");
+ Node P = node("P");
+ Node o = node("o");
+
+ Node _x = node("_x");
+ Node _R = node("_R");
+ Node _y = node("_y");
+
+ Node x = node("x");
+ Node S = node("S");
+
+ Graph g = graphWith(producer.newInstance(), "s P o; _x _R _y; x S 0");
+ txnRun(g, () -> {
+
+ assertTrue("Graph should have contained _x _R _y",
+ g.contains(_x, _R, _y));
+ assertFalse(g.contains(_x, node("_r"), _y));
+ });
+ }
+
+ @ContractTest
+ public void testContains_Node_Node_Node_Fluid()
+ {
+ Node x = node("x");
+ Node R = node("R");
+ Node P = node("P");
+ Node y = node("y");
+ Node a = node("a");
+ Node b = node("b");
+ Graph g = graphWith(producer.newInstance(), "x R y; a P b");
+
+ txnRun(g, () -> {
+ assertTrue(g.contains(Node.ANY, R, y));
+ assertTrue(g.contains(x, Node.ANY, y));
+ assertTrue(g.contains(x, R, Node.ANY));
+ assertTrue(g.contains(Node.ANY, P, b));
+ assertTrue(g.contains(a, Node.ANY, b));
+ assertTrue(g.contains(a, P, Node.ANY));
+ assertTrue(g.contains(Node.ANY, R, y));
+ /* */
+ assertFalse(g.contains(Node.ANY, R, b));
+ assertFalse(g.contains(a, Node.ANY, y));
+ assertFalse(g.contains(x, P, Node.ANY));
+ assertFalse(g.contains(Node.ANY, R, x));
+ assertFalse(g.contains(x, Node.ANY, R));
+ assertFalse(g.contains(a, node("S"), Node.ANY));
+ });
+ }
+
+ @ContractTest
+ public void testContains_Triple()
+ {
+ Graph graph = graphWith(producer.newInstance(),
+ "S P O; S2 P2 O2; S3 P3 O3");
+ txnRun(graph, () -> {
+ assertTrue(graph.contains(triple("S P O")));
+ assertFalse(graph.contains(triple("S P O2")));
+ assertFalse(graph.contains(triple("S P2 O")));
+ assertFalse(graph.contains(triple("S2 P O")));
+ assertTrue(graph.contains(Triple.ANY));
+ assertTrue(
+ graph.contains(Triple.create(Node.ANY, Node.ANY, node("O"))));
+ assertTrue(
+ graph.contains(Triple.create(Node.ANY, node("P"), Node.ANY)));
+ assertTrue(
+ graph.contains(Triple.create(node("S"), Node.ANY, Node.ANY)));
+ });
+
+ }
+
+ @ContractTest
+ public void testContains_Triple_RepeatedSubjectDoesNotConceal()
+ {
+
+ Graph g = graphWith(producer.newInstance(), "s P o; s Q r");
+ txnRun(g, () -> {
+ assertTrue(g.contains(triple("s P o")));
+ assertTrue(g.contains(triple("s Q r")));
+ assertTrue(g.contains(triple("?? P o")));
+ assertTrue(g.contains(triple("?? Q r")));
+ assertTrue(g.contains(triple("?? P ??")));
+ assertTrue(g.contains(triple("?? Q ??")));
+ });
+ }
+
+ @ContractTest
+ public void testContains_Triple_Concrete()
+ {
+ Graph g = graphWith(producer.newInstance(), "s P o; _x R _y; x S 0");
+ txnRun(g, () -> {
+ assertTrue(g.contains(triple("s P o")));
+ assertTrue(g.contains(triple("_x R _y")));
+ assertTrue(g.contains(triple("x S 0")));
+ /* */
+ assertFalse(g.contains(triple("s P Oh")));
+ assertFalse(g.contains(triple("S P O")));
+ assertFalse(g.contains(triple("s p o")));
+ assertFalse(g.contains(triple("_x _r _y")));
+ assertFalse(g.contains(triple("x S 1")));
+ });
+ }
+
+ @ContractTest
+ public void testContains_Triple_Concrete_BlankPredicate()
+ {
+ Graph g = graphWith(producer.newInstance(), "s P o; _x _R _y; x S 0");
+ txnRun(g, () -> {
+ assertTrue(g.contains(triple("s P o")));
+ assertTrue(g.contains(triple("_x _R _y")));
+ assertTrue(g.contains(triple("x S 0")));
+ /* */
+ assertFalse(g.contains(triple("s P Oh")));
+ assertFalse(g.contains(triple("S P O")));
+ assertFalse(g.contains(triple("s p o")));
+ assertFalse(g.contains(triple("_x _r _y")));
+ assertFalse(g.contains(triple("x S 1")));
+ });
+ }
+
+ @ContractTest
+ public void testContains_Triple_Fluid()
+ {
+ Graph g = graphWith(producer.newInstance(), "x R y; a P b");
+ txnRun(g, () -> {
+
+ assertTrue(g.contains(triple("?? R y")));
+ assertTrue(g.contains(triple("x ?? y")));
+ assertTrue(g.contains(triple("x R ??")));
+ assertTrue(g.contains(triple("?? P b")));
+ assertTrue(g.contains(triple("a ?? b")));
+ assertTrue(g.contains(triple("a P ??")));
+ assertTrue(g.contains(triple("?? R y")));
+ /* */
+ assertFalse(g.contains(triple("?? R b")));
+ assertFalse(g.contains(triple("a ?? y")));
+ assertFalse(g.contains(triple("x P ??")));
+ assertFalse(g.contains(triple("?? R x")));
+ assertFalse(g.contains(triple("x ?? R")));
+ assertFalse(g.contains(triple("a S ??")));
+ });
+ }
+
+ /**
+ * Inference graphs can not be empty
+ */
+ @ContractTest
+ public void testDelete_Triple()
+ {
+ Graph graph = graphWith(producer.newInstance(),
+ "S P O; S2 P2 O2; S3 P3 O3");
+ Graph base = producer.newInstance();
+ graph.getEventManager().register(GL);
+
+ try
+ {
+ txnBegin(graph);
+ graph.delete(triple("S P O"));
+ txnCommit(graph);
+ } catch (DeleteDeniedException expected)
+ {
+ txnRollback(graph);
+ fail("delete( S P O ) failed: " + expected.getMessage());
+ }
+
+ GL.assertContains("delete", graph, triple("S P O"));
+
+ txnRun(graph, () -> {
+ assertFalse("Graph should not contain <S P O>",
+ graph.contains(triple("S P O")));
+ assertNotEmpty(graph, base);
+ assertTrue("Graph should contain <S2 P2 O2>",
+ graph.contains(triple("S2 P2 O2")));
+ assertTrue("Graph should contain <S3 P3 O3>",
+ graph.contains(triple("S3 P3 O3")));
+ });
+ }
+
+ @ContractTest
+ public void testDelete_Triple_Wildcard()
+ {
+ Graph graph = graphWith(producer.newInstance(),
+ "S P O; S2 P2 O2; S3 P3 O3");
+ Graph base = producer.newInstance();
+ graph.getEventManager().register(GL);
+
+ // should not modify anything on wildcard delete
+ GL.clear();
+ try
+ {
+ txnBegin(graph);
+ graph.delete(Triple.create(node("S2"), node("P2"), Node.ANY));
+ txnCommit(graph);
+ } catch (DeleteDeniedException expected)
+ {
+ txnRollback(graph);
+ }
+ txnRun(graph, () -> {
+
+ assertTrue("Graph should contain <S2 P2 O2>",
+ graph.contains(triple("S2 P2 O2")));
+ assertTrue("Graph should contain <S3 P3 O3>",
+ graph.contains(triple("S3 P3 O3")));
+ });
+ GL.assertHas("delete", graph,
+ Triple.create(node("S2"), node("P2"), Node.ANY));
+ }
+
+ @ContractTest
+ public void testDelete_Triple_FromNothing()
+ {
+ Graph g = producer.newInstance();
+ g.getEventManager().register(GL);
+ txnBegin(g);
+ g.delete(triple("quint rdf:subject S"));
+ txnCommit(g);
+ GL.assertContains("delete", g, triple("quint rdf:subject S"));
+ }
+
+ @ContractTest
+ public void testDependsOn()
+ {
+ Graph g = producer.newInstance();
+ Graph[] depGraphs = producer.getDependsOn(g);
+ if (depGraphs != null)
+ {
+ for (Graph dg : depGraphs)
+ {
+ assertTrue(
+ String.format("Graph %s should depend upon %s", g, dg),
+ g.dependsOn(dg));
+ }
+ }
+ depGraphs = producer.getNotDependsOn(g);
+ if (depGraphs != null)
+ {
+ for (Graph dg : depGraphs)
+ {
+ assertFalse(String.format("Graph %s should not depend upon %s",
+ g, dg), g.dependsOn(dg));
+ }
+ }
+ }
+
+ @ContractTest
+ public void testFind_Node_Node_Node()
+ {
+ Graph graph = graphWith(producer.newInstance(),
+ "S P O; S2 P2 O2; S3 P3 O3");
+ txnBegin(graph);
+ List<Triple> s = graph.find(Node.ANY, Node.ANY, Node.ANY).toList();
+ assertEquals(3, s.size());
+ List<Triple> expected = Arrays.asList(new Triple[] { triple("S P O"),
+ triple("S2 P2 O2"), triple("S3 P3 O3") });
+ assertTrue("Missing some values",
+ expected.containsAll(s) && s.containsAll(expected));
+
+ s = graph.find(node("S"), Node.ANY, Node.ANY).toList();
+ assertEquals(1, s.size());
+ assertTrue("Missing some values", s.contains(triple("S P O")));
+
+ s = graph.find(Node.ANY, node("P"), Node.ANY).toList();
+ assertEquals(1, s.size());
+ assertTrue("Missing some values", s.contains(triple("S P O")));
+
+ s = graph.find(Node.ANY, Node.ANY, node("O")).toList();
+ assertEquals(1, s.size());
+ assertTrue("Missing some values", s.contains(triple("S P O")));
+
+ s = graph.find(node("S2"), node("P2"), node("O2")).toList();
+ assertEquals(1, s.size());
+ assertTrue("Missing some values", s.contains(triple("S2 P2 O2")));
+
+ s = graph.find(node("S2"), node("P3"), node("O2")).toList();
+ assertEquals(0, s.size());
+
+ s = graph.find(Node.ANY, node("P3"), node("O2")).toList();
+ assertEquals(0, s.size());
+
+ s = graph.find(node("S3"), Node.ANY, node("O2")).toList();
+ assertEquals(0, s.size());
+
+ s = graph.find(node("S3"), node("P2"), Node.ANY).toList();
+ assertEquals(0, s.size());
+ txnRollback(graph);
+ }
+
+ @ContractTest
+ public void testFind_Node_Node_Node_ByFluidTriple()
+ {
+ Node x = node("x");
+ Node y = node("y");
+ Node z = node("z");
+ Graph g = graphWith(producer.newInstance(), "x y z ");
+ Set<Triple> expect = tripleSet("x y z");
+ txnBegin(g);
+ assertEquals(expect, g.find(Node.ANY, y, z).toSet());
+ assertEquals(expect, g.find(x, Node.ANY, z).toSet());
+ assertEquals(expect, g.find(x, y, Node.ANY).toSet());
+ txnRollback(g);
+ }
+
+ @ContractTest
+ public void testFind_Node_Node_Node_MatchLanguagedLiteralCaseInsensitive()
+ {
+ Graph g = graphWith(producer.newInstance(), "a p 'chat'en");
+ Node chaten = node("'chat'en"), chatEN = node("'chat'EN");
+ assertEquals(chaten, chatEN);
+ assertTrue(chaten.sameValueAs(chatEN));
+ assertEquals(chaten.getIndexingValue(), chatEN.getIndexingValue());
+ txnBegin(g);
+ assertEquals(1, g.find(Node.ANY, Node.ANY, chaten).toList().size());
+ assertEquals(1, g.find(Node.ANY, Node.ANY, chatEN).toList().size());
+ txnRollback(g);
+ }
+
+ @ContractTest
+ public void testFind_Node_Node_Node_NoMatchAgainstUnlanguagesLiteral()
+ {
+ Graph g = graphWith(producer.newInstance(), "a p 'chat'en; a p 'chat'");
+ Node chaten = node("'chat'en"), chatEN = node("'chat'EN");
+ assertEquals(chaten, chatEN);
+ assertTrue(chaten.sameValueAs(chatEN));
+ assertEquals(chaten.getIndexingValue(), chatEN.getIndexingValue());
+ txnBegin(g);
+ assertEquals(1, g.find(Node.ANY, Node.ANY, chaten).toList().size());
+ assertEquals(1, g.find(Node.ANY, Node.ANY, chatEN).toList().size());
+ txnRollback(g);
+ }
+
+ @ContractTest
+ public void testFind_Triple()
+ {
+ Graph graph = graphWith(producer.newInstance(),
+ "S P O; S2 P2 O2; S3 P3 O3");
+ txnBegin(graph);
+ List<Triple> s = graph.find(Triple.ANY).toList();
+ assertEquals(3, s.size());
+ List<Triple> expected = Arrays.asList(new Triple[] { triple("S P O"),
+ triple("S2 P2 O2"), triple("S3 P3 O3") });
+ assertTrue("Missing some values", expected.containsAll(s));
+
+ s = graph.find(Triple.create(node("S"), Node.ANY, Node.ANY)).toList();
+ assertEquals(1, s.size());
+ assertTrue("Missing some values", s.contains(triple("S P O")));
+
+ s = graph.find(Triple.create(Node.ANY, node("P"), Node.ANY)).toList();
+ assertEquals(1, s.size());
+ assertTrue("Missing some values", s.contains(triple("S P O")));
+
+ s = graph.find(Triple.create(Node.ANY, Node.ANY, node("O"))).toList();
+ assertEquals(1, s.size());
+ assertTrue("Missing some values", s.contains(triple("S P O")));
+
+ s = graph.find(Triple.create(node("S2"), node("P2"), node("O2"))).toList();
+ assertEquals(1, s.size());
+ assertTrue("Missing some values", s.contains(triple("S2 P2 O2")));
+
+ s = graph.find(Triple.create(node("S2"), node("P3"), node("O2"))).toList();
+ assertEquals(0, s.size());
+
+ s = graph.find(Triple.create(Node.ANY, node("P3"), node("O2"))).toList();
+ assertEquals(0, s.size());
+
+ s = graph.find(Triple.create(node("S3"), Node.ANY, node("O2"))).toList();
+ assertEquals(0, s.size());
+
+ s = graph.find(Triple.create(node("S3"), node("P2"), Node.ANY)).toList();
+ assertEquals(0, s.size());
+ txnRollback(graph);
+ }
+
+ @ContractTest
+ public void testFind_Triple_ByFluidTriple()
+ {
+ Graph g = graphWith(producer.newInstance(), "x y z ");
+ Set<Triple> expect = tripleSet("x y z");
+ txnBegin(g);
+ assertEquals(expect, g.find(triple("?? y z")).toSet());
+ assertEquals(expect, g.find(triple("x ?? z")).toSet());
+ assertEquals(expect, g.find(triple("x y ??")).toSet());
+ txnRollback(g);
+ }
+
+ @ContractTest
+ public void testFind_Triple_NoMatchAgainstUnlanguagesLiteral()
+ {
+ Graph g = graphWith(producer.newInstance(), "a p 'chat'en; a p 'chat'");
+ Node chaten = node("'chat'en"), chatEN = node("'chat'EN");
+ assertEquals(chaten, chatEN);
+ assertTrue(chaten.sameValueAs(chatEN));
+ assertEquals(chaten.getIndexingValue(), chatEN.getIndexingValue());
+ txnBegin(g);
+ assertEquals(1, g.find(Triple.create(Node.ANY, Node.ANY, chaten))
+ .toList().size());
+ assertEquals(1, g.find(Triple.create(Node.ANY, Node.ANY, chatEN))
+ .toList().size());
+ txnRollback(g);
+ }
+
+ @ContractTest
+ public void testGetEventManager()
+ {
+ assertNotNull("Must return an EventManager",
+ producer.newInstance().getEventManager());
+ }
+
+ @ContractTest
+ public void testGetPrefixMapping()
+ {
+ Graph g = producer.newInstance();
+ txnBegin(g);
+ PrefixMapping pm = g.getPrefixMapping();
+ assertNotNull("Must return prefix mapping", pm);
+ assertSame("getPrefixMapping must always return the same object", pm,
+ g.getPrefixMapping());
+ txnRollback(g);
+ pm.setNsPrefix("pfx1", "http://example.com/");
+ pm.setNsPrefix("pfx2", "scheme:rope/string#");
+
+ txnBegin(g);
+ // assert same after adding to other mapl
+ assertSame("getPrefixMapping must always return the same object", pm,
+ g.getPrefixMapping());
+ txnRollback(g);
+
+ }
+
+ @ContractTest
+ public void testGetTransactionHandler()
+ {
+ Graph g = producer.newInstance();
+ assertNotNull("Must return a Transaction handler",
+ g.getTransactionHandler());
+ }
+
+ @ContractTest
+ public void testIsClosed()
+ {
+ Graph g = producer.newInstance();
+ assertFalse("Graph created in closed state", g.isClosed());
+ txnBegin(g);
+ g.close();
+ txnCommit(g);
+ txnBegin(g);
+ assertTrue("Graph does not report closed state after close called",
+ g.isClosed());
+ txnRollback(g);
+ }
+
+ @ContractTest
+ public void testIsEmpty()
+ {
+ Graph g = producer.newInstance();
+ txnBegin(g);
+ if (!g.isEmpty())
+ {
+ LOG.warn(String.format(
+ "Graph type %s can not be empty (Empty test skipped)",
+ g.getClass()));
+ txnRollback(g);
+ } else
+ {
+ txnRollback(g);
+ graphAddTxn(g, "S P O");
+ txnBegin(g);
+ assertFalse("Graph reports empty after add", g.isEmpty());
+ txnRollback(g);
+
+ txnBegin(g);
+ g.add(NodeCreateUtils.createTriple("Foo B C"));
+ g.delete(NodeCreateUtils.createTriple("S P O"));
+ txnCommit(g);
+ txnBegin(g);
+ assertFalse("Should not report empty", g.isEmpty());
+ txnRollback(g);
+
+ txnBegin(g);
+ g.delete(NodeCreateUtils.createTriple("Foo B C"));
+ txnCommit(g);
+ txnBegin(g);
+ assertTrue("Should report empty after all entries deleted",
+ g.isEmpty());
+ txnRollback(g);
+ }
+ }
+
+ @ContractTest
+ public void testIsIsomorphicWith_Graph()
+ {
+ Graph graph = producer.newInstance();
+ Graph g2 = memGraph();
+ txnBegin(graph);
+ assertTrue("Empty graphs should be isomorphic",
+ graph.isIsomorphicWith(g2));
+ txnRollback(graph);
+ graphWith(graph, "S P O; S2 P2 O2; S3 P3 O3");
+ g2 = graphWith("S3 P3 O3; S2 P2 O2; S P O");
+ txnBegin(graph);
+ assertTrue("Should be isomorphic", graph.isIsomorphicWith(g2));
+ txnRollback(graph);
+ txnBegin(graph);
+ graph.add(triple("_1, P4 S4"));
+ txnCommit(graph);
+
+ txnBegin(g2);
+ g2.add(triple("_2, P4 S4"));
+ txnCommit(g2);
+ txnBegin(graph);
+ assertTrue("Should be isomorphic after adding anonymous nodes",
+ graph.isIsomorphicWith(g2));
+ txnRollback(graph);
+
+ txnBegin(graph);
+ graph.add(triple("_1, P3 S4"));
+ txnCommit(graph);
+
+ txnBegin(g2);
+ g2.add(triple("_2, P4 S4"));
+ txnCommit(g2);
+ txnBegin(graph);
+ assertFalse("Should not be isomorphic", graph.isIsomorphicWith(g2));
+ txnRollback(graph);
+ }
+
+ private Graph copy(Graph g)
+ {
+ Graph result = producer.newInstance();
+ txnBegin(result);
+ GraphUtil.addInto(result, g);
+ txnCommit(result);
+ return result;
+ }
+
+ private Graph remove(Graph toUpdate, Graph toRemove)
+ {
+ txnBegin(toUpdate);
+ GraphUtil.deleteFrom(toUpdate, toRemove);
+ txnCommit(toUpdate);
+ return toUpdate;
+ }
+
+ /**
+ * Test that remove(s, p, o) works, in the presence of inferencing graphs
+ * that mean emptyness isn't available. This is why we go round the houses
+ * and test that expected ~= initialContent + addedStuff - removed -
+ * initialContent.
+ */
+ @ContractTest
+ public void testRemove_Node_Node_Node()
+ {
+ for (int i = 0; i < cases.length; i += 1)
+ for (int j = 0; j < 3; j += 1)
+ {
+ Graph content = producer.newInstance();
+
+ Graph baseContent = copy(content);
+ graphAddTxn(content, cases[i][0]);
+ Triple remove = triple(cases[i][1]);
+ Graph expected = graphWith(cases[i][2]);
+ Triple[] removed = tripleArray(cases[i][3]);
+ content.getEventManager().register(GL);
+ GL.clear();
+ txnBegin(content);
+ content.remove(remove.getSubject(), remove.getPredicate(),
+ remove.getObject());
+ txnCommit(content);
+
+ // check for optional delete notifications
+ if (GL.contains("delete"))
+ {
+ // if it contains any it must contain all.
+ for (Triple t : removed)
+ {
+ GL.assertContains("delete", content, t);
+ }
+ }
+ GL.assertHasEnd("someEvent", content,
+ GraphEvents.remove(remove.getSubject(),
+ remove.getPredicate(), remove.getObject()));
+
+ content.getEventManager().unregister(GL);
+ Graph finalContent = remove(copy(content), baseContent);
+ txnBegin(finalContent);
+ assertIsomorphic(cases[i][1], expected, finalContent);
+ txnRollback(finalContent);
+ }
+ }
+
+ @ContractTest
+ public void testRemove_ByIterator()
+ {
+ testRemove("?? ?? ??", "?? ?? ??");
+ testRemove("S ?? ??", "S ?? ??");
+ testRemove("S ?? ??", "?? P ??");
+ testRemove("S ?? ??", "?? ?? O");
+ testRemove("?? P ??", "S ?? ??");
+ testRemove("?? P ??", "?? P ??");
+ testRemove("?? P ??", "?? ?? O");
+ testRemove("?? ?? O", "S ?? ??");
+ testRemove("?? ?? O", "?? P ??");
+ testRemove("?? ?? O", "?? ?? O");
+ }
+
+ private void testRemove(String findRemove, String findCheck)
+ {
+ Graph g = graphWith(producer.newInstance(), "S P O");
+ txnBegin(g);
+ ExtendedIterator<Triple> it = g
+ .find(NodeCreateUtils.createTriple(findRemove));
+ txnRollback(g);
+ try
+ {
+ it.next();
+ it.remove();
+ it.close();
+ assertEquals("remove with " + findRemove + ":", 0, g.size());
+ assertFalse(g.contains(NodeCreateUtils.createTriple(findCheck)));
+ } catch (UnsupportedOperationException e)
+ {
+ it.close();
+ }
+ }
+
+ /**
+ * This test case was generated by Ian and was caused by GraphMem not
+ * keeping up with changes to the find interface.
+ */
+ @ContractTest
+ public void testFindAndContains()
+ {
+ Graph g = producer.newInstance();
+ Node r = NodeCreateUtils.create("r"), s = NodeCreateUtils.create("s"),
+ p = NodeCreateUtils.create("P");
+ txnBegin(g);
+ try
+ {
+ g.add(Triple.create(r, p, s));
+ txnCommit(g);
+ txnBegin(g);
+ assertTrue(g.contains(r, p, Node.ANY));
+ assertEquals(1, g.find(r, p, Node.ANY).toList().size());
+ } catch (Exception e)
+ {
+ fail(e.getMessage());
+ } finally
+ {
+ txnRollback(g);
+ }
+ }
+
+ /**
+ * Check that contains respects by-value semantics.
+ */
+
+ @ContractTest
+ public void testAGraph()
+ {
+ String title = this.getClass().getName();
+ Graph g = producer.newInstance();
+ txnBegin(g);
+ int baseSize = g.size();
+ txnRollback(g);
+ graphAddTxn(g, "x R y; p S q; a T b");
+ /* */
+ txnBegin(g);
+ assertContainsAll(title + ": simple graph", g, "x R y; p S q; a T b");
+ assertEquals(title + ": size", baseSize + 3, g.size());
+ txnRollback(g);
+
+ graphAddTxn(g,
+ "spindizzies lift cities; Diracs communicate instantaneously");
+ txnBegin(g);
+ assertEquals(title + ": size after adding", baseSize + 5, g.size());
+
+ g.delete(triple("x R y"));
+ g.delete(triple("a T b"));
+ txnCommit(g);
+ txnBegin(g);
+ assertEquals(title + ": size after deleting", baseSize + 3, g.size());
+ assertContainsAll(title + ": modified simple graph", g,
+ "p S q; spindizzies lift cities; Diracs communicate instantaneously");
+ assertOmitsAll(title + ": modified simple graph", g, "x R y; a T b");
+ /* */
+ ClosableIterator<Triple> it = g.find(Node.ANY, node("lift"), Node.ANY);
+ assertTrue(title + ": finds some triple(s)", it.hasNext());
+ assertEquals(title + ": finds a 'lift' triple",
+ triple("spindizzies lift cities"), it.next());
+ assertFalse(title + ": finds exactly one triple", it.hasNext());
+ txnRollback(g);
+ it.close();
+ }
+
+ @ContractTest
+ public void testAddWithReificationPreamble()
+ {
+ Graph g = producer.newInstance();
+ txnBegin(g);
+ xSPO(g);
+ txnCommit(g);
+ txnBegin(g);
+ assertFalse(g.isEmpty());
+ txnRollback(g);
+ }
+
+ protected void xSPOyXYZ(Graph g)
+ {
+ xSPO(g);
+ ReifierStd.reifyAs(g, NodeCreateUtils.create("y"),
+ NodeCreateUtils.createTriple("X Y Z"));
+ }
+
+ protected void aABC(Graph g)
+ {
+ ReifierStd.reifyAs(g, NodeCreateUtils.create("a"),
+ NodeCreateUtils.createTriple("Foo B C"));
+ }
+
+ protected void xSPO(Graph g)
+ {
+ ReifierStd.reifyAs(g, NodeCreateUtils.create("x"),
+ NodeCreateUtils.createTriple("S P O"));
+ }
+
+ @ContractTest
+ public void failingTestDoubleRemoveAll()
+ {
+ final Graph g = producer.newInstance();
+ try
+ {
+ graphAddTxn(g, "c S d; e:ff GGG hhhh; _i J 27; Ell Em 'en'");
+ txnBegin(g);
+ Iterator<Triple> it = new TrackingTripleIterator(g.find(Triple.ANY))
+ {
+ @Override
+ public void remove()
+ {
+ super.remove(); // removes current
+ g.delete(current); // no-op.
+ }
+ };
+ txnRollback(g);
+ while (it.hasNext())
+ {
+ it.next();
+ it.remove();
+ }
+ txnBegin(g);
+ assertTrue(g.isEmpty());
+ txnRollback(g);
+ } catch (UnsupportedOperationException e)
+ {
+ // No Iterator.remove
+ }
+ }
+
+ /**
+ * Test cases for RemoveSPO(); each entry is a triple (add, remove, result).
+ * <ul>
+ * <li>add - the triples to add to the graph to start with
+ * <li>remove - the pattern to use in the removal
+ * <li>result - the triples that should remain in the graph
+ * </ul>
+ */
+ protected static String[][] cases = { { "x R y", "x R y", "", "x R y" },
+ { "x R y; a P b", "x R y", "a P b", "x R y" },
+ { "x R y; a P b", "?? R y", "a P b", "x R y" },
+ { "x R y; a P b", "x R ??", "a P b", "x R y" },
+ { "x R y; a P b", "x ?? y", "a P b", "x R y" },
+ { "x R y; a P b", "?? ?? ??", "", "x R y; a P b" },
+ { "x R y; a P b; c P d", "?? P ??", "x R y", "a P b; c P d" },
+ { "x R y; a P b; x S y", "x ?? ??", "a P b", "x R y; x S y" }, };
+
+ /**
+ * testIsomorphism from file data
+ *
+ * @throws URISyntaxException
+ * @throws MalformedURLException
+ */
+ @ContractTest
+ public void testIsomorphismFile()
+ throws URISyntaxException, MalformedURLException
+ {
+ testIsomorphismXMLFile(1, true);
+ testIsomorphismXMLFile(2, true);
+ testIsomorphismXMLFile(3, true);
+ testIsomorphismXMLFile(4, true);
+ testIsomorphismXMLFile(5, false);
+ testIsomorphismXMLFile(6, false);
+ testIsomorphismNTripleFile(7, true);
+ testIsomorphismNTripleFile(8, false);
+
+ }
+
+ private void testIsomorphismNTripleFile(int i, boolean result)
+ {
+ testIsomorphismFile(i, "N-TRIPLE", "nt", result);
+ }
+
+ private void testIsomorphismXMLFile(int i, boolean result)
+ {
+ testIsomorphismFile(i, "RDF/XML", "rdf", result);
+ }
+
+ private InputStream getInputStream(int n, int n2, String suffix)
+ {
+ String urlStr = String.format("regression/testModelEquals/%s-%s.%s", n,
+ n2, suffix);
+ return GraphContractTest.class.getClassLoader()
+ .getResourceAsStream(urlStr);
+ }
+
+ private void testIsomorphismFile(int n, String lang, String suffix,
+ boolean result)
+ {
+ Graph g1 = producer.newInstance();
+ Graph g2 = producer.newInstance();
+ Model m1 = ModelFactory.createModelForGraph(g1);
+ Model m2 = ModelFactory.createModelForGraph(g2);
+
+ txnBegin(g1);
+ m1.read(getInputStream(n, 1, suffix), "http://www.example.org/", lang);
+ txnCommit(g1);
+
+ txnBegin(g2);
+ m2.read(getInputStream(n, 2, suffix), "http://www.example.org/", lang);
+ txnCommit(g2);
+
+ txnBegin(g1);
+ boolean rslt = g1.isIsomorphicWith(g2) == result;
+ txnRollback(g1);
+ if (!rslt)
+ {
+ System.out.println("g1:");
+ m1.write(System.out, "N-TRIPLE");
+ System.out.println("g2:");
+ m2.write(System.out, "N-TRIPLE");
+ }
+ assertTrue("Isomorphism test failed", rslt);
+ }
+
+ protected Graph getClosed()
+ {
+ Graph result = producer.newInstance();
+ result.close();
+ return result;
+ }
+
+ /**
+ * Ensure that triples removed by calling .remove() on the iterator returned
+ * by a find() will generate deletion notifications.
+ */
+ @ContractTest
+ public void testIterator_Remove()
+ {
+ Graph graph = graphWith(producer.newInstance(), "a R b; b S e");
+ graph.getEventManager().register(GL);
+ txnBegin(graph);
+ Triple toRemove = triple("a R b");
+ ExtendedIterator<Triple> rtr = graph.find(toRemove);
+ assertTrue("ensure a(t least) one triple", rtr.hasNext());
+ txnRollback(graph);
+ try
+ {
+ rtr.next();
+ rtr.remove();
+ rtr.close();
+ GL.assertHas("delete", graph, toRemove);
+ } catch (UnsupportedOperationException e)
+ {
+ // No Iterator.remove
+ }
+ }
+
+ @ContractTest
+ public void testTransactionHandler_Commit()
+ {
+ Graph g = producer.newInstance();
+ if (g.getTransactionHandler().transactionsSupported())
+ {
+ Graph initial = graphWith("initial hasValue 42; also hasURI hello");
+ Graph extra = graphWith("extra hasValue 17; also hasURI world");
+ g.getTransactionHandler().begin();
+ GraphUtil.addInto(g, initial);
+ g.getTransactionHandler().commit();
+ g.getTransactionHandler().begin();
+ GraphUtil.addInto(g, extra);
+ g.getTransactionHandler().commit();
+ Graph union = memGraph();
+ GraphUtil.addInto(union, initial);
+ GraphUtil.addInto(union, extra);
+ g.getTransactionHandler().begin();
+ assertIsomorphic(union, g);
+ g.getTransactionHandler().abort();
+ // Model inFiIProducer<TransactionHandler>le =
+ // ModelFactory.createDefaultModel();
+ // inFile.read( "file:///" + foo, "N-TRIPLES" );
+ // assertIsomorphic( union, inFile.getGraph() );
+ }
+ }
+
+ @ContractTest
+ public void testTransactionHandler_Abort()
+ {
+ Graph g = producer.newInstance();
+ if (g.getTransactionHandler().transactionsSupported())
+ {
+ Graph initial = graphWith(producer.newInstance(),
+ "initial hasValue 42; also hasURI hello");
+ Graph extra = graphWith(producer.newInstance(),
+ "extra hasValue 17; also hasURI world");
+ g.getTransactionHandler().begin();
+ GraphUtil.addInto(g, initial);
+ g.getTransactionHandler().commit();
+
+ g.getTransactionHandler().begin();
+ GraphUtil.addInto(g, extra);
+ g.getTransactionHandler().abort();
+
+ g.getTransactionHandler().begin();
+ assertIsomorphic(initial, g);
+ g.getTransactionHandler().abort();
+ }
+ }
+
+ @ContractTest
+ public void testTransactionHandler_CommitThenAbort()
+ {
+ Graph g = producer.newInstance();
+ if (g.getTransactionHandler().transactionsSupported())
+ {
+ Graph initial = graphWith(producer.newInstance(),
+ "Foo pings B; B pings C");
+ Graph extra = graphWith(producer.newInstance(),
+ "C pingedBy B; fileGraph rdf:type Graph");
+ g.getTransactionHandler().begin();
+ GraphUtil.addInto(g, initial);
+ g.getTransactionHandler().commit();
+ g.getTransactionHandler().begin();
+ GraphUtil.addInto(g, extra);
+ g.getTransactionHandler().abort();
+ g.getTransactionHandler().begin();
+ assertIsomorphic(initial, g);
+ g.getTransactionHandler().abort();
+ // Model inFile = ModelFactory.createDefaultModel();
+ // inFile.read( "file:///" + foo, "N-TRIPLES" );
+ // assertIsomorphic( initial, inFile.getGraph() );
+ }
+ }
+
+ //
+ // Test that literal typing works when supported
+ //
+
+ // used to find the object set from the returned set for literal testing
+
+ private static final Function<Triple, Node> getObject = new Function<Triple, Node>()
+ {
+ @Override
+ public Node apply(Triple t)
+ {
+ return t.getObject();
+ }
+ };
+
+ @ContractTest
+ public void testQuadRemove()
+ {
+ Graph g = producer.newInstance();
+ txnBegin(g);
+ assertEquals(0, g.size());
+ txnRollback(g);
+ Triple s = triple("x rdf:subject s");
+ Triple p = triple("x rdf:predicate p");
+ Triple o = triple("x rdf:object o");
+ Triple t = triple("x rdf:type rdf:Statement");
+ txnBegin(g);
+ g.add(s);
+ g.add(p);
+ g.add(o);
+ g.add(t);
+ txnCommit(g);
+ txnBegin(g);
+ assertEquals(4, g.size());
+ txnRollback(g);
+ txnBegin(g);
+ g.delete(s);
+ g.delete(p);
+ g.delete(o);
+ g.delete(t);
+ txnCommit(g);
+ txnBegin(g);
+ assertEquals(0, g.size());
+ txnRollback(g);
+ }
+
+ @ContractTest
+ public void testSizeAfterRemove()
+ {
+ Graph g = graphWith(producer.newInstance(), "x p y");
+ try
+ {
+ txnBegin(g);
+ ExtendedIterator<Triple> it = g.find(triple("x ?? ??"));
+ txnRollback(g);
+ it.removeNext();
+ txnBegin(g);
+ assertEquals(0, g.size());
+ txnRollback(g);
+ } catch (UnsupportedOperationException e)
+ {
+ // No Iterator.remove
+ }
+ }
+
+ @ContractTest
+ public void testBrokenIndexes()
+ {
+ Graph g = graphWith(producer.newInstance(), "x R y; x S z");
+ try
+ {
+ txnBegin(g);
+ ExtendedIterator<Triple> it = g.find(Node.ANY, Node.ANY, Node.ANY);
+ txnRollback(g);
+ it.removeNext();
+ it.removeNext();
+ txnBegin(g);
+ assertFalse(g.find(node("x"), Node.ANY, Node.ANY).hasNext());
+ assertFalse(g.find(Node.ANY, node("R"), Node.ANY).hasNext());
+ assertFalse(g.find(Node.ANY, Node.ANY, node("y")).hasNext());
+ txnRollback(g);
+ } catch (UnsupportedOperationException e)
+ {
+ // No Iterator.remove
+ }
+ }
+
+ @ContractTest
+ public void testBrokenSubject()
+ {
+ Graph g = graphWith(producer.newInstance(), "x brokenSubject y");
+ try
+ {
+ txnBegin(g);
+ ExtendedIterator<Triple> it = g.find(node("x"), Node.ANY, Node.ANY);
+ txnRollback(g);
+ it.removeNext();
+ txnBegin(g);
+ assertFalse(g.find(Node.ANY, Node.ANY, Node.ANY).hasNext());
+ txnRollback(g);
+ } catch (UnsupportedOperationException e)
+ {
+ // No Iterator.remove
+ }
+ }
+
+ @ContractTest
+ public void testBrokenPredicate()
+ {
+ Graph g = graphWith(producer.newInstance(), "x brokenPredicate y");
+ try
+ {
+ txnBegin(g);
+ ExtendedIterator<Triple> it = g.find(Node.ANY,
+ node("brokenPredicate"), Node.ANY);
+ txnRollback(g);
+ it.removeNext();
+ txnBegin(g);
+ assertFalse(g.find(Node.ANY, Node.ANY, Node.ANY).hasNext());
+ txnRollback(g);
+ } catch (UnsupportedOperationException e)
+ {
+ // No Iterator.remove
+ }
+ }
+
+ @ContractTest
+ public void testBrokenObject()
+ {
+ Graph g = graphWith(producer.newInstance(), "x brokenObject y");
+
+ try
+ {
+ txnBegin(g);
+ ExtendedIterator<Triple> it = g.find(Node.ANY, Node.ANY, node("y"));
+ txnRollback(g);
+ it.removeNext();
+ txnBegin(g);
+ assertFalse(g.find(Node.ANY, Node.ANY, Node.ANY).hasNext());
+ txnRollback(g);
+
+ } catch (UnsupportedOperationException e)
+ {
+ // No Iterator.remove
+ }
+
+ }
+
+}
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 0ab76a7730..5b4fedb0ba 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
@@ -40,7 +40,7 @@ public class TestDelta extends AbstractTestGraph
}
@Override
- public Graph getGraph()
+ public Graph getNewGraph()
{
Graph gBase = graphWith( "" );
return new Delta( gBase );
diff --git a/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestDifference.java b/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestDifference.java
index 66ed0d31f0..7ad74f74db 100755
--- a/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestDifference.java
+++ b/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestDifference.java
@@ -31,7 +31,7 @@ public class TestDifference extends TestDyadic
{ return new TestSuite( TestDifference.class ); }
@Override
- public Graph getGraph()
+ public Graph getNewGraph()
{
Graph gBase = graphWith( "" ), g1 = graphWith( "" );
return new Difference( gBase, g1 );
diff --git a/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestDisjointUnion.java b/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestDisjointUnion.java
index 04e7a94ca5..89501e4c15 100644
--- a/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestDisjointUnion.java
+++ b/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestDisjointUnion.java
@@ -35,7 +35,7 @@ public class TestDisjointUnion extends TestDyadic
@Override
- public Graph getGraph()
+ public Graph getNewGraph()
{
Graph gBase = graphWith( "" ), g1 = graphWith( "" );
return new DisjointUnion( gBase, g1 );
diff --git a/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestIntersection.java b/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestIntersection.java
index 25ad131e50..9bff6673a7 100755
--- a/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestIntersection.java
+++ b/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestIntersection.java
@@ -31,7 +31,7 @@ public class TestIntersection extends TestDyadic
{ return new TestSuite( TestIntersection.class ); }
@Override
- public Graph getGraph()
+ public Graph getNewGraph()
{
Graph gBase = graphWith( "" ), g1 = graphWith( "" );
return new Intersection( gBase, g1 );
diff --git a/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestMultiUnion.java b/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestMultiUnion.java
index 9ed93acf1f..ef8b3669a1 100755
--- a/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestMultiUnion.java
+++ b/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestMultiUnion.java
@@ -55,7 +55,7 @@ public class TestMultiUnion extends AbstractTestGraph
{ return new TestSuite( TestMultiUnion.class ); }
@Override
- public Graph getGraph()
+ public Graph getNewGraph()
{
Graph gBase = graphWith( "" ), g1 = graphWith( "" );
return new MultiUnion( new Graph[] {gBase, g1} );
diff --git a/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestUnion.java b/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestUnion.java
index 886e3a9065..dfec39f166 100755
--- a/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestUnion.java
+++ b/jena-core/src/test/java/org/apache/jena/graph/compose/test/TestUnion.java
@@ -31,7 +31,7 @@ public class TestUnion extends TestDyadic
{ return new TestSuite( TestUnion.class ); }
@Override
- public Graph getGraph()
+ public Graph getNewGraph()
{
Graph gBase = graphWith( "" ), g1 = graphWith( "" );
return new Union( gBase, g1 );
diff --git a/jena-core/src/test/java/org/apache/jena/graph/test/AbstractTestGraph.java b/jena-core/src/test/java/org/apache/jena/graph/test/AbstractTestGraph.java
index 69d1170226..7c0e170347 100644
--- a/jena-core/src/test/java/org/apache/jena/graph/test/AbstractTestGraph.java
+++ b/jena-core/src/test/java/org/apache/jena/graph/test/AbstractTestGraph.java
@@ -45,20 +45,18 @@ public abstract class AbstractTestGraph extends GraphTestBase
Returns a Graph to take part in the test. Must be overridden in
a subclass.
*/
- public abstract Graph getGraph();
-
- //public Graph getGraph() { return Factory.createGraphMem(); }
+ public abstract Graph getNewGraph();
public Graph getGraphWith( String facts )
{
- Graph g = getGraph();
+ Graph g = getNewGraph();
graphAdd( g, facts );
return g;
}
public void testCloseSetsIsClosed()
{
- Graph g = getGraph();
+ Graph g = getNewGraph();
assertFalse( "unclosed Graph shouild not be isClosed()", g.isClosed() );
g.close();
assertTrue( "closed Graph should be isClosed()", g.isClosed() );
@@ -70,7 +68,7 @@ public abstract class AbstractTestGraph extends GraphTestBase
*/
public void testFindAndContains()
{
- Graph g = getGraph();
+ Graph g = getNewGraph();
Node r = NodeCreateUtils.create( "r" ), s = NodeCreateUtils.create( "s" ), p = NodeCreateUtils.create( "P" );
g.add( Triple.create( r, p, s ) );
assertTrue( g.contains( r, p, Node.ANY ) );
@@ -130,79 +128,35 @@ public abstract class AbstractTestGraph extends GraphTestBase
assertFalse( g.contains( triple( "a S ??" ) ) );
}
- /**
- Check that contains respects by-value semantics.
- */
- public void testContainsByValue()
- {
- if (getGraph().getCapabilities().handlesLiteralTyping())
- {
- Graph g1 = getGraphWith( "x P '1'xsd:integer" );
-
- boolean b = g1.contains( triple( "x P '01'xsd:int" ) );
- if ( !b )
- System.err.println("No value match: "+g1.getClass().getSimpleName());
-
- assertTrue( g1.contains( triple( "x P '01'xsd:int" ) ) );
- //
- Graph g2 = getGraphWith( "x P '1'xsd:int" );
- assertTrue( g2.contains( triple( "x P '1'xsd:integer" ) ) );
- //
- Graph g3 = getGraphWith( "x P '123'xsd:string" );
- assertTrue( g3.contains( triple( "x P '123'" ) ) );
- }
- }
-
public void testMatchLanguagedLiteralCaseInsensitive()
{
Graph m = graphWith( "a p 'chat'en" );
- if (m.getCapabilities().handlesLiteralTyping())
- {
- Node chaten = node( "'chat'en" ), chatEN = node( "'chat'EN" );
- //assertDiffer( chaten, chatEN ); // Up to Jena4.
- assertEquals( chaten, chatEN ); // Jena5 -- the nodes are now the same due to normalized langtags
- assertTrue( chaten.sameValueAs( chatEN ) );
- assertEquals( chaten.getIndexingValue(), chatEN.getIndexingValue() );
- assertEquals( 1, m.find( Node.ANY, Node.ANY, chaten ).toList().size() );
- assertEquals( 1, m.find( Node.ANY, Node.ANY, chatEN ).toList().size() );
- }
+ Node chaten = node( "'chat'en" ), chatEN = node( "'chat'EN" );
+ //assertDiffer( chaten, chatEN ); // Up to Jena4.
+ assertEquals( chaten, chatEN ); // Jena5 -- the nodes are now the same due to normalized langtags
+ assertTrue( chaten.sameValueAs( chatEN ) );
+ assertEquals( chaten.getIndexingValue(), chatEN.getIndexingValue() );
+ assertEquals( 1, m.find( Node.ANY, Node.ANY, chaten ).toList().size() );
+ assertEquals( 1, m.find( Node.ANY, Node.ANY, chatEN ).toList().size() );
}
public void testMatchBothLanguagedLiteralsCaseInsensitive()
{
Graph m = graphWith( "a p 'chat'en; a p 'chat'EN" );
- if (m.getCapabilities().handlesLiteralTyping())
- {
- Node chaten = node( "'chat'en" ), chatEN = node( "'chat'EN" );
- // Jena4.
-// assertDiffer( chaten, chatEN ); // Up to Jena4.
-// assertTrue( chaten.sameValueAs( chatEN ) );
-// assertEquals( chaten.getIndexingValue(), chatEN.getIndexingValue() );
-// assertEquals( 2, m.find( Node.ANY, Node.ANY, chaten ).toList().size() );
-// assertEquals( 2, m.find( Node.ANY, Node.ANY, chatEN ).toList().size() );
-
- // Jena5 -- the nodes are now the same due to normalized langtags
- assertEquals( chaten, chatEN ); // Jena5 -- the nodes are now the same due to normalized langtags
- assertTrue( chaten.sameValueAs( chatEN ) );
- assertEquals( chaten.getIndexingValue(), chatEN.getIndexingValue() );
- assertEquals( 1, m.find( Node.ANY, Node.ANY, chaten ).toList().size() );
- assertEquals( 1, m.find( Node.ANY, Node.ANY, chatEN ).toList().size() );
- }
- }
-
- public void testNoMatchAgainstUnlanguagesLiteral()
- {
- Graph m = graphWith( "a p 'chat'en; a p 'chat'" );
- if (m.getCapabilities().handlesLiteralTyping())
- {
- Node chaten = node( "'chat'en" ), chatEN = node( "'chat'EN" );
- //assertDiffer( chaten, chatEN ); // Up to Jena4.
- assertEquals( chaten, chatEN ); // Jena5 -- the nodes are now the same due to normalized langtags
- assertTrue( chaten.sameValueAs( chatEN ) );
- assertEquals( chaten.getIndexingValue(), chatEN.getIndexingValue() );
- assertEquals( 1, m.find( Node.ANY, Node.ANY, chaten ).toList().size() );
- assertEquals( 1, m.find( Node.ANY, Node.ANY, chatEN ).toList().size() );
- }
+ Node chaten = node( "'chat'en" ), chatEN = node( "'chat'EN" );
+ // Jena4.
+// assertDiffer( chaten, chatEN ); // Up to Jena4.
+// assertTrue( chaten.sameValueAs( chatEN ) );
+// assertEquals( chaten.getIndexingValue(), chatEN.getIndexingValue() );
+// assertEquals( 2, m.find( Node.ANY, Node.ANY, chaten ).toList().size() );
+// assertEquals( 2, m.find( Node.ANY, Node.ANY, chatEN ).toList().size() );
+
+ // Jena5 -- the nodes are now the same due to normalized langtags
+ assertEquals( chaten, chatEN ); // Jena5 -- the nodes are now the same due to normalized langtags
+ assertTrue( chaten.sameValueAs( chatEN ) );
+ assertEquals( chaten.getIndexingValue(), chatEN.getIndexingValue() );
+ assertEquals( 1, m.find( Node.ANY, Node.ANY, chaten ).toList().size() );
+ assertEquals( 1, m.find( Node.ANY, Node.ANY, chatEN ).toList().size() );
}
/**
@@ -210,7 +164,7 @@ public abstract class AbstractTestGraph extends GraphTestBase
*/
public void testIsEmpty()
{
- Graph g = getGraph();
+ Graph g = getNewGraph();
if (canBeEmpty( g ))
{
assertTrue( g.isEmpty() );
@@ -231,7 +185,7 @@ public abstract class AbstractTestGraph extends GraphTestBase
public void testAGraph()
{
String title = this.getClass().getName();
- Graph g = getGraph();
+ Graph g = getNewGraph();
int baseSize = g.size();
graphAdd( g, "x R y; p S q; a T b" );
/* */
@@ -252,28 +206,13 @@ public abstract class AbstractTestGraph extends GraphTestBase
it.close();
}
- // public void testStuff()
- // {
- //// testAGraph( "StoreMem", new GraphMem() );
- //// testAGraph( "StoreMemBySubject", new GraphMem() );
- //// String [] empty = new String [] {};
- //// Graph g = graphWith( "x R y; p S q; a T b" );
- //// /* */
- //// assertContainsAll( "simple graph", g, "x R y; p S q; a T b" );
- //// graphAdd( g, "spindizzies lift cities; Diracs communicate instantaneously" );
- //// g.delete( triple( "x R y" ) );
- //// g.delete( triple( "a T b" ) );
- //// assertContainsAll( "modified simple graph", g, "p S q; spindizzies lift cities; Diracs communicate instantaneously" );
- //// assertOmitsAll( "modified simple graph", g, "x R y; a T b" );
- // }
-
/**
Test that Graphs have transaction support methods, and that if they fail
on some g they fail because they do not support the operation.
*/
public void testHasTransactions()
{
- Graph g = getGraph();
+ Graph g = getNewGraph();
TransactionHandler th = g.getTransactionHandler();
th.transactionsSupported();
try { th.begin(); } catch (UnsupportedOperationException x) {}
@@ -283,14 +222,14 @@ public abstract class AbstractTestGraph extends GraphTestBase
}
public void testExecuteInTransactionCatchesThrowable() {
- Graph g = getGraph();
+ Graph g = getNewGraph();
TransactionHandler th = g.getTransactionHandler();
try { th.executeAlways( ()-> { throw new Error() ; } ); }
catch (JenaException x) {}
}
public void testCalculateInTransactionCatchesThrowable() {
- Graph g = getGraph();
+ Graph g = getNewGraph();
TransactionHandler th = g.getTransactionHandler();
try { th.calculateAlways( ()-> { throw new Error() ; } ); }
catch (JenaException x) {}
@@ -307,7 +246,7 @@ public abstract class AbstractTestGraph extends GraphTestBase
public void testBulkUpdate()
{
- Graph g = getGraph();
+ Graph g = getNewGraph();
Graph items = graphWith( "pigs might fly; dead can dance" );
int initialSize = g.size();
/* */
@@ -354,7 +293,7 @@ public abstract class AbstractTestGraph extends GraphTestBase
public void testAddWithReificationPreamble()
{
- Graph g = getGraph();
+ Graph g = getNewGraph();
xSPO( g );
assertFalse( g.isEmpty() );
}
@@ -403,7 +342,8 @@ public abstract class AbstractTestGraph extends GraphTestBase
public void testHasCapabilities()
{
- Graph g = getGraph();
+ Graph g = getNewGraph();
+ @SuppressWarnings("removal")
Capabilities c = g.getCapabilities();
boolean sa = c.sizeAccurate();
boolean aaSome = c.addAllowed();
@@ -412,7 +352,7 @@ public abstract class AbstractTestGraph extends GraphTestBase
public void testFind()
{
- Graph g = getGraph();
+ Graph g = getNewGraph();
graphAdd( g, "S P O" );
assertDiffer( Set.of(), g.find( Node.ANY, Node.ANY, Node.ANY ).toSet() );
assertDiffer( Set.of(), g.find( Triple.ANY ).toSet() );
@@ -423,7 +363,7 @@ public abstract class AbstractTestGraph extends GraphTestBase
public void testEventRegister()
{
- Graph g = getGraph();
+ Graph g = getNewGraph();
GraphEventManager gem = g.getEventManager();
assertSame( gem, gem.register( new RecordingListener() ) );
}
@@ -433,7 +373,7 @@ public abstract class AbstractTestGraph extends GraphTestBase
*/
public void testEventUnregister()
{
- getGraph().getEventManager().unregister( L );
+ getNewGraph().getEventManager().unregister( L );
}
/**
@@ -447,7 +387,7 @@ public abstract class AbstractTestGraph extends GraphTestBase
*/
protected Graph getAndRegister( GraphListener gl )
{
- Graph g = getGraph();
+ Graph g = getNewGraph();
g.getEventManager().register( gl );
return g;
}
@@ -543,7 +483,7 @@ public abstract class AbstractTestGraph extends GraphTestBase
{
RecordingListener L1 = new RecordingListener();
RecordingListener L2 = new RecordingListener();
- Graph g = getGraph();
+ Graph g = getNewGraph();
GraphEventManager gem = g.getEventManager();
gem.register( L1 ).register( L2 );
g.add( SPO );
@@ -553,7 +493,7 @@ public abstract class AbstractTestGraph extends GraphTestBase
public void testUnregisterWorks()
{
- Graph g = getGraph();
+ Graph g = getNewGraph();
GraphEventManager gem = g.getEventManager();
gem.register( L ).unregister( L );
g.add( SPO );
@@ -705,7 +645,7 @@ public abstract class AbstractTestGraph extends GraphTestBase
*/
public void testContainsNode()
{
- Graph g = getGraph();
+ Graph g = getNewGraph();
graphAdd( g, "a P b; _c _Q _d; a 11 12" );
assertTrue( containsNode( g, node( "a" ) ) );
assertTrue( containsNode( g, node( "P" ) ) );
@@ -849,14 +789,14 @@ public abstract class AbstractTestGraph extends GraphTestBase
public void testRemoveAll( String triples )
{
- Graph g = getGraph();
+ Graph g = getNewGraph();
graphAdd( g, triples );
g.clear();
assertTrue( g.isEmpty() );
}
public void failingTestDoubleRemoveAll() {
- final Graph g = getGraph();
+ final Graph g = getNewGraph();
graphAdd(g,"c S d; e:ff GGG hhhh; _i J 27; Ell Em 'en'" );
try {
Iterator<Triple> it = new TrackingTripleIterator(g.find(Triple.ANY)){
@@ -907,7 +847,7 @@ public abstract class AbstractTestGraph extends GraphTestBase
{
for ( int j = 0; j < 3; j += 1 )
{
- Graph content = getGraph();
+ Graph content = getNewGraph();
Graph baseContent = copy( content );
graphAdd( content, aCase[0] );
Triple remove = triple( aCase[1] );
@@ -947,8 +887,8 @@ public abstract class AbstractTestGraph extends GraphTestBase
private void testIsomorphismFile(int n, String lang, String suffix, boolean result) {
- Graph g1 = getGraph();
- Graph g2 = getGraph();
+ Graph g1 = getNewGraph();
+ Graph g2 = getNewGraph();
Model m1 = ModelFactory.createModelForGraph(g1);
Model m2 = ModelFactory.createModelForGraph(g2);
@@ -992,53 +932,8 @@ public abstract class AbstractTestGraph extends GraphTestBase
protected Graph getClosed()
{
- Graph result = getGraph();
+ Graph result = getNewGraph();
result.close();
return result;
}
-
- // public void testClosedDelete()
- // {
- // try { getClosed().delete( triple( "x R y" ) ); fail( "delete when closed" ); }
- // catch (ClosedException c) { /* as required */ }
- // }
- //
- // public void testClosedAdd()
- // {
- // try { getClosed().add( triple( "x R y" ) ); fail( "add when closed" ); }
- // catch (ClosedException c) { /* as required */ }
- // }
- //
- // public void testClosedContainsTriple()
- // {
- // try { getClosed().contains( triple( "x R y" ) ); fail( "contains[triple] when closed" ); }
- // catch (ClosedException c) { /* as required */ }
- // }
- //
- // public void testClosedContainsSPO()
- // {
- // Node a = Node.ANY;
- // try { getClosed().contains( a, a, a ); fail( "contains[SPO] when closed" ); }
- // catch (ClosedException c) { /* as required */ }
- // }
- //
- // public void testClosedFindTriple()
- // {
- // try { getClosed().find( triple( "x R y" ) ); fail( "find [triple] when closed" ); }
- // catch (ClosedException c) { /* as required */ }
- // }
- //
- // public void testClosedFindSPO()
- // {
- // Node a = Node.ANY;
- // try { getClosed().find( a, a, a ); fail( "find[SPO] when closed" ); }
- // catch (ClosedException c) { /* as required */ }
- // }
- //
- // public void testClosedSize()
- // {
- // try { getClosed().size(); fail( "size when closed (" + this.getClass() + ")" ); }
- // catch (ClosedException c) { /* as required */ }
- // }
-
}
diff --git a/jena-core/src/test/java/org/apache/jena/graph/test/MetaTestGraph.java b/jena-core/src/test/java/org/apache/jena/graph/test/MetaTestGraph.java
index 2471829d50..bfb731eacf 100644
--- a/jena-core/src/test/java/org/apache/jena/graph/test/MetaTestGraph.java
+++ b/jena-core/src/test/java/org/apache/jena/graph/test/MetaTestGraph.java
@@ -85,7 +85,7 @@ public class MetaTestGraph extends AbstractTestGraph
catch (Exception e) { throw new JenaException( e ); }
}
- @Override public Graph getGraph()
+ @Override public Graph getNewGraph()
{ return getGraph( this, graphClass); }
}
diff --git a/jena-core/src/test/java/org/apache/jena/graph/test/TestGraphListener.java b/jena-core/src/test/java/org/apache/jena/graph/test/TestGraphListener.java
index 48dfcf8feb..7f2d13fe99 100644
--- a/jena-core/src/test/java/org/apache/jena/graph/test/TestGraphListener.java
+++ b/jena-core/src/test/java/org/apache/jena/graph/test/TestGraphListener.java
@@ -52,7 +52,7 @@ public class TestGraphListener extends MetaTestGraph {
public CheckChanges(String description, Graph g) {
original = g;
desc = description;
- copy = TestGraphListener.super.getGraph();
+ copy = TestGraphListener.super.getNewGraph();
}
@@ -143,7 +143,7 @@ public class TestGraphListener extends MetaTestGraph {
}
@Override
- public Graph getGraph() {
+ public Graph getNewGraph() {
Graph g = GraphMemFactory.createGraphMem();
g.getEventManager().register(new CheckChanges("simple tracking",g));
diff --git a/jena-core/src/test/java/org/apache/jena/mem/test/TestGraphMem2.java b/jena-core/src/test/java/org/apache/jena/mem/test/TestGraphMem2.java
index 990137e22f..3d943424df 100644
--- a/jena-core/src/test/java/org/apache/jena/mem/test/TestGraphMem2.java
+++ b/jena-core/src/test/java/org/apache/jena/mem/test/TestGraphMem2.java
@@ -34,7 +34,7 @@ public class TestGraphMem2 extends AbstractTestGraph
{ return new TestSuite( TestGraphMem2.class ); }
@Override
- public Graph getGraph() { return GraphMemFactory.createGraphMem(); }
+ public Graph getNewGraph() { return GraphMemFactory.createGraphMem(); }
public void testBrokenIndexes()
{
diff --git a/jena-core/src/test/java/org/apache/jena/mem/test/TestGraphMemValue.java b/jena-core/src/test/java/org/apache/jena/mem/test/TestGraphMemValue.java
index 4920f40e18..1b8f8ebd6d 100644
--- a/jena-core/src/test/java/org/apache/jena/mem/test/TestGraphMemValue.java
+++ b/jena-core/src/test/java/org/apache/jena/mem/test/TestGraphMemValue.java
@@ -18,46 +18,264 @@
package org.apache.jena.mem.test;
-import junit.framework.TestSuite;
-import org.apache.jena.graph.* ;
-import org.apache.jena.graph.test.* ;
+import static org.apache.jena.testing_framework.GraphHelper.txnBegin;
+import static org.apache.jena.testing_framework.GraphHelper.txnCommit;
+import static org.apache.jena.testing_framework.GraphHelper.txnRollback;
+import static org.apache.jena.testing_framework.GraphHelper.txnRun;
+
+import java.util.Set;
+
+import junit.framework.JUnit4TestAdapter;
+import org.apache.jena.atlas.iterator.Iter;
+import org.apache.jena.graph.Graph;
+import org.apache.jena.graph.Node;
+import org.apache.jena.graph.NodeFactory;
+import org.apache.jena.graph.Triple;
+import org.apache.jena.graph.impl.LiteralLabelFactory;
+import org.apache.jena.graph.test.AbstractTestGraph;
import org.apache.jena.mem.GraphMem ;
-import org.apache.jena.shared.* ;
+import org.apache.jena.testing_framework.NodeCreateUtils;
import org.apache.jena.util.iterator.ExtendedIterator ;
+import org.junit.Test;
-@SuppressWarnings("deprecation")
-public class TestGraphMemValue extends AbstractTestGraph
- {
- public TestGraphMemValue( String name )
- { super( name ); }
+/**
+ * Tests of {@link GraphMem} based on (Java object) value handling.
+ * <p>
+ * This is used by the Model API.
+ * <p>
+ * Jena5+ : Only {@link GraphMem} supports this. Other graph are "same term", not "same value"
+ * and language tags are held in canonical form.
+ */
+public class TestGraphMemValue extends AbstractTestGraph {
+ public TestGraphMemValue(String name) {
+ super(name);
+ }
- public static TestSuite suite()
- { return new TestSuite( TestGraphMemValue.class ); }
+ public static junit.framework.Test suite() {
+ return new JUnit4TestAdapter(TestGraphMemValue.class);
+ }
- @Override public Graph getGraph()
- { return new GraphMem(); }
+ @SuppressWarnings("deprecation")
+ @Override
+ public Graph getNewGraph() {
+ return new GraphMem();
+ }
- public void testSizeAfterRemove()
- {
- Graph g = getGraphWith( "x p y" );
- ExtendedIterator<Triple> it = g.find( triple( "x ?? ??" ) );
+ @Test public void testSizeAfterRemove() {
+ Graph g = getGraphWith("x p y");
+ ExtendedIterator<Triple> it = g.find(triple("x ?? ??"));
it.removeNext();
- assertEquals( 0, g.size() );
+ assertEquals(0, g.size());
+ }
+
+ /**
+ * Check that contains respects by-value semantics.
+ */
+ @Test public void testContainsByValue() {
+ Graph g1 = getGraphWith("x P '1'xsd:integer");
+
+ boolean b = g1.contains(triple("x P '01'xsd:int"));
+ if ( !b )
+ System.err.println("No value match: " + g1.getClass().getSimpleName());
+
+ assertTrue(g1.contains(triple("x P '01'xsd:int")));
+ //
+ Graph g2 = getGraphWith("x P '1'xsd:int");
+ assertTrue(g2.contains(triple("x P '1'xsd:integer")));
+ //
+ Graph g3 = getGraphWith("x P '123'xsd:string");
+ assertTrue(g3.contains(triple("x P '123'")));
+ }
+
+ // From the contract tests
+
+ @SuppressWarnings("deprecation")
+ @Test public void test_ProgrammaticValue() {
+ Graph g = getNewGraph();
+ Node ab = NodeFactory.createLiteral(LiteralLabelFactory.createTypedLiteral(Byte.valueOf((byte)42)));
+ Node as = NodeFactory.createLiteral(LiteralLabelFactory.createTypedLiteral(Short.valueOf((short)42)));
+ Node ai = NodeFactory.createLiteral(LiteralLabelFactory.createTypedLiteral(Integer.valueOf(42)));
+ Node al = NodeFactory.createLiteral(LiteralLabelFactory.createTypedLiteral(Long.valueOf(42)));
+
+ Node SB = NodeCreateUtils.create("SB");
+ Node SS = NodeCreateUtils.create("SS");
+ Node SI = NodeCreateUtils.create("SI");
+ Node SL = NodeCreateUtils.create("SL");
+ Node P = NodeCreateUtils.create("P");
+
+ try {
+ g.add(Triple.create(SB, P, ab));
+ g.add(Triple.create(SS, P, as));
+ g.add(Triple.create(SI, P, ai));
+ g.add(Triple.create(SL, P, al));
+ } catch (Exception e) {
+ fail(e.getMessage());
}
+ assertEquals(String.format("Should have found 4 elements, does %s really implement literal typing", g.getClass()), 4,
+ Iter.toSet(g.find(Node.ANY, P, NodeCreateUtils.create("42"))).size());
+ }
- public void testContainsConcreteDoesntUseFind()
- {
- Graph g = new GraphMemWithoutFind();
- graphAdd( g, "x P y; a Q b" );
- assertTrue( g.contains( triple( "x P y" ) ) );
- assertTrue( g.contains( triple( "a Q b" ) ) );
- assertFalse( g.contains( triple( "a P y" ) ) );
- assertFalse( g.contains( triple( "y R b" ) ) );
+ @Test
+ public void test_Contains_Node_Node_Node_ByValue()
+ {
+ Node x = node("x");
+ Node P = node("P");
+ Graph g1 = graphWith("x P '1'xsd:integer");
+ txnRun(g1,
+ () -> assertTrue(
+ String.format(
+ "literal type equality failed, does %s really implement literal typing",
+ g1.getClass()),
+ g1.contains(x, P, node("'01'xsd:int"))));
+ //
+ Graph g2 = graphWith("x P '1'xsd:int");
+ txnRun(g2, () -> {
+ assertTrue("Literal equality with '1'xsd:integer failed",
+ g2.contains(x, P, node("'1'xsd:integer")));
+ });
+ //
+ Graph g3 = graphWith("x P '123'xsd:string");
+ txnRun(g3, () -> {
+ assertTrue("Literal equality with '123' failed",
+ g3.contains(x, P, node("'123'")));
+ });
}
- protected final class GraphMemWithoutFind extends GraphMem
+
+ @Test
+ public void test_Contains_Triple_ByValue()
+ {
+ Graph g1 = graphWith("x P '1'xsd:integer");
+ txnRun(g1, () -> {
+ assertTrue(
+ String.format(
+ "did not find x P '01'xsd:int, does %s really implement literal typing",
+ g1.getClass()),
+ g1.contains(triple("x P '01'xsd:int")));
+ });
+ //
+ Graph g2 = graphWith("x P '1'xsd:int");
+ txnRun(g2, () -> {
+ assertTrue("did not find x P '1'xsd:integer",
+ g2.contains(triple("x P '1'xsd:integer")));
+ });
+ //
+ Graph g3 = graphWith("x P '123'xsd:string");
+ txnRun(g3, () -> assertTrue("did not find x P '123'xsd:string",
+ g3.contains(triple("x P '123'"))));
+ }
+
+ @Test
+ public void test_Find_Triple_ProgrammaticValues()
+ {
+ Graph g = getNewGraph();
+ @SuppressWarnings("deprecation")
+ Node ab = NodeFactory.createLiteral(LiteralLabelFactory
+ .createTypedLiteral(Byte.valueOf((byte) 42)));
+ @SuppressWarnings("deprecation")
+ Node as = NodeFactory.createLiteral(LiteralLabelFactory
+ .createTypedLiteral(Short.valueOf((short) 42)));
+ @SuppressWarnings("deprecation")
+ Node ai = NodeFactory.createLiteral(
+ LiteralLabelFactory.createTypedLiteral(Integer.valueOf(42)));
+ @SuppressWarnings("deprecation")
+ Node al = NodeFactory.createLiteral(
+ LiteralLabelFactory.createTypedLiteral(Long.valueOf(42)));
+
+ Node SB = NodeCreateUtils.create("SB");
+ Node SS = NodeCreateUtils.create("SS");
+ Node SI = NodeCreateUtils.create("SI");
+ Node SL = NodeCreateUtils.create("SL");
+ Node P = NodeCreateUtils.create("P");
+
+ txnBegin(g);
+ try
+ {
+ g.add(Triple.create(SB, P, ab));
+ g.add(Triple.create(SS, P, as));
+ g.add(Triple.create(SI, P, ai));
+ g.add(Triple.create(SL, P, al));
+ } catch (Exception e)
+ {
+ txnRollback(g);
+ fail(e.getMessage());
+ }
+ txnCommit(g);
+ txnBegin(g);
+ assertEquals(
+ String.format(
+ "Should have found 4 elements, does %s really implement literal typing",
+ g.getClass()),
+ 4, Iter.toSet(g.find(Triple.create(Node.ANY, P,
+ NodeCreateUtils.create("42")))).size());
+ txnRollback(g);
+ }
+
+ @Test
+ public void test_Find_Triple_MatchLanguagedLiteralCaseInsensitive()
+ {
+ Graph g = graphWith("a p 'chat'en");
+ Node chaten = node("'chat'en"), chatEN = node("'chat'EN");
+ assertEquals(chaten, chatEN);
+ assertTrue(chaten.sameValueAs(chatEN));
+ assertEquals(chaten.getIndexingValue(), chatEN.getIndexingValue());
+ txnBegin(g);
+ assertEquals(1, g.find(Triple.create(Node.ANY, Node.ANY, chaten))
+ .toList().size());
+ assertEquals(1, g.find(Triple.create(Node.ANY, Node.ANY, chatEN))
+ .toList().size());
+ txnRollback(g);
+ }
+
+ private void literalTypingBasedFindTest(final String data, final int size,
+ final String search, final String results, boolean reqLitType) {
+ if (!reqLitType)
{
- @Override public ExtendedIterator<Triple> graphBaseFind( Triple t )
- { throw new JenaException( "find is Not Allowed" ); }
+ Graph g = graphWith(data);
+
+ Node literal = NodeCreateUtils.create(search);
+ //
+ txnBegin(g);
+ assertEquals("graph has wrong size", size, g.size());
+ Set<Node> got = g.find(Node.ANY, Node.ANY, literal).mapWith(t->t.getObject()).toSet();
+ assertEquals(nodeSet(results), got);
+ txnRollback(g);
}
}
+
+ @Test
+ public void testLiteralTypingBasedFind() {
+ literalTypingBasedFindTest("a P 'simple'", 1, "'simple'", "'simple'", false);
+ literalTypingBasedFindTest("a P 'simple'xsd:string", 1, "'simple'", "'simple'xsd:string", true);
+ literalTypingBasedFindTest("a P 'simple'", 1, "'simple'xsd:string", "'simple'", true);
+ // ensure that adding identical strings one with type yields single result
+ // and that querying with or without type works
+ literalTypingBasedFindTest("a P 'simple'xsd:string", 1, "'simple'xsd:string", "'simple'xsd:string",
+ false);
+ literalTypingBasedFindTest("a P 'simple'; a P 'simple'xsd:string", 1, "'simple'",
+ "'simple'xsd:string", true);
+ literalTypingBasedFindTest("a P 'simple'; a P 'simple'xsd:string", 1, "'simple'xsd:string",
+ "'simple'", true);
+ literalTypingBasedFindTest("a P 'simple'; a P 'simple'xsd:string", 1, "'simple'", "'simple'", true);
+ literalTypingBasedFindTest("a P 'simple'; a P 'simple'xsd:string", 1, "'simple'xsd:string",
+ "'simple'xsd:string", true);
+ literalTypingBasedFindTest("a P 1", 1, "1", "1", false);
+ literalTypingBasedFindTest("a P '1'xsd:float", 1, "'1'xsd:float", "'1'xsd:float", false);
+ literalTypingBasedFindTest("a P '1'xsd:double", 1, "'1'xsd:double", "'1'xsd:double", false);
+ literalTypingBasedFindTest("a P '1'xsd:float", 1, "'1'xsd:float", "'1'xsd:float", false);
+ literalTypingBasedFindTest("a P '1.1'xsd:float", 1, "'1'xsd:float", "", false);
+ literalTypingBasedFindTest("a P '1'xsd:double", 1, "'1'xsd:int", "", false);
+ literalTypingBasedFindTest("a P 'abc'rdf:XMLLiteral", 1, "'abc'", "", false);
+ literalTypingBasedFindTest("a P 'abc'", 1, "'abc'rdf:XMLLiteral", "", false);
+ //
+ // floats & doubles are not compatible
+ //
+ literalTypingBasedFindTest("a P '1'xsd:float", 1, "'1'xsd:double", "", false);
+ literalTypingBasedFindTest("a P '1'xsd:double", 1, "'1'xsd:float", "", false);
+ literalTypingBasedFindTest("a P 1", 1, "'1'", "", false);
+ literalTypingBasedFindTest("a P 1", 1, "'1'xsd:integer", "'1'xsd:integer", false);
+ literalTypingBasedFindTest("a P 1", 1, "'1'", "", false);
+ literalTypingBasedFindTest("a P '1'xsd:short", 1, "'1'xsd:integer", "'1'xsd:short", true);
+ literalTypingBasedFindTest("a P '1'xsd:int", 1, "'1'xsd:integer", "'1'xsd:int", true);
+ }
+}
diff --git a/jena-core/src/test/java/org/apache/jena/ontology/impl/TestOntGraph.java b/jena-core/src/test/java/org/apache/jena/ontology/impl/TestOntGraph.java
index 30b8ab4982..a96af17dd8 100644
--- a/jena-core/src/test/java/org/apache/jena/ontology/impl/TestOntGraph.java
+++ b/jena-core/src/test/java/org/apache/jena/ontology/impl/TestOntGraph.java
@@ -37,6 +37,6 @@ public class TestOntGraph extends AbstractTestGraph
{ return new TestSuite( TestOntGraph.class ); }
@Override
- public Graph getGraph()
+ public Graph getNewGraph()
{ return ModelFactory.createOntologyModel().getGraph(); }
}
diff --git a/jena-core/src/test/java/org/apache/jena/reasoner/rulesys/test/FRuleEngineIFactoryTest.java b/jena-core/src/test/java/org/apache/jena/reasoner/rulesys/test/FRuleEngineIFactoryTest.java
index 13704e8487..29630f82ea 100644
--- a/jena-core/src/test/java/org/apache/jena/reasoner/rulesys/test/FRuleEngineIFactoryTest.java
+++ b/jena-core/src/test/java/org/apache/jena/reasoner/rulesys/test/FRuleEngineIFactoryTest.java
@@ -133,9 +133,6 @@ public class FRuleEngineIFactoryTest extends TestCase {
@Override
public TransactionHandler getTransactionHandler() { return null; }
- @Override
- public Capabilities getCapabilities() { return null; }
-
@Override
public GraphEventManager getEventManager() { return null; }
diff --git a/jena-core/src/test/java/org/apache/jena/reasoner/test/TestInfGraph.java b/jena-core/src/test/java/org/apache/jena/reasoner/test/TestInfGraph.java
index 76413319ec..dfa7c061e3 100644
--- a/jena-core/src/test/java/org/apache/jena/reasoner/test/TestInfGraph.java
+++ b/jena-core/src/test/java/org/apache/jena/reasoner/test/TestInfGraph.java
@@ -44,7 +44,7 @@ public class TestInfGraph extends AbstractTestGraph
}
@Override
- public Graph getGraph()
+ public Graph getNewGraph()
{ return getInfGraph(); }
public void testInfGraph()
diff --git a/jena-permissions/src/test/java/org/apache/jena/permissions/contract/graph/SecuredGraphContractTests.java b/jena-permissions/src/test/java/org/apache/jena/permissions/contract/graph/SecuredGraphContractTests.java
index f73da1ba55..84aabe373d 100644
--- a/jena-permissions/src/test/java/org/apache/jena/permissions/contract/graph/SecuredGraphContractTests.java
+++ b/jena-permissions/src/test/java/org/apache/jena/permissions/contract/graph/SecuredGraphContractTests.java
@@ -38,7 +38,7 @@ public class SecuredGraphContractTests extends MetaTestGraph {
}
@Override
- public Graph getGraph() {
+ public Graph getNewGraph() {
return org.apache.jena.permissions.Factory.getInstance(eval, getName(), GraphMemFactory.createDefaultGraph());
}
diff --git a/jena-permissions/src/test/java/org/apache/jena/permissions/contract/graph/SecuredGraphListenerTest.java b/jena-permissions/src/test/java/org/apache/jena/permissions/contract/graph/SecuredGraphListenerTest.java
index bb5806cc99..3b05877d22 100644
--- a/jena-permissions/src/test/java/org/apache/jena/permissions/contract/graph/SecuredGraphListenerTest.java
+++ b/jena-permissions/src/test/java/org/apache/jena/permissions/contract/graph/SecuredGraphListenerTest.java
@@ -37,7 +37,7 @@ public class SecuredGraphListenerTest extends TestGraphListener {
}
@Override
- public Graph getGraph() {
+ public Graph getNewGraph() {
final Graph graph = org.apache.jena.permissions.Factory.getInstance(eval, getName(),
GraphMemFactory.createDefaultGraph());
graph.getEventManager().register(new CheckChanges("simple tracking", graph));
diff --git a/jena-permissions/src/test/java/org/apache/jena/permissions/contract/graph/SecuredTDBGraphContractTests.java b/jena-permissions/src/test/java/org/apache/jena/permissions/contract/graph/SecuredTDBGraphContractTests.java
index f7f971cd99..56bf0b3f9d 100644
--- a/jena-permissions/src/test/java/org/apache/jena/permissions/contract/graph/SecuredTDBGraphContractTests.java
+++ b/jena-permissions/src/test/java/org/apache/jena/permissions/contract/graph/SecuredTDBGraphContractTests.java
@@ -38,7 +38,7 @@ public class SecuredTDBGraphContractTests extends MetaTestGraph {
}
@Override
- public Graph getGraph() {
+ public Graph getNewGraph() {
return org.apache.jena.permissions.Factory.getInstance(eval, getName(),
TDB1Factory.createDatasetGraph().getDefaultGraph());
}