You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jena.apache.org by cl...@apache.org on 2013/10/09 19:16:18 UTC
svn commit: r1530718 [6/10] - in /jena/Experimental/new-test: ./
src/test/java/com/hp/hpl/jena/graph/
src/test/java/com/hp/hpl/jena/graph/compose/
src/test/java/com/hp/hpl/jena/graph/impl/
src/test/java/com/hp/hpl/jena/mem/ src/test/java/com/hp/hpl/jen...
Copied: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ModelConContractTests.java (from r1525417, jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AbstractModelConContractTests.java)
URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ModelConContractTests.java?p2=jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ModelConContractTests.java&p1=jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AbstractModelConContractTests.java&r1=1525417&r2=1530718&rev=1530718&view=diff
==============================================================================
--- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/AbstractModelConContractTests.java (original)
+++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/rdf/model/ModelConContractTests.java Wed Oct 9 17:16:15 2013
@@ -22,15 +22,15 @@ import static com.hp.hpl.jena.testing_fr
import static org.junit.Assert.*;
import java.util.Arrays;
import java.util.Calendar;
-import java.util.HashSet;
import java.util.List;
-import java.util.Set;
-
+import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import org.xenei.junit.contract.Contract;
+
import com.hp.hpl.jena.datatypes.BaseDatatype;
import com.hp.hpl.jena.datatypes.RDFDatatype;
import com.hp.hpl.jena.datatypes.xsd.XSDDatatype;
@@ -39,7 +39,7 @@ import com.hp.hpl.jena.graph.Node;
import com.hp.hpl.jena.graph.NodeFactory;
import com.hp.hpl.jena.graph.impl.AdhocDatatype;
import com.hp.hpl.jena.rdf.model.impl.StmtIteratorImpl;
-import com.hp.hpl.jena.testing_framework.AbstractModelProducerUser;
+import org.xenei.junit.contract.IProducer;
import com.hp.hpl.jena.testing_framework.ModelHelper;
import com.hp.hpl.jena.testing_framework.NodeCreateUtils;
import com.hp.hpl.jena.vocabulary.RDF;
@@ -51,27 +51,44 @@ import com.hp.hpl.jena.vocabulary.RDF;
* independent or not.
*
*/
-public abstract class AbstractModelConContractTests extends
- AbstractModelProducerUser {
+@Contract(ModelCon.class)
+public abstract class ModelConContractTests {
+
+ private ModelCon modelCon;
private Model model;
private RecordingModelListener SL;
- private static Logger log = LoggerFactory
- .getLogger(AbstractModelConContractTests.class);
+ @Contract.Inject( "org.xenei.junit.contract.IProducer<%s>" )
+ abstract public IProducer<ModelCon> getProducer();
+
+ private static Logger LOG = LoggerFactory
+ .getLogger(ModelConContractTests.class);
@Before
- public final void setupAbstractModelConTest() {
- model = getModelProducer().newModel();
+ public final void beforeModelConContractTest() {
+ modelCon = getProducer().newInstance();
+ if (modelCon instanceof Model) {
+ model = (Model) modelCon;
+ } else {
+ // hould be empty so this won't matter.
+ model = modelCon.remove(null, null, null);
+ }
SL = new RecordingModelListener();
}
+ @After
+ public final void aftereModelConContractTest() {
+ getProducer().cleanUp();
+ }
+
@Test
public void testAdd_Resource_Property_RDFNode() {
Statement s = statement("S P O");
model.register(SL);
txnBegin(model);
assertTrue("add( S, P, O ) must return model for cascading",
- model == model.add(resource("S"), property("P"), rdfNode("O")));
+ modelCon == modelCon.add(resource("S"), property("P"),
+ rdfNode("O")));
txnCommit(model);
SL.assertHas(new Object[] { "add", s });
assertTrue("Statement not found in model", model.contains(s));
@@ -84,7 +101,7 @@ public abstract class AbstractModelConCo
model.register(SL);
txnBegin(model);
assertTrue("add( S, P, O ) must return model for cascading",
- model == model.add(resource("S"), property("P"), "foo"));
+ modelCon == modelCon.add(resource("S"), property("P"), "foo"));
txnCommit(model);
SL.assertHas(new Object[] { "add", s });
assertTrue("Statement not found in model", model.contains(s));
@@ -102,18 +119,18 @@ public abstract class AbstractModelConCo
model.register(SL);
txnBegin(model);
assertTrue("add( S, P, O ) must return model for cascading",
- model == model.add(S, P, "foo", true));
+ modelCon == modelCon.add(S, P, "foo", true));
txnCommit(model);
// this doesn't work because of BaseDatatype equality strangeness.
- //SL.assertHas(new Object[] { "add", s });
- SL.assertContains( "add" );
- Statement s2 = (Statement) SL.from( "add" ).next();
- assertEquals( "wrong subject", s.getSubject(), s2.getSubject() );
- assertEquals( "wrong predicate", s.getPredicate(), s2.getPredicate() );
- assertTrue( s2.getObject().isLiteral());
- Literal lit = (Literal) s2.getObject().asLiteral();
- assertEquals( O.getDatatypeURI(), lit.getDatatypeURI() );
- assertEquals( O.getString(), lit.getString());
+ // SL.assertHas(new Object[] { "add", s });
+ SL.assertContains("add");
+ Statement s2 = (Statement) SL.from("add").next();
+ assertEquals("wrong subject", s.getSubject(), s2.getSubject());
+ assertEquals("wrong predicate", s.getPredicate(), s2.getPredicate());
+ assertTrue(s2.getObject().isLiteral());
+ Literal lit = s2.getObject().asLiteral();
+ assertEquals(O.getDatatypeURI(), lit.getDatatypeURI());
+ assertEquals(O.getString(), lit.getString());
assertTrue("Statement not found in model", model.contains(s2));
}
@@ -126,7 +143,7 @@ public abstract class AbstractModelConCo
model.register(SL);
txnBegin(model);
assertTrue("add( S, P, O ) must return model for cascading",
- model == model.add(resource("S"), property("P"), "foo",
+ modelCon == modelCon.add(resource("S"), property("P"), "foo",
XSDDatatype.XSDstring));
txnCommit(model);
SL.assertHas(new Object[] { "add", s });
@@ -143,7 +160,7 @@ public abstract class AbstractModelConCo
model.register(SL);
txnBegin(model);
assertTrue("add( S, P, O ) must return model for cascading",
- model == model.add(S, P, "foo", "fr"));
+ modelCon == modelCon.add(S, P, "foo", "fr"));
txnCommit(model);
SL.assertHas(new Object[] { "add", s });
@@ -151,7 +168,7 @@ public abstract class AbstractModelConCo
Assert.assertTrue(model.contains(s));
Assert.assertFalse(model.contains(S, P, "foo"));
assertTrue("add( S, P, O ) must return model for cascading",
- model == model.add(resource("S"), property("P"), "foo",
+ modelCon == modelCon.add(resource("S"), property("P"), "foo",
XSDDatatype.XSDstring));
// final Resource S =
// model.createResource("http://nowhere.man/subject");
@@ -171,7 +188,7 @@ public abstract class AbstractModelConCo
model.register(SL);
txnBegin(model);
assertTrue("addLiteral( S, P, O ) must return model for cascading",
- model == model.addLiteral(S, P, tvBoolean));
+ modelCon == modelCon.addLiteral(S, P, tvBoolean));
txnCommit(model);
SL.assertHas(new Object[] { "add", s });
assertTrue("Statement not found in model", model.contains(s));
@@ -187,15 +204,15 @@ public abstract class AbstractModelConCo
Statement s = statement(S, P, O);
model.register(SL);
txnBegin(model);
- assertSame("addLiteral() should return the model", model,
- model.addLiteral(S, P, tvChar));
+ assertSame("addLiteral() should return the model", modelCon,
+ modelCon.addLiteral(S, P, tvChar));
txnCommit(model);
SL.assertHas(new Object[] { "add", s });
assertTrue("Statement not found in model", model.contains(s));
Assert.assertTrue(model.contains(s));
Assert.assertFalse(model.contains(S, P, "foo"));
- Assert.assertTrue(model.containsLiteral(S, P, tvChar));
+ Assert.assertTrue(modelCon.containsLiteral(S, P, tvChar));
}
@Test
@@ -206,15 +223,15 @@ public abstract class AbstractModelConCo
Statement s = statement(S, P, O);
model.register(SL);
txnBegin(model);
- assertSame("addLiteral() should return the model", model,
- model.addLiteral(S, P, tvDouble));
+ assertSame("addLiteral() should return the model", modelCon,
+ modelCon.addLiteral(S, P, tvDouble));
txnCommit(model);
SL.assertHas(new Object[] { "add", s });
assertTrue("Statement not found in model", model.contains(s));
Assert.assertTrue(model.contains(s));
Assert.assertFalse(model.contains(S, P, "foo"));
- Assert.assertTrue(model.containsLiteral(S, P, tvDouble));
+ Assert.assertTrue(modelCon.containsLiteral(S, P, tvDouble));
}
@Test
@@ -225,15 +242,15 @@ public abstract class AbstractModelConCo
Statement s = statement(S, P, O);
model.register(SL);
txnBegin(model);
- assertSame("addLiteral() should return the model", model,
- model.addLiteral(S, P, tvFloat));
+ assertSame("addLiteral() should return the model", modelCon,
+ modelCon.addLiteral(S, P, tvFloat));
txnCommit(model);
SL.assertHas(new Object[] { "add", s });
assertTrue("Statement not found in model", model.contains(s));
Assert.assertTrue(model.contains(s));
Assert.assertFalse(model.contains(S, P, "foo"));
- Assert.assertTrue(model.containsLiteral(S, P, tvFloat));
+ Assert.assertTrue(modelCon.containsLiteral(S, P, tvFloat));
}
@Test
@@ -244,15 +261,15 @@ public abstract class AbstractModelConCo
Statement s = statement(S, P, O);
model.register(SL);
txnBegin(model);
- assertSame("addLiteral() should return the model", model,
- model.addLiteral(S, P, tvInt));
+ assertSame("addLiteral() should return the model", modelCon,
+ modelCon.addLiteral(S, P, tvInt));
txnCommit(model);
SL.assertHas(new Object[] { "add", s });
assertTrue("Statement not found in model", model.contains(s));
Assert.assertTrue(model.contains(s));
Assert.assertFalse(model.contains(S, P, "foo"));
- Assert.assertTrue(model.containsLiteral(S, P, tvInt));
+ Assert.assertTrue(modelCon.containsLiteral(S, P, tvInt));
}
@Test
@@ -263,15 +280,15 @@ public abstract class AbstractModelConCo
Statement s = statement(S, P, O);
model.register(SL);
txnBegin(model);
- assertSame("addLiteral() should return the model", model,
- model.addLiteral(S, P, O));
+ assertSame("addLiteral() should return the model", modelCon,
+ modelCon.addLiteral(S, P, O));
txnCommit(model);
SL.assertHas(new Object[] { "add", s });
assertTrue("Statement not found in model", model.contains(s));
Assert.assertTrue(model.contains(s));
Assert.assertFalse(model.contains(S, P, "foo"));
- Assert.assertTrue(model.containsLiteral(S, P, O));
+ Assert.assertTrue(modelCon.containsLiteral(S, P, O));
}
@Test
@@ -282,15 +299,15 @@ public abstract class AbstractModelConCo
Statement s = statement(S, P, O);
model.register(SL);
txnBegin(model);
- assertSame("addLiteral() should return the model", model,
- model.addLiteral(S, P, tvLong));
+ assertSame("addLiteral() should return the model", modelCon,
+ modelCon.addLiteral(S, P, tvLong));
txnCommit(model);
SL.assertHas(new Object[] { "add", s });
assertTrue("Statement not found in model", model.contains(s));
Assert.assertTrue(model.contains(s));
Assert.assertFalse(model.contains(S, P, "foo"));
- Assert.assertTrue(model.containsLiteral(S, P, tvLong));
+ Assert.assertTrue(modelCon.containsLiteral(S, P, tvLong));
}
@Test
@@ -300,7 +317,7 @@ public abstract class AbstractModelConCo
RDFNode O = rdfNode("O");
txnBegin(model);
- model.add(S, P, O);
+ modelCon.add(S, P, O);
txnCommit(model);
assertTrue("missing resource", model.contains(S, P, O));
@@ -322,7 +339,7 @@ public abstract class AbstractModelConCo
RDFNode O = literal("foo", "fr");
txnBegin(model);
- model.add(S, P, O);
+ modelCon.add(S, P, O);
txnCommit(model);
assertTrue("missing resource", model.contains(S, P, "foo", "fr"));
@@ -354,14 +371,15 @@ public abstract class AbstractModelConCo
Property P = property("P");
txnBegin(model);
- model.addLiteral(S, P, true);
+ modelCon.addLiteral(S, P, true);
txnCommit(model);
- assertTrue("missing resource", model.containsLiteral(S, P, true));
- assertTrue("missing resource", model.containsLiteral(S, null, true));
- assertTrue("missing resource", model.containsLiteral(null, P, true));
- assertTrue("missing resource", model.containsLiteral(null, null, true));
- assertFalse("extra resource", model.containsLiteral(S, P, false));
+ assertTrue("missing resource", modelCon.containsLiteral(S, P, true));
+ assertTrue("missing resource", modelCon.containsLiteral(S, null, true));
+ assertTrue("missing resource", modelCon.containsLiteral(null, P, true));
+ assertTrue("missing resource",
+ modelCon.containsLiteral(null, null, true));
+ assertFalse("extra resource", modelCon.containsLiteral(S, P, false));
}
@Test
@@ -370,14 +388,14 @@ public abstract class AbstractModelConCo
Property P = property("P");
char c = 'c';
txnBegin(model);
- model.addLiteral(S, P, c);
+ modelCon.addLiteral(S, P, c);
txnCommit(model);
- assertTrue("missing resource", model.containsLiteral(S, P, c));
- assertTrue("missing resource", model.containsLiteral(S, null, c));
- assertTrue("missing resource", model.containsLiteral(null, P, c));
- assertTrue("missing resource", model.containsLiteral(null, null, c));
- assertFalse("extra resource", model.containsLiteral(S, P, 'b'));
+ assertTrue("missing resource", modelCon.containsLiteral(S, P, c));
+ assertTrue("missing resource", modelCon.containsLiteral(S, null, c));
+ assertTrue("missing resource", modelCon.containsLiteral(null, P, c));
+ assertTrue("missing resource", modelCon.containsLiteral(null, null, c));
+ assertFalse("extra resource", modelCon.containsLiteral(S, P, 'b'));
}
@Test
@@ -387,14 +405,14 @@ public abstract class AbstractModelConCo
double d = 4.5d;
txnBegin(model);
- model.addLiteral(S, P, d);
+ modelCon.addLiteral(S, P, d);
txnCommit(model);
- assertTrue("missing resource", model.containsLiteral(S, P, d));
- assertTrue("missing resource", model.containsLiteral(S, null, d));
- assertTrue("missing resource", model.containsLiteral(null, P, d));
- assertTrue("missing resource", model.containsLiteral(null, null, d));
- assertFalse("extra resource", model.containsLiteral(S, P, 8.5d));
+ assertTrue("missing resource", modelCon.containsLiteral(S, P, d));
+ assertTrue("missing resource", modelCon.containsLiteral(S, null, d));
+ assertTrue("missing resource", modelCon.containsLiteral(null, P, d));
+ assertTrue("missing resource", modelCon.containsLiteral(null, null, d));
+ assertFalse("extra resource", modelCon.containsLiteral(S, P, 8.5d));
}
@Test
@@ -404,14 +422,14 @@ public abstract class AbstractModelConCo
float f = 4.5f;
txnBegin(model);
- model.addLiteral(S, P, f);
+ modelCon.addLiteral(S, P, f);
txnCommit(model);
- assertTrue("missing resource", model.containsLiteral(S, P, f));
- assertTrue("missing resource", model.containsLiteral(S, null, f));
- assertTrue("missing resource", model.containsLiteral(null, P, f));
- assertTrue("missing resource", model.containsLiteral(null, null, f));
- assertFalse("extra resource", model.containsLiteral(S, P, 8.5f));
+ assertTrue("missing resource", modelCon.containsLiteral(S, P, f));
+ assertTrue("missing resource", modelCon.containsLiteral(S, null, f));
+ assertTrue("missing resource", modelCon.containsLiteral(null, P, f));
+ assertTrue("missing resource", modelCon.containsLiteral(null, null, f));
+ assertFalse("extra resource", modelCon.containsLiteral(S, P, 8.5f));
}
@Test
@@ -421,14 +439,14 @@ public abstract class AbstractModelConCo
int i = 5;
txnBegin(model);
- model.addLiteral(S, P, i);
+ modelCon.addLiteral(S, P, i);
txnCommit(model);
- assertTrue("missing resource", model.containsLiteral(S, P, i));
- assertTrue("missing resource", model.containsLiteral(S, null, i));
- assertTrue("missing resource", model.containsLiteral(null, P, i));
- assertTrue("missing resource", model.containsLiteral(null, null, i));
- assertFalse("extra resource", model.containsLiteral(S, P, 10));
+ assertTrue("missing resource", modelCon.containsLiteral(S, P, i));
+ assertTrue("missing resource", modelCon.containsLiteral(S, null, i));
+ assertTrue("missing resource", modelCon.containsLiteral(null, P, i));
+ assertTrue("missing resource", modelCon.containsLiteral(null, null, i));
+ assertFalse("extra resource", modelCon.containsLiteral(S, P, 10));
}
@Test
@@ -438,14 +456,14 @@ public abstract class AbstractModelConCo
long l = 15L;
txnBegin(model);
- model.addLiteral(S, P, l);
+ modelCon.addLiteral(S, P, l);
txnCommit(model);
- assertTrue("missing resource", model.containsLiteral(S, P, l));
- assertTrue("missing resource", model.containsLiteral(S, null, l));
- assertTrue("missing resource", model.containsLiteral(null, P, l));
- assertTrue("missing resource", model.containsLiteral(null, null, l));
- assertFalse("extra resource", model.containsLiteral(S, P, 100L));
+ assertTrue("missing resource", modelCon.containsLiteral(S, P, l));
+ assertTrue("missing resource", modelCon.containsLiteral(S, null, l));
+ assertTrue("missing resource", modelCon.containsLiteral(null, P, l));
+ assertTrue("missing resource", modelCon.containsLiteral(null, null, l));
+ assertFalse("extra resource", modelCon.containsLiteral(S, P, 100L));
}
@Test
@@ -454,15 +472,17 @@ public abstract class AbstractModelConCo
Property P = property("P");
txnBegin(model);
- model.addLiteral(S, P, tvObject);
+ modelCon.addLiteral(S, P, tvObject);
txnCommit(model);
- assertTrue("missing resource", model.containsLiteral(S, P, tvObject));
- assertTrue("missing resource", model.containsLiteral(S, null, tvObject));
- assertTrue("missing resource", model.containsLiteral(null, P, tvObject));
+ assertTrue("missing resource", modelCon.containsLiteral(S, P, tvObject));
assertTrue("missing resource",
- model.containsLiteral(null, null, tvObject));
- assertFalse("extra resource", model.containsLiteral(S, P, tvLitObj));
+ modelCon.containsLiteral(S, null, tvObject));
+ assertTrue("missing resource",
+ modelCon.containsLiteral(null, P, tvObject));
+ assertTrue("missing resource",
+ modelCon.containsLiteral(null, null, tvObject));
+ assertFalse("extra resource", modelCon.containsLiteral(S, P, tvLitObj));
}
/**
@@ -473,7 +493,7 @@ public abstract class AbstractModelConCo
model.register(SL);
txnBegin(model);
- final Alt tvAlt = model.createAlt();
+ final Alt tvAlt = modelCon.createAlt();
txnCommit(model);
List<Statement> stmts = model.listStatements().toList();
@@ -484,7 +504,8 @@ public abstract class AbstractModelConCo
SL.assertHas("add", stmts.get(0));
Assert.assertTrue("Alt should be anonymous", tvAlt.isAnon());
Assert.assertTrue("Alt should be alt", tvAlt.isAlt());
- assertEquals("must be associated with model", model, tvAlt.getModel());
+ assertEquals("must be associated with model", modelCon,
+ tvAlt.getModel());
}
@@ -492,7 +513,7 @@ public abstract class AbstractModelConCo
public void testCreateAlt_String() {
model.register(SL);
txnBegin(model);
- final Alt tvAlt = model.createAlt("http://exmple.com/A");
+ final Alt tvAlt = modelCon.createAlt("http://exmple.com/A");
txnCommit(model);
List<Statement> stmts = model.listStatements().toList();
@@ -503,7 +524,8 @@ public abstract class AbstractModelConCo
SL.assertHas("add", stmts.get(0));
Assert.assertEquals("http://exmple.com/A", tvAlt.getURI());
Assert.assertTrue("Alt should be alt", tvAlt.isAlt());
- assertEquals("must be associated with model", model, tvAlt.getModel());
+ assertEquals("must be associated with model", modelCon,
+ tvAlt.getModel());
}
@@ -512,7 +534,7 @@ public abstract class AbstractModelConCo
model.register(SL);
txnBegin(model);
- final Bag tvBag = model.createBag();
+ final Bag tvBag = modelCon.createBag();
txnCommit(model);
List<Statement> stmts = model.listStatements().toList();
@@ -523,14 +545,15 @@ public abstract class AbstractModelConCo
SL.assertHas("add", stmts.get(0));
Assert.assertTrue("bag should be anonymous", tvBag.isAnon());
Assert.assertTrue("bag should be bag", tvBag.isBag());
- assertEquals("must be associated with model", model, tvBag.getModel());
+ assertEquals("must be associated with model", modelCon,
+ tvBag.getModel());
}
@Test
public void testCreateBag_String() {
model.register(SL);
txnBegin(model);
- final Bag tvBag = model.createBag("http://exmple.com/B");
+ final Bag tvBag = modelCon.createBag("http://exmple.com/B");
txnCommit(model);
List<Statement> stmts = model.listStatements().toList();
@@ -542,7 +565,8 @@ public abstract class AbstractModelConCo
Assert.assertEquals("http://exmple.com/B", tvBag.getURI());
Assert.assertTrue("bag should be bag", tvBag.isBag());
- assertEquals("must be associated with model", model, tvBag.getModel());
+ assertEquals("must be associated with model", modelCon,
+ tvBag.getModel());
}
@@ -550,10 +574,10 @@ public abstract class AbstractModelConCo
public void testLiteral_String() {
model.register(SL);
txnBegin(model);
- Literal l = model.createLiteral("foo");
+ Literal l = modelCon.createLiteral("foo");
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, l.getModel());
+ assertEquals("must be associated with model", modelCon, l.getModel());
assertFalse("Should not be in model", model.contains(null, null, l));
}
@@ -561,11 +585,11 @@ public abstract class AbstractModelConCo
public void testCreateLiteralStatement_Resource_Property_boolean() {
model.register(SL);
txnBegin(model);
- Statement s = model.createLiteralStatement(resource("S"),
+ Statement s = modelCon.createLiteralStatement(resource("S"),
property("P"), true);
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, s.getModel());
+ assertEquals("must be associated with model", modelCon, s.getModel());
assertFalse("Should not be in model", model.contains(s));
}
@@ -573,11 +597,11 @@ public abstract class AbstractModelConCo
public void testCreateLiteralStatement_Resource_Property_char() {
model.register(SL);
txnBegin(model);
- Statement s = model.createLiteralStatement(resource("S"),
+ Statement s = modelCon.createLiteralStatement(resource("S"),
property("P"), 'c');
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, s.getModel());
+ assertEquals("must be associated with model", modelCon, s.getModel());
assertFalse("Should not be in model", model.contains(s));
}
@@ -585,11 +609,11 @@ public abstract class AbstractModelConCo
public void testCreateLiteralStatement_Resource_Property_double() {
model.register(SL);
txnBegin(model);
- Statement s = model.createLiteralStatement(resource("S"),
+ Statement s = modelCon.createLiteralStatement(resource("S"),
property("P"), 4.5d);
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, s.getModel());
+ assertEquals("must be associated with model", modelCon, s.getModel());
assertFalse("Should not be in model", model.contains(s));
}
@@ -597,11 +621,11 @@ public abstract class AbstractModelConCo
public void testCreateLiteralStatement_Resource_Property_float() {
model.register(SL);
txnBegin(model);
- Statement s = model.createLiteralStatement(resource("S"),
+ Statement s = modelCon.createLiteralStatement(resource("S"),
property("P"), 4.5f);
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, s.getModel());
+ assertEquals("must be associated with model", modelCon, s.getModel());
assertFalse("Should not be in model", model.contains(s));
}
@@ -609,11 +633,11 @@ public abstract class AbstractModelConCo
public void testCreateLiteralStatement_Resource_Property_int() {
model.register(SL);
txnBegin(model);
- Statement s = model.createLiteralStatement(resource("S"),
+ Statement s = modelCon.createLiteralStatement(resource("S"),
property("P"), 4);
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, s.getModel());
+ assertEquals("must be associated with model", modelCon, s.getModel());
assertFalse("Should not be in model", model.contains(s));
}
@@ -621,11 +645,11 @@ public abstract class AbstractModelConCo
public void testCreateLiteralStatement_Resource_Property_long() {
model.register(SL);
txnBegin(model);
- Statement s = model.createLiteralStatement(resource("S"),
+ Statement s = modelCon.createLiteralStatement(resource("S"),
property("P"), 4L);
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, s.getModel());
+ assertEquals("must be associated with model", modelCon, s.getModel());
assertFalse("Should not be in model", model.contains(s));
}
@@ -633,11 +657,11 @@ public abstract class AbstractModelConCo
public void testCreateLiteralStatement_Resource_Property_Object() {
model.register(SL);
txnBegin(model);
- Statement s = model.createLiteralStatement(resource("S"),
+ Statement s = modelCon.createLiteralStatement(resource("S"),
property("P"), tvObject);
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, s.getModel());
+ assertEquals("must be associated with model", modelCon, s.getModel());
assertFalse("Should not be in model", model.contains(s));
}
@@ -645,10 +669,10 @@ public abstract class AbstractModelConCo
public void testCreateProperty_String() {
model.register(SL);
txnBegin(model);
- Property p = model.createProperty("ex:/test");
+ Property p = modelCon.createProperty("ex:/test");
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, p.getModel());
+ assertEquals("must be associated with model", modelCon, p.getModel());
assertFalse("Should not be in model",
model.contains(null, p, (RDFNode) null));
assertEquals("ex:/test", p.getURI());
@@ -659,10 +683,10 @@ public abstract class AbstractModelConCo
Resource typ = resource("ex:/type");
model.register(SL);
txnBegin(model);
- Resource r = model.createResource(typ);
+ Resource r = modelCon.createResource(typ);
txnCommit(model);
SL.has("add", statement(r, RDF.type, typ));
- assertEquals("must be associated with model", model, r.getModel());
+ assertEquals("must be associated with model", modelCon, r.getModel());
assertTrue("Should be anonymous type", r.isAnon());
assertTrue("Should be in model", model.contains(r, RDF.type, typ));
}
@@ -672,10 +696,10 @@ public abstract class AbstractModelConCo
Resource typ = resource("ex:/type");
model.register(SL);
txnBegin(model);
- Resource r = model.createResource("A", typ);
+ Resource r = modelCon.createResource("A", typ);
txnCommit(model);
SL.assertHas("add", statement(r, RDF.type, typ));
- assertEquals("must be associated with model", model, r.getModel());
+ assertEquals("must be associated with model", modelCon, r.getModel());
assertEquals("Wrong URI", "A", r.getURI());
assertTrue("Should be in model", model.contains(r, RDF.type, typ));
}
@@ -685,7 +709,7 @@ public abstract class AbstractModelConCo
model.register(SL);
txnBegin(model);
- final Seq tvSeq = model.createSeq();
+ final Seq tvSeq = modelCon.createSeq();
txnCommit(model);
List<Statement> stmts = model.listStatements().toList();
@@ -696,14 +720,15 @@ public abstract class AbstractModelConCo
SL.assertHas("add", stmts.get(0));
Assert.assertTrue("seq should be anonymous", tvSeq.isAnon());
Assert.assertTrue("seq should be seq", tvSeq.isSeq());
- assertEquals("must be associated with model", model, tvSeq.getModel());
+ assertEquals("must be associated with model", modelCon,
+ tvSeq.getModel());
}
@Test
public void testCreateSeq_String() {
model.register(SL);
txnBegin(model);
- final Seq tvSeq = model.createSeq("http://exmple.com/B");
+ final Seq tvSeq = modelCon.createSeq("http://exmple.com/B");
txnCommit(model);
List<Statement> stmts = model.listStatements().toList();
@@ -715,7 +740,8 @@ public abstract class AbstractModelConCo
Assert.assertEquals("http://exmple.com/B", tvSeq.getURI());
Assert.assertTrue("seq should be seq", tvSeq.isSeq());
- assertEquals("must be associated with model", model, tvSeq.getModel());
+ assertEquals("must be associated with model", modelCon,
+ tvSeq.getModel());
}
@@ -724,13 +750,13 @@ public abstract class AbstractModelConCo
Literal lit = ResourceFactory.createPlainLiteral("foo");
model.register(SL);
txnBegin(model);
- final Statement s = model.createStatement(resource("S"), property("P"),
- "foo");
+ final Statement s = modelCon.createStatement(resource("S"),
+ property("P"), "foo");
txnCommit(model);
assertFalse("found statements", model.listStatements().hasNext());
SL.assertEmpty();
- assertSame("must be associated with model", model, s.getModel());
+ assertSame("must be associated with model", modelCon, s.getModel());
assertFalse("must not be in model", model.contains(s));
assertEquals("Wrong subject", resource("S"), s.getSubject());
@@ -745,23 +771,23 @@ public abstract class AbstractModelConCo
Literal lit = ResourceFactory.createTypedLiteral("foo", dt);
model.register(SL);
txnBegin(model);
- final Statement s = model.createStatement(resource("S"), property("P"),
- "foo", true);
+ final Statement s = modelCon.createStatement(resource("S"),
+ property("P"), "foo", true);
txnCommit(model);
assertFalse("found statements", model.listStatements().hasNext());
SL.assertEmpty();
- assertSame("must be associated with model", model, s.getModel());
+ assertSame("must be associated with model", modelCon, s.getModel());
assertFalse("must not be in model", model.contains(s));
assertEquals("Wrong subject", resource("S"), s.getSubject());
assertEquals("Wrong predicate", property("P"), s.getPredicate());
// this does not work because of basedatatype equality strangeness
// assertEquals("Wrong object", lit, s.getObject());
- assertTrue( s.getObject().isLiteral());
+ assertTrue(s.getObject().isLiteral());
Literal lit2 = s.getObject().asLiteral();
- assertEquals( lit.getDatatypeURI(), lit2.getDatatypeURI() );
- assertEquals( lit.getString(), lit2.getString());
+ assertEquals(lit.getDatatypeURI(), lit2.getDatatypeURI());
+ assertEquals(lit.getString(), lit2.getString());
}
@Test
@@ -769,13 +795,13 @@ public abstract class AbstractModelConCo
Literal lit = literal("foo", "fr");
model.register(SL);
txnBegin(model);
- final Statement s = model.createStatement(resource("S"), property("P"),
- "foo", "fr");
+ final Statement s = modelCon.createStatement(resource("S"),
+ property("P"), "foo", "fr");
txnCommit(model);
assertFalse("found statements", model.listStatements().hasNext());
SL.assertEmpty();
- assertSame("must be associated with model", model, s.getModel());
+ assertSame("must be associated with model", modelCon, s.getModel());
assertFalse("must not be in model", model.contains(s));
assertEquals("Wrong subject", resource("S"), s.getSubject());
@@ -796,13 +822,13 @@ public abstract class AbstractModelConCo
n.getLiteralLexicalForm(), n.getLiteralDatatype());
model.register(SL);
txnBegin(model);
- final Statement s = model.createStatement(resource("S"), property("P"),
- "foo", "fr", true);
+ final Statement s = modelCon.createStatement(resource("S"),
+ property("P"), "foo", "fr", true);
txnCommit(model);
assertFalse("found statements", model.listStatements().hasNext());
SL.assertEmpty();
- assertSame("must be associated with model", model, s.getModel());
+ assertSame("must be associated with model", modelCon, s.getModel());
assertFalse("must not be in model", model.contains(s));
assertEquals("Wrong subject", resource("S"), s.getSubject());
assertEquals("Wrong predicate", property("P"), s.getPredicate());
@@ -818,11 +844,11 @@ public abstract class AbstractModelConCo
public void testCreateTypedLiteral_boolean() {
model.register(SL);
txnBegin(model);
- final Literal l = model.createTypedLiteral(true);
+ final Literal l = modelCon.createTypedLiteral(true);
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, l.getModel());
+ assertEquals("must be associated with model", modelCon, l.getModel());
assertFalse("Found literal in model", model.contains(null, null, l));
assertEquals("wrong type of literal", XSDDatatype.XSDboolean,
l.getDatatype());
@@ -836,11 +862,11 @@ public abstract class AbstractModelConCo
model.register(SL);
txnBegin(model);
- final Literal l = model.createTypedLiteral(c);
+ final Literal l = modelCon.createTypedLiteral(c);
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, l.getModel());
+ assertEquals("must be associated with model", modelCon, l.getModel());
assertFalse("Found literal in model", model.contains(null, null, l));
assertEquals("wrong type of literal", XSDDatatype.XSDdateTime,
l.getDatatype());
@@ -851,11 +877,11 @@ public abstract class AbstractModelConCo
public void testCreateTypedLiteral_char() {
model.register(SL);
txnBegin(model);
- final Literal l = model.createTypedLiteral('c');
+ final Literal l = modelCon.createTypedLiteral('c');
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, l.getModel());
+ assertEquals("must be associated with model", modelCon, l.getModel());
assertFalse("Found literal in model", model.contains(null, null, l));
assertEquals("wrong type of literal", XSDDatatype.XSDstring,
l.getDatatype());
@@ -866,11 +892,11 @@ public abstract class AbstractModelConCo
public void testCreateTypedLiteral_double() {
model.register(SL);
txnBegin(model);
- final Literal l = model.createTypedLiteral(4.5d);
+ final Literal l = modelCon.createTypedLiteral(4.5d);
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, l.getModel());
+ assertEquals("must be associated with model", modelCon, l.getModel());
assertFalse("Found literal in model", model.contains(null, null, l));
assertEquals("wrong type of literal", XSDDatatype.XSDdouble,
l.getDatatype());
@@ -882,11 +908,11 @@ public abstract class AbstractModelConCo
float f = 4.5f;
model.register(SL);
txnBegin(model);
- final Literal l = model.createTypedLiteral(f);
+ final Literal l = modelCon.createTypedLiteral(f);
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, l.getModel());
+ assertEquals("must be associated with model", modelCon, l.getModel());
assertFalse("Found literal in model", model.contains(null, null, l));
assertEquals("wrong type of literal", XSDDatatype.XSDfloat,
l.getDatatype());
@@ -897,11 +923,11 @@ public abstract class AbstractModelConCo
public void testCreateTypedLiteral_int() {
model.register(SL);
txnBegin(model);
- final Literal l = model.createTypedLiteral(5);
+ final Literal l = modelCon.createTypedLiteral(5);
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, l.getModel());
+ assertEquals("must be associated with model", modelCon, l.getModel());
assertFalse("Found literal in model", model.contains(null, null, l));
assertEquals("wrong type of literal", XSDDatatype.XSDint,
l.getDatatype());
@@ -912,11 +938,11 @@ public abstract class AbstractModelConCo
public void testCreateTypedLiteral_long() {
model.register(SL);
txnBegin(model);
- final Literal l = model.createTypedLiteral(5L);
+ final Literal l = modelCon.createTypedLiteral(5L);
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, l.getModel());
+ assertEquals("must be associated with model", modelCon, l.getModel());
assertFalse("Found literal in model", model.contains(null, null, l));
assertEquals("wrong type of literal", XSDDatatype.XSDlong,
l.getDatatype());
@@ -927,13 +953,13 @@ public abstract class AbstractModelConCo
public void testCreateTypedLiteral_Object() {
model.register(SL);
txnBegin(model);
- final Literal l = model.createTypedLiteral(tvObject);
+ final Literal l = modelCon.createTypedLiteral(tvObject);
txnCommit(model);
BaseDatatype dt = new AdhocDatatype(ModelHelper.LitTestObj.class);
SL.assertEmpty();
- assertEquals("must be associated with model", model, l.getModel());
+ assertEquals("must be associated with model", modelCon, l.getModel());
assertFalse("Found literal in model", model.contains(null, null, l));
assertEquals("wrong type of literal", dt.getURI(), l.getDatatypeURI());
assertEquals("wrong value", tvObject.toString(), l.getString());
@@ -944,12 +970,12 @@ public abstract class AbstractModelConCo
RDFDatatype dt = new BaseDatatype("http://example.com/objType");
model.register(SL);
txnBegin(model);
- final Literal l = model.createTypedLiteral(tvObject,
+ final Literal l = modelCon.createTypedLiteral(tvObject,
"http://example.com/objType");
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, l.getModel());
+ assertEquals("must be associated with model", modelCon, l.getModel());
assertFalse("Found literal in model", model.contains(null, null, l));
assertEquals("wrong type of literal", dt.getURI(), l.getDatatype()
.getURI());
@@ -960,11 +986,11 @@ public abstract class AbstractModelConCo
public void testCreateTypedLiteral_String() {
model.register(SL);
txnBegin(model);
- final Literal l = model.createTypedLiteral("foo");
+ final Literal l = modelCon.createTypedLiteral("foo");
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, l.getModel());
+ assertEquals("must be associated with model", modelCon, l.getModel());
assertFalse("Found literal in model", model.contains(null, null, l));
assertEquals("wrong type of literal", XSDDatatype.XSDstring,
l.getDatatype());
@@ -976,12 +1002,12 @@ public abstract class AbstractModelConCo
RDFDatatype dt = new BaseDatatype("http://example.com/strType");
model.register(SL);
txnBegin(model);
- final Literal l = model.createTypedLiteral("foo",
+ final Literal l = modelCon.createTypedLiteral("foo",
"http://example.com/strType");
txnCommit(model);
SL.assertEmpty();
- assertEquals("must be associated with model", model, l.getModel());
+ assertEquals("must be associated with model", modelCon, l.getModel());
assertFalse("Found literal in model", model.contains(null, null, l));
assertEquals("wrong type of literal", dt.getURI(), l.getDatatype()
.getURI());
@@ -1000,10 +1026,11 @@ public abstract class AbstractModelConCo
Resource r = resource("O");
// get a non existant alt
- Alt alt = model.getAlt(r);
+ Alt alt = modelCon.getAlt(r);
// verify alt settings
- logAssertSame(this.getClass(), "must be of the model", model, alt.getModel());
+ logAssertSame(this.getClass(), "must be of the model", modelCon,
+ alt.getModel());
assertEquals("must be uri", r.getURI(), alt.getURI());
assertFalse("model must not contain statement", model.listStatements()
.hasNext());
@@ -1012,13 +1039,14 @@ public abstract class AbstractModelConCo
// add the alt to the model
txnBegin(model);
- model.add(alt, RDF.type, RDF.Alt);
+ modelCon.add(alt, RDF.type, RDF.Alt);
txnCommit(model);
SL.clear();
- Alt alt2 = model.getAlt(r);
+ Alt alt2 = modelCon.getAlt(r);
SL.assertEmpty();
- logAssertSame(this.getClass(),"must be of the model", model, alt2.getModel());
+ logAssertSame(this.getClass(), "must be of the model", modelCon,
+ alt2.getModel());
assertEquals("must be uri", r.getURI(), alt2.getURI());
logAssertTrue(this.getClass(), "must be an alt", alt2.isAlt());
}
@@ -1032,25 +1060,25 @@ public abstract class AbstractModelConCo
// should not add anything to the model
// get a non existant bag
- Alt alt = model.getAlt("O");
+ Alt alt = modelCon.getAlt("O");
// verify alt settings
- assertSame("must be of the model", model, alt.getModel());
+ assertSame("must be of the model", modelCon, alt.getModel());
assertEquals("must be uri", "O", alt.getURI());
assertFalse("model must not contain statement", model.listStatements()
.hasNext());
- logAssertTrue( this.getClass(), "must be an alt", alt.isAlt());
+ logAssertTrue(this.getClass(), "must be an alt", alt.isAlt());
SL.assertEmpty();
// add the alt to the model
txnBegin(model);
- model.add(alt, RDF.type, RDF.Alt);
+ modelCon.add(alt, RDF.type, RDF.Alt);
txnCommit(model);
SL.clear();
- Alt alt2 = model.getAlt("O");
+ Alt alt2 = modelCon.getAlt("O");
SL.assertEmpty();
- assertSame("must be of the model", model, alt2.getModel());
+ assertSame("must be of the model", modelCon, alt2.getModel());
assertEquals("must be uri", "O", alt2.getURI());
assertTrue("must be an alt", alt2.isAlt());
}
@@ -1067,10 +1095,11 @@ public abstract class AbstractModelConCo
Resource r = resource("O");
// get a non existant bag
- Bag bag = model.getBag(r);
+ Bag bag = modelCon.getBag(r);
// verify bag settings
- logAssertSame( this.getClass(), "must be of the model", model, bag.getModel());
+ logAssertSame(this.getClass(), "must be of the model", modelCon,
+ bag.getModel());
assertEquals("must be uri", r.getURI(), bag.getURI());
assertFalse("model must not contain statement", model.listStatements()
.hasNext());
@@ -1079,16 +1108,17 @@ public abstract class AbstractModelConCo
// add the bag to the model
txnBegin(model);
- model.add(bag, RDF.type, RDF.Bag);
+ modelCon.add(bag, RDF.type, RDF.Bag);
// bag.add(false);
txnCommit(model);
// SL.clear();
r.getModel().write(System.out, "TURTLE");
- Bag bag2 = model.getBag(r);
+ Bag bag2 = modelCon.getBag(r);
// SL.assertEmpty();
- logAssertSame(this.getClass(), "must be of the model", model, bag2.getModel());
+ logAssertSame(this.getClass(), "must be of the model", modelCon,
+ bag2.getModel());
assertEquals("must be uri", r.getURI(), bag2.getURI());
logAssertTrue(this.getClass(), "must be a bag", bag2.isBag());
@@ -1099,10 +1129,10 @@ public abstract class AbstractModelConCo
model.register(SL);
// get a non-existant bag
- Bag bag = model.getBag("O");
+ Bag bag = modelCon.getBag("O");
// verify bag settings
- assertSame("must not be of the model", model, bag.getModel());
+ assertSame("must not be of the model", modelCon, bag.getModel());
assertEquals("must be uri", "O", bag.getURI());
assertFalse("model must not contain statement", model.listStatements()
.hasNext());
@@ -1111,14 +1141,14 @@ public abstract class AbstractModelConCo
// add the bag to the model
txnBegin(model);
- model.add(bag, RDF.type, RDF.Bag);
+ modelCon.add(bag, RDF.type, RDF.Bag);
txnCommit(model);
SL.clear();
// read it back
- Bag bag2 = model.getBag("O");
+ Bag bag2 = modelCon.getBag("O");
SL.assertEmpty();
- assertSame("must be of the model", model, bag2.getModel());
+ assertSame("must be of the model", modelCon, bag2.getModel());
assertEquals("must be uri", "O", bag2.getURI());
assertTrue("must be a bag", bag2.isBag());
}
@@ -1128,10 +1158,10 @@ public abstract class AbstractModelConCo
model.register(SL);
// get a non-existant property
- Property p = model.getProperty("P");
+ Property p = modelCon.getProperty("P");
// verify bag settings
- assertSame("must be of the model", model, p.getModel());
+ assertSame("must be of the model", modelCon, p.getModel());
assertEquals("must be uri", "P", p.getURI());
assertFalse("model must not contain statement", model.listStatements()
.hasNext());
@@ -1139,14 +1169,14 @@ public abstract class AbstractModelConCo
// add the bag to the model
txnBegin(model);
- model.add(p, RDF.type, RDF.Property);
+ modelCon.add(p, RDF.type, RDF.Property);
txnCommit(model);
SL.clear();
// read it back
- Property p2 = model.getProperty("P");
+ Property p2 = modelCon.getProperty("P");
SL.assertEmpty();
- assertSame("must be of the model", model, p2.getModel());
+ assertSame("must be of the model", modelCon, p2.getModel());
assertEquals("must be uri", "P", p2.getURI());
}
@@ -1155,10 +1185,10 @@ public abstract class AbstractModelConCo
// create the node
txnBegin(model);
- RDFNode o = model.getRDFNode(NodeCreateUtils.create("O"));
+ RDFNode o = modelCon.getRDFNode(NodeCreateUtils.create("O"));
txnCommit(model);
- assertEquals("must be of the model", model, o.getModel());
+ assertEquals("must be of the model", modelCon, o.getModel());
assertFalse("model must not contain the resource", model
.listStatements().hasNext());
}
@@ -1175,10 +1205,11 @@ public abstract class AbstractModelConCo
Resource r = resource("O");
// get a non existant seq
- Seq seq = model.getSeq(r);
+ Seq seq = modelCon.getSeq(r);
// verify bag settings
- logAssertSame(this.getClass(), "must be of the model", model, seq.getModel());
+ logAssertSame(this.getClass(), "must be of the model", modelCon,
+ seq.getModel());
assertEquals("must be uri", r.getURI(), seq.getURI());
assertFalse("model must not contain statement", model.listStatements()
.hasNext());
@@ -1187,13 +1218,14 @@ public abstract class AbstractModelConCo
// add the seq to the model
txnBegin(model);
- model.add(seq, RDF.type, RDF.Bag);
+ modelCon.add(seq, RDF.type, RDF.Bag);
txnCommit(model);
SL.clear();
- Seq seq2 = model.getSeq(r);
+ Seq seq2 = modelCon.getSeq(r);
SL.assertEmpty();
- logAssertSame( this.getClass(), "must be of the model", model, seq2.getModel());
+ logAssertSame(this.getClass(), "must be of the model", modelCon,
+ seq2.getModel());
assertEquals("must be uri", r.getURI(), seq2.getURI());
logAssertTrue(this.getClass(), "must be a seq", seq2.isSeq());
@@ -1208,25 +1240,25 @@ public abstract class AbstractModelConCo
// should not add anything to the model
// get a non existant bag
- Seq seq = model.getSeq("O");
+ Seq seq = modelCon.getSeq("O");
// verify seq settings
- assertSame("must be of the model", model, seq.getModel());
+ assertSame("must be of the model", modelCon, seq.getModel());
assertEquals("must be uri", "O", seq.getURI());
assertFalse("model must not contain statement", model.listStatements()
.hasNext());
- logAssertTrue(this.getClass(),"must be a seq", seq.isSeq());
+ logAssertTrue(this.getClass(), "must be a seq", seq.isSeq());
SL.assertEmpty();
// add the seq to the model
txnBegin(model);
- model.add(seq, RDF.type, RDF.Bag);
+ modelCon.add(seq, RDF.type, RDF.Bag);
txnCommit(model);
SL.clear();
- Seq seq2 = model.getSeq("O");
+ Seq seq2 = modelCon.getSeq("O");
SL.assertEmpty();
- assertSame("must be of the model", model, seq2.getModel());
+ assertSame("must be of the model", modelCon, seq2.getModel());
assertEquals("must be uri", "O", seq2.getURI());
logAssertTrue(this.getClass(), "must be a seq", seq2.isSeq());
@@ -1239,18 +1271,19 @@ public abstract class AbstractModelConCo
Property p = property("P");
txnBegin(model);
modelAdd(model, "S P O; S P2 O2");
- model.addLiteral(resource("S"), p, v1);
- model.addLiteral(resource("S2"), p, v2);
+ modelCon.addLiteral(resource("S"), p, v1);
+ modelCon.addLiteral(resource("S2"), p, v2);
txnCommit(model);
- assertEquals(1, model.listLiteralStatements(null, null, v1).toList()
+ assertEquals(1, modelCon.listLiteralStatements(null, null, v1).toList()
+ .size());
+ assertEquals(0, modelCon
+ .listLiteralStatements(resource("S2"), null, v1).toList()
.size());
- assertEquals(0, model.listLiteralStatements(resource("S2"), null, v1)
- .toList().size());
- assertEquals(1, model.listLiteralStatements(null, null, v2).toList()
+ assertEquals(1, modelCon.listLiteralStatements(null, null, v2).toList()
.size());
- assertEquals(0, model.listLiteralStatements(resource("S"), null, v2)
+ assertEquals(0, modelCon.listLiteralStatements(resource("S"), null, v2)
.toList().size());
}
@@ -1262,18 +1295,19 @@ public abstract class AbstractModelConCo
Property p = property("P");
txnBegin(model);
modelAdd(model, "S P O; S P2 O2");
- model.addLiteral(resource("S"), p, v1);
- model.addLiteral(resource("S2"), p, v2);
+ modelCon.addLiteral(resource("S"), p, v1);
+ modelCon.addLiteral(resource("S2"), p, v2);
txnCommit(model);
- assertEquals(1, model.listLiteralStatements(null, null, v1).toList()
+ assertEquals(1, modelCon.listLiteralStatements(null, null, v1).toList()
+ .size());
+ assertEquals(0, modelCon
+ .listLiteralStatements(resource("S2"), null, v1).toList()
.size());
- assertEquals(0, model.listLiteralStatements(resource("S2"), null, v1)
- .toList().size());
- assertEquals(1, model.listLiteralStatements(null, null, v2).toList()
+ assertEquals(1, modelCon.listLiteralStatements(null, null, v2).toList()
.size());
- assertEquals(0, model.listLiteralStatements(resource("S"), null, v2)
+ assertEquals(0, modelCon.listLiteralStatements(resource("S"), null, v2)
.toList().size());
}
@@ -1285,18 +1319,19 @@ public abstract class AbstractModelConCo
Property p = property("P");
txnBegin(model);
modelAdd(model, "S P O; S P2 O2");
- model.addLiteral(resource("S"), p, v1);
- model.addLiteral(resource("S2"), p, v2);
+ modelCon.addLiteral(resource("S"), p, v1);
+ modelCon.addLiteral(resource("S2"), p, v2);
txnCommit(model);
- assertEquals(1, model.listLiteralStatements(null, null, v1).toList()
+ assertEquals(1, modelCon.listLiteralStatements(null, null, v1).toList()
+ .size());
+ assertEquals(0, modelCon
+ .listLiteralStatements(resource("S2"), null, v1).toList()
.size());
- assertEquals(0, model.listLiteralStatements(resource("S2"), null, v1)
- .toList().size());
- assertEquals(1, model.listLiteralStatements(null, null, v2).toList()
+ assertEquals(1, modelCon.listLiteralStatements(null, null, v2).toList()
.size());
- assertEquals(0, model.listLiteralStatements(resource("S"), null, v2)
+ assertEquals(0, modelCon.listLiteralStatements(resource("S"), null, v2)
.toList().size());
}
@@ -1308,18 +1343,19 @@ public abstract class AbstractModelConCo
Property p = property("P");
txnBegin(model);
modelAdd(model, "S P O; S P2 O2");
- model.addLiteral(resource("S"), p, v1);
- model.addLiteral(resource("S2"), p, v2);
+ modelCon.addLiteral(resource("S"), p, v1);
+ modelCon.addLiteral(resource("S2"), p, v2);
txnCommit(model);
- assertEquals(1, model.listLiteralStatements(null, null, v1).toList()
+ assertEquals(1, modelCon.listLiteralStatements(null, null, v1).toList()
+ .size());
+ assertEquals(0, modelCon
+ .listLiteralStatements(resource("S2"), null, v1).toList()
.size());
- assertEquals(0, model.listLiteralStatements(resource("S2"), null, v1)
- .toList().size());
- assertEquals(1, model.listLiteralStatements(null, null, v2).toList()
+ assertEquals(1, modelCon.listLiteralStatements(null, null, v2).toList()
.size());
- assertEquals(0, model.listLiteralStatements(resource("S"), null, v2)
+ assertEquals(0, modelCon.listLiteralStatements(resource("S"), null, v2)
.toList().size());
}
@@ -1331,18 +1367,19 @@ public abstract class AbstractModelConCo
Property p = property("P");
txnBegin(model);
modelAdd(model, "S P O; S P2 O2");
- model.addLiteral(resource("S"), p, v1);
- model.addLiteral(resource("S2"), p, v2);
+ modelCon.addLiteral(resource("S"), p, v1);
+ modelCon.addLiteral(resource("S2"), p, v2);
txnCommit(model);
- assertEquals(1, model.listLiteralStatements(null, null, v1).toList()
+ assertEquals(1, modelCon.listLiteralStatements(null, null, v1).toList()
+ .size());
+ assertEquals(0, modelCon
+ .listLiteralStatements(resource("S2"), null, v1).toList()
.size());
- assertEquals(0, model.listLiteralStatements(resource("S2"), null, v1)
- .toList().size());
- assertEquals(1, model.listLiteralStatements(null, null, v2).toList()
+ assertEquals(1, modelCon.listLiteralStatements(null, null, v2).toList()
.size());
- assertEquals(0, model.listLiteralStatements(resource("S"), null, v2)
+ assertEquals(0, modelCon.listLiteralStatements(resource("S"), null, v2)
.toList().size());
}
@@ -1357,16 +1394,20 @@ public abstract class AbstractModelConCo
Resource r1 = resource("S");
Resource r2 = resource("S1");
txnBegin(model);
- model.addLiteral(r1, p, v1);
- model.addLiteral(r1, p, v2);
- model.addLiteral(r2, p, v1);
+ modelCon.addLiteral(r1, p, v1);
+ modelCon.addLiteral(r1, p, v2);
+ modelCon.addLiteral(r2, p, v1);
txnCommit(model);
- assertEquals(2, model.listResourcesWithProperty(p, v1).toList().size());
- assertEquals(0, model.listResourcesWithProperty(p2, v1).toList().size());
+ assertEquals(2, modelCon.listResourcesWithProperty(p, v1).toList()
+ .size());
+ assertEquals(0, modelCon.listResourcesWithProperty(p2, v1).toList()
+ .size());
- assertEquals(1, model.listResourcesWithProperty(p, v2).toList().size());
- assertEquals(0, model.listResourcesWithProperty(p2, v2).toList().size());
+ assertEquals(1, modelCon.listResourcesWithProperty(p, v2).toList()
+ .size());
+ assertEquals(0, modelCon.listResourcesWithProperty(p2, v2).toList()
+ .size());
}
@@ -1380,16 +1421,20 @@ public abstract class AbstractModelConCo
Resource r1 = resource("S");
Resource r2 = resource("S1");
txnBegin(model);
- model.addLiteral(r1, p, v1);
- model.addLiteral(r1, p, v2);
- model.addLiteral(r2, p, v1);
+ modelCon.addLiteral(r1, p, v1);
+ modelCon.addLiteral(r1, p, v2);
+ modelCon.addLiteral(r2, p, v1);
txnCommit(model);
- assertEquals(2, model.listResourcesWithProperty(p, v1).toList().size());
- assertEquals(0, model.listResourcesWithProperty(p2, v1).toList().size());
+ assertEquals(2, modelCon.listResourcesWithProperty(p, v1).toList()
+ .size());
+ assertEquals(0, modelCon.listResourcesWithProperty(p2, v1).toList()
+ .size());
- assertEquals(1, model.listResourcesWithProperty(p, v2).toList().size());
- assertEquals(0, model.listResourcesWithProperty(p2, v2).toList().size());
+ assertEquals(1, modelCon.listResourcesWithProperty(p, v2).toList()
+ .size());
+ assertEquals(0, modelCon.listResourcesWithProperty(p2, v2).toList()
+ .size());
}
@@ -1403,16 +1448,20 @@ public abstract class AbstractModelConCo
Resource r1 = resource("S");
Resource r2 = resource("S1");
txnBegin(model);
- model.addLiteral(r1, p, v1);
- model.addLiteral(r1, p, v2);
- model.addLiteral(r2, p, v1);
+ modelCon.addLiteral(r1, p, v1);
+ modelCon.addLiteral(r1, p, v2);
+ modelCon.addLiteral(r2, p, v1);
txnCommit(model);
- assertEquals(2, model.listResourcesWithProperty(p, v1).toList().size());
- assertEquals(0, model.listResourcesWithProperty(p2, v1).toList().size());
+ assertEquals(2, modelCon.listResourcesWithProperty(p, v1).toList()
+ .size());
+ assertEquals(0, modelCon.listResourcesWithProperty(p2, v1).toList()
+ .size());
- assertEquals(1, model.listResourcesWithProperty(p, v2).toList().size());
- assertEquals(0, model.listResourcesWithProperty(p2, v2).toList().size());
+ assertEquals(1, modelCon.listResourcesWithProperty(p, v2).toList()
+ .size());
+ assertEquals(0, modelCon.listResourcesWithProperty(p2, v2).toList()
+ .size());
}
@@ -1426,16 +1475,20 @@ public abstract class AbstractModelConCo
Resource r1 = resource("S");
Resource r2 = resource("S1");
txnBegin(model);
- model.addLiteral(r1, p, v1);
- model.addLiteral(r1, p, v2);
- model.addLiteral(r2, p, v1);
+ modelCon.addLiteral(r1, p, v1);
+ modelCon.addLiteral(r1, p, v2);
+ modelCon.addLiteral(r2, p, v1);
txnCommit(model);
- assertEquals(2, model.listResourcesWithProperty(p, v1).toList().size());
- assertEquals(0, model.listResourcesWithProperty(p2, v1).toList().size());
+ assertEquals(2, modelCon.listResourcesWithProperty(p, v1).toList()
+ .size());
+ assertEquals(0, modelCon.listResourcesWithProperty(p2, v1).toList()
+ .size());
- assertEquals(1, model.listResourcesWithProperty(p, v2).toList().size());
- assertEquals(0, model.listResourcesWithProperty(p2, v2).toList().size());
+ assertEquals(1, modelCon.listResourcesWithProperty(p, v2).toList()
+ .size());
+ assertEquals(0, modelCon.listResourcesWithProperty(p2, v2).toList()
+ .size());
}
@@ -1449,16 +1502,20 @@ public abstract class AbstractModelConCo
Resource r1 = resource("S");
Resource r2 = resource("S1");
txnBegin(model);
- model.addLiteral(r1, p, v1);
- model.addLiteral(r1, p, v2);
- model.addLiteral(r2, p, v1);
+ modelCon.addLiteral(r1, p, v1);
+ modelCon.addLiteral(r1, p, v2);
+ modelCon.addLiteral(r2, p, v1);
txnCommit(model);
- assertEquals(2, model.listResourcesWithProperty(p, v1).toList().size());
- assertEquals(0, model.listResourcesWithProperty(p2, v1).toList().size());
+ assertEquals(2, modelCon.listResourcesWithProperty(p, v1).toList()
+ .size());
+ assertEquals(0, modelCon.listResourcesWithProperty(p2, v1).toList()
+ .size());
- assertEquals(1, model.listResourcesWithProperty(p, v2).toList().size());
- assertEquals(0, model.listResourcesWithProperty(p2, v2).toList().size());
+ assertEquals(1, modelCon.listResourcesWithProperty(p, v2).toList()
+ .size());
+ assertEquals(0, modelCon.listResourcesWithProperty(p2, v2).toList()
+ .size());
}
@@ -1472,16 +1529,20 @@ public abstract class AbstractModelConCo
Resource r1 = resource("S");
Resource r2 = resource("S1");
txnBegin(model);
- model.addLiteral(r1, p, v1);
- model.addLiteral(r1, p, v2);
- model.addLiteral(r2, p, v1);
+ modelCon.addLiteral(r1, p, v1);
+ modelCon.addLiteral(r1, p, v2);
+ modelCon.addLiteral(r2, p, v1);
txnCommit(model);
- assertEquals(2, model.listResourcesWithProperty(p, v1).toList().size());
- assertEquals(0, model.listResourcesWithProperty(p2, v1).toList().size());
+ assertEquals(2, modelCon.listResourcesWithProperty(p, v1).toList()
+ .size());
+ assertEquals(0, modelCon.listResourcesWithProperty(p2, v1).toList()
+ .size());
- assertEquals(1, model.listResourcesWithProperty(p, v2).toList().size());
- assertEquals(0, model.listResourcesWithProperty(p2, v2).toList().size());
+ assertEquals(1, modelCon.listResourcesWithProperty(p, v2).toList()
+ .size());
+ assertEquals(0, modelCon.listResourcesWithProperty(p2, v2).toList()
+ .size());
}
@@ -1495,20 +1556,19 @@ public abstract class AbstractModelConCo
Resource r1 = resource("S");
Resource r2 = resource("S1");
txnBegin(model);
- model.add(r1, p, v1);
- model.add(r1, p, v2);
- model.add(r2, p, v1);
+ modelCon.add(r1, p, v1);
+ modelCon.add(r1, p, v2);
+ modelCon.add(r2, p, v1);
txnCommit(model);
- assertEquals(2, model.listStatements(null, p, v1).toList().size());
- assertEquals(1, model.listStatements(r1, p, v1).toList().size());
- assertEquals(1, model.listStatements(r2, p, v1).toList().size());
-
- assertEquals(0, model.listStatements(null, p2, v2).toList().size());
- assertEquals(0, model.listStatements(r1, p2, v2).toList().size());
- assertEquals(0, model.listStatements(r2, p2, v2).toList().size());
-
-
+ assertEquals(2, modelCon.listStatements(null, p, v1).toList().size());
+ assertEquals(1, modelCon.listStatements(r1, p, v1).toList().size());
+ assertEquals(1, modelCon.listStatements(r2, p, v1).toList().size());
+
+ assertEquals(0, modelCon.listStatements(null, p2, v2).toList().size());
+ assertEquals(0, modelCon.listStatements(r1, p2, v2).toList().size());
+ assertEquals(0, modelCon.listStatements(r2, p2, v2).toList().size());
+
}
@Test
@@ -1519,24 +1579,29 @@ public abstract class AbstractModelConCo
Resource s = resource("S");
txnBegin(model);
- model.add(s, p, v, "en");
- model.add(s, p, v, "fr");
- model.add(s, p, v, (String)null );
- model.add(s, p, v2, (String)null );
- txnCommit(model);
-
- assertEquals(1, model.listStatements(s, p, v, "en").toList().size());
- assertEquals(1, model.listStatements(s, p, v, "fr").toList().size());
- assertEquals(3, model.listStatements(s, p, v, null).toList().size());
- assertEquals(1, model.listStatements(s, p, null, "en").toList().size());
- assertEquals(1, model.listStatements(s, p, null, "fr").toList().size());
- assertEquals(2, model.listStatements(s, p, null, "").toList().size());
- assertEquals(1, model.listStatements(s, p, v, "").toList().size());
- assertEquals(1, model.listStatements(s, null, v, "en").toList().size());
- assertEquals(1, model.listStatements(null, p, v, "fr").toList().size());
- assertEquals(4, model.listStatements(s, p, null, null).toList().size());
- assertEquals(4, model.listStatements(null, null, null, null).toList()
+ modelCon.add(s, p, v, "en");
+ modelCon.add(s, p, v, "fr");
+ modelCon.add(s, p, v, (String) null);
+ modelCon.add(s, p, v2, (String) null);
+ txnCommit(model);
+
+ assertEquals(1, modelCon.listStatements(s, p, v, "en").toList().size());
+ assertEquals(1, modelCon.listStatements(s, p, v, "fr").toList().size());
+ assertEquals(3, modelCon.listStatements(s, p, v, null).toList().size());
+ assertEquals(1, modelCon.listStatements(s, p, null, "en").toList()
+ .size());
+ assertEquals(1, modelCon.listStatements(s, p, null, "fr").toList()
+ .size());
+ assertEquals(2, modelCon.listStatements(s, p, null, "").toList().size());
+ assertEquals(1, modelCon.listStatements(s, p, v, "").toList().size());
+ assertEquals(1, modelCon.listStatements(s, null, v, "en").toList()
+ .size());
+ assertEquals(1, modelCon.listStatements(null, p, v, "fr").toList()
.size());
+ assertEquals(4, modelCon.listStatements(s, p, null, null).toList()
+ .size());
+ assertEquals(4, modelCon.listStatements(null, null, null, null)
+ .toList().size());
}
@Test
@@ -1550,16 +1615,20 @@ public abstract class AbstractModelConCo
Resource r2 = resource("S1");
txnBegin(model);
- model.add(r1, p, v1);
- model.add(r1, p, v2);
- model.add(r2, p, v1);
+ modelCon.add(r1, p, v1);
+ modelCon.add(r1, p, v2);
+ modelCon.add(r2, p, v1);
txnCommit(model);
- assertEquals(2, model.listSubjectsWithProperty(p, v1).toList().size());
- assertEquals(0, model.listSubjectsWithProperty(p2, v1).toList().size());
+ assertEquals(2, modelCon.listSubjectsWithProperty(p, v1).toList()
+ .size());
+ assertEquals(0, modelCon.listSubjectsWithProperty(p2, v1).toList()
+ .size());
- assertEquals(1, model.listSubjectsWithProperty(p, v2).toList().size());
- assertEquals(0, model.listSubjectsWithProperty(p2, v2).toList().size());
+ assertEquals(1, modelCon.listSubjectsWithProperty(p, v2).toList()
+ .size());
+ assertEquals(0, modelCon.listSubjectsWithProperty(p2, v2).toList()
+ .size());
}
@@ -1572,19 +1641,19 @@ public abstract class AbstractModelConCo
Resource r = resource("S");
txnBegin(model);
- model.add(r, p, v, "en");
- model.add(r, p, v, "fr");
- model.add(r, p, v, (String) null);
- model.add(r, p, v);
+ modelCon.add(r, p, v, "en");
+ modelCon.add(r, p, v, "fr");
+ modelCon.add(r, p, v, (String) null);
+ modelCon.add(r, p, v);
txnCommit(model);
- assertEquals(1, model.listSubjectsWithProperty(p, v, "en").toList()
+ assertEquals(1, modelCon.listSubjectsWithProperty(p, v, "en").toList()
.size());
- assertEquals(1, model.listSubjectsWithProperty(p, v, "fr").toList()
+ assertEquals(1, modelCon.listSubjectsWithProperty(p, v, "fr").toList()
.size());
- assertEquals(0, model.listSubjectsWithProperty(p, v, "es").toList()
+ assertEquals(0, modelCon.listSubjectsWithProperty(p, v, "es").toList()
.size());
- assertEquals(1, model.listSubjectsWithProperty(p, v, null).toList()
+ assertEquals(1, modelCon.listSubjectsWithProperty(p, v, null).toList()
.size());
}
@@ -1599,8 +1668,8 @@ public abstract class AbstractModelConCo
model.register(SL);
txnBegin(model);
- assertEquals("Remove model should return model", model,
- model.remove(model2));
+ assertEquals("Remove model should return model", modelCon,
+ modelCon.remove(model2));
txnCommit(model);
SL.assertHas("removeModel", model2);
@@ -1619,8 +1688,8 @@ public abstract class AbstractModelConCo
model.register(SL);
txnBegin(model);
- assertEquals("Remove model should return model", model,
- model.remove(resource("S"), property("P"), rdfNode("O")));
+ assertEquals("Remove model should return model", modelCon,
+ modelCon.remove(resource("S"), property("P"), rdfNode("O")));
txnCommit(model);
SL.assertHas("remove", statement("S P O"));
@@ -1646,8 +1715,8 @@ public abstract class AbstractModelConCo
model.register(SL);
txnBegin(model);
- assertEquals("Remove model should return model", model,
- model.remove(si));
+ assertEquals("Remove model should return model", modelCon,
+ modelCon.remove(si));
txnCommit(model);
SL.assertContains("removeIterator");
@@ -1663,2037 +1732,2050 @@ public abstract class AbstractModelConCo
lst.contains(statement("S P2 O")));
}
-
-
-
-// @Test
-// public void testChangedListener() {
-// final ChangedListener CL = new ChangedListener();
-// model.register(CL);
-// Assert.assertFalse(CL.hasChanged());
-// model.add(statement("S P O"));
-// Assert.assertTrue(CL.hasChanged());
-// Assert.assertFalse(CL.hasChanged());
-// model.remove(statement("ab CD ef"));
-// Assert.assertTrue(CL.hasChanged());
-// model.add(statements("gh IJ kl"));
-// Assert.assertTrue(CL.hasChanged());
-// model.remove(statements("mn OP qr"));
-// Assert.assertTrue(CL.hasChanged());
-// model.add(asIterator(statements("st UV wx")));
-// Assert.assertTrue(CL.hasChanged());
-// Assert.assertFalse(CL.hasChanged());
-// model.remove(asIterator(statements("yz AB cd")));
-// Assert.assertTrue(CL.hasChanged());
-// model.add(modelWithStatements(getModelProducer(), "ef GH ij"));
-// Assert.assertTrue(CL.hasChanged());
-// model.remove(modelWithStatements(getModelProducer(), "kl MN op"));
-// Assert.assertTrue(CL.hasChanged());
-// model.add(Arrays.asList(statements("rs TU vw")));
-// Assert.assertTrue(CL.hasChanged());
-// model.remove(Arrays.asList(statements("xy wh q")));
-// Assert.assertTrue(CL.hasChanged());
-// }
-
-
+ // @Test
+ // public void testChangedListener() {
+ // final ChangedListener CL = new ChangedListener();
+ // model.register(CL);
+ // Assert.assertFalse(CL.hasChanged());
+ // model.add(statement("S P O"));
+ // Assert.assertTrue(CL.hasChanged());
+ // Assert.assertFalse(CL.hasChanged());
+ // model.remove(statement("ab CD ef"));
+ // Assert.assertTrue(CL.hasChanged());
+ // model.add(statements("gh IJ kl"));
+ // Assert.assertTrue(CL.hasChanged());
+ // model.remove(statements("mn OP qr"));
+ // Assert.assertTrue(CL.hasChanged());
+ // model.add(asIterator(statements("st UV wx")));
+ // Assert.assertTrue(CL.hasChanged());
+ // Assert.assertFalse(CL.hasChanged());
+ // model.remove(asIterator(statements("yz AB cd")));
+ // Assert.assertTrue(CL.hasChanged());
+ // model.add(modelWithStatements(getModelProducer(), "ef GH ij"));
+ // Assert.assertTrue(CL.hasChanged());
+ // model.remove(modelWithStatements(getModelProducer(), "kl MN op"));
+ // Assert.assertTrue(CL.hasChanged());
+ // model.add(Arrays.asList(statements("rs TU vw")));
+ // Assert.assertTrue(CL.hasChanged());
+ // model.remove(Arrays.asList(statements("xy wh q")));
+ // Assert.assertTrue(CL.hasChanged());
+ // }
+
// / FIXME END OF EDIT
-// @Test
-// public void testContains() {
-// testContains(false, "", "x");
-// testContains(false, "a R b", "x");
-// testContains(false, "a R b; c P d", "x");
-// /* */
-// testContains(false, "a R b", "z");
-// /* */
-// testContains(true, "x R y", "x");
-// testContains(true, "a P b", "P");
-// testContains(true, "i Q j", "j");
-// testContains(true, "x R y; a P b; i Q j", "y");
-// /* */
-// testContains(true, "x R y; a P b; i Q j", "y");
-// testContains(true, "x R y; a P b; i Q j", "R");
-// testContains(true, "x R y; a P b; i Q j", "a");
-// }
-//
-// @Test
-// public void testCreateResourceFromNode() {
-// RDFNode S = model.getRDFNode(NodeCreateUtils.create("spoo:S"));
-// assertInstanceOf(Resource.class, S);
-// assertEquals("spoo:S", ((Resource) S).getURI());
-// }
-//
-// @Test
-// public void testCreateLiteralFromNode() {
-// RDFNode S = model.getRDFNode(NodeCreateUtils.create("42"));
-// assertInstanceOf(Literal.class, S);
-// assertEquals("42", ((Literal) S).getLexicalForm());
-// }
-//
-// @Test
-// public void testCreateBlankFromNode() {
-// RDFNode S = model.getRDFNode(NodeCreateUtils.create("_Blank"));
-// assertInstanceOf(Resource.class, S);
-// assertEquals(new AnonId("_Blank"), ((Resource) S).getId());
-// }
-//
-// /**
-// * Always retuns a value even if the property is no in the model.
-// */
-// @Test
-// public void testGetPropertyURI() {
-// modelAdd(model, "x P a; x P b; x R c");
-// Assert.assertNotNull(model.getProperty(resource("P").getURI()));
-// Assert.assertNotNull(model.getProperty(resource("R").getURI()));
-// Assert.assertNotNull(model.getProperty(resource("x").getURI()));
-// }
-//
-// @Test
-// public void testToStatement() {
-// Triple t = triple("a P b");
-// Statement s = model.asStatement(t);
-// assertEquals(node("a"), s.getSubject().asNode());
-// assertEquals(node("P"), s.getPredicate().asNode());
-// assertEquals(node("b"), s.getObject().asNode());
-// }
-//
-// @Test
-// public void testAsRDF() {
-// verifyPresentAsRDFNode(node("a"), Resource.class);
-// verifyPresentAsRDFNode(node("17"), Literal.class);
-// verifyPresentAsRDFNode(node("_b"), Resource.class);
-// }
-//
-// private void verifyPresentAsRDFNode(Node n,
-// Class<? extends RDFNode> nodeClass) {
-// RDFNode r = model.asRDFNode(n);
-// assertSame(n, r.asNode());
-// assertInstanceOf(nodeClass, r);
-// }
-//
-// @Test
-// public void testURINodeAsResource() {
-// Node n = node("a");
-// Resource r = model.wrapAsResource(n);
-// assertSame(n, r.asNode());
-// }
-//
-// @Test
-// public void testLiteralNodeAsResourceFails() {
-// try {
-// model.wrapAsResource(node("17"));
-// fail("should fail to convert literal to Resource");
-// } catch (UnsupportedOperationException e) {
-// // expected
-// }
-// }
-//
-// /**
-// * 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 String[][] cases = { { "x R y", "x R y", "" },
-// { "x R y; a P b", "x R y", "a P b" },
-// { "x R y; a P b", "?? R y", "a P b" },
-// { "x R y; a P b", "x R ??", "a P b" },
-// { "x R y; a P b", "x ?? y", "a P b" },
-// { "x R y; a P b", "?? ?? ??", "" },
-// { "x R y; a P b; c P d", "?? P ??", "x R y" },
-// { "x R y; a P b; x S y", "x ?? ??", "a P b" }, };
-//
-// /**
-// * 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.
-// */
-// @Test
-// public void testRemoveSPO() {
-// ModelCom mc = (ModelCom) ModelFactory.createDefaultModel();
-// for (int i = 0; i < cases.length; i += 1)
-// for (int j = 0; j < 3; j += 1) {
-// Model content = getModelProducer().newModel();
-// Model baseContent = copy(content);
-// modelAdd(content, cases[i][0]);
-// Triple remove = triple(cases[i][1]);
-// Node s = remove.getSubject(), p = remove.getPredicate(), o = remove
-// .getObject();
-// Resource S = (Resource) (s.equals(Node.ANY) ? null : mc
-// .getRDFNode(s));
-// Property P = ((p.equals(Node.ANY) ? null : mc.getRDFNode(p).as(
-// Property.class)));
-// RDFNode O = o.equals(Node.ANY) ? null : mc.getRDFNode(o);
-// Model expected = modelWithStatements(getModelProducer(),
-// cases[i][2]);
-// content.removeAll(S, P, O);
-// Model finalContent = copy(content).remove(baseContent);
-// assertIsoModels(cases[i][1], expected, finalContent);
-// }
-// }
-//
-// protected Model copy(Model m) {
-// return getModelProducer().newModel().add(m);
-// }
-//
-// @Test
-// public void testAddLiteralByStatement() {
-// final Literal L = model.createTypedLiteral(210);
-// final Resource S = model.createResource("http://nowhere.man/subject");
-// final Statement s = model.createStatement(S, RDF.value, L);
-// Assert.assertTrue(model.add(s).contains(s));
-// Assert.assertTrue(model.contains(S, RDF.value));
-// }
-//
-//
-// @Test
-// public void testAddLiteralByte() {
-// final Resource S = model.createResource("http://nowhere.man/subject");
-// final Property P = model.createProperty("http://nowhere.man/predicate");
-// model.addLiteral(S, P, tvByte);
-// Assert.assertTrue(model.containsLiteral(S, P, tvByte));
-// }
-//
-// @Test
-// public void testAddLiteralChar() {
-// final Resource S = model.createResource("http://nowhere.man/subject");
-// final Property P = model.createProperty("http://nowhere.man/predicate");
-// model.addLiteral(S, P, tvChar);
-// Assert.assertTrue(model.containsLiteral(S, P, tvChar));
-// }
-//
-// @Test
-// public void testAddLiteralDouble() {
-// final Resource S = model.createResource("http://nowhere.man/subject");
-// final Property P = model.createProperty("http://nowhere.man/predicate");
-// model.addLiteral(S, P, tvDouble);
-// Assert.assertTrue(model.containsLiteral(S, P, tvDouble));
-// }
-//
-// @Test
-// public void testAddLiteralFloat() {
-// final Resource S = model.createResource("http://nowhere.man/subject");
-// final Property P = model.createProperty("http://nowhere.man/predicate");
-// model.addLiteral(S, P, tvFloat);
-// Assert.assertTrue(model.containsLiteral(S, P, tvFloat));
-// }
-//
-// @Test
-// public void testAddLiteralInt() {
-// final Resource S = model.createResource("http://nowhere.man/subject");
-// final Property P = model.createProperty("http://nowhere.man/predicate");
-// model.addLiteral(S, P, tvInt);
-// Assert.assertTrue(model.containsLiteral(S, P, tvInt));
-// }
-//
-//
-// @Test
-// public void testAddLiteralLong() {
-// final Resource S = model.createResource("http://nowhere.man/subject");
-// final Property P = model.createProperty("http://nowhere.man/predicate");
-// model.addLiteral(S, P, tvLong);
-// Assert.assertTrue(model.containsLiteral(S, P, tvLong));
-// }
-//
-
-// // public void testAddContainsObject()
-// // {
-// // LitTestObj O = new LitTestObj( 12345 );
-// // model.addLiteral( S, P, O );
-// // assertTrue( model.containsLiteral( S, P, O ) );
-// // }
-//
-
-//
-// @Test
-// public void testAddLiteralShort() {
-// final Resource S = model.createResource("http://nowhere.man/subject");
-// final Property P = model.createProperty("http://nowhere.man/predicate");
-// model.addLiteral(S, P, tvShort);
-// Assert.assertTrue(model.containsLiteral(S, P, tvShort));
-// }
-//
-// @Test
-// public void testAddDuplicateStatementLeavesSizeSame() {
-// final Resource S = model.createResource("http://nowhere.man/subject");
-// final Property P = model.createProperty("http://nowhere.man/predicate");
-// final Statement s = model.createStatement(S, RDF.value, "something");
-// model.add(s);
-// final long size = model.size();
-// model.add(s);
-// Assert.assertEquals(size, model.size());
-// }
-//
-// @Test
-// public void testEmpty() {
-// final Resource S = model.createResource("http://nowhere.man/subject");
-// final Property P = model.createProperty("http://nowhere.man/predicate");
-// Assert.assertTrue("Model should be empty", model.isEmpty());
-// Assert.assertFalse(model.containsLiteral(S, P, tvBoolean));
-// Assert.assertFalse(model.contains(S, P, model.createResource()));
-// Assert.assertFalse(model.containsLiteral(S, P, tvByte));
-// Assert.assertFalse(model.containsLiteral(S, P, tvShort));
-// Assert.assertFalse(model.containsLiteral(S, P, tvInt));
-// Assert.assertFalse(model.containsLiteral(S, P, tvLong));
-// Assert.assertFalse(model.containsLiteral(S, P, tvChar));
-// Assert.assertFalse(model.containsLiteral(S, P, tvFloat));
-// Assert.assertFalse(model.containsLiteral(S, P, tvDouble));
-// Assert.assertFalse(model.containsLiteral(S, P, new LitTestObj(12345)));
-// Assert.assertFalse(model.contains(S, P, "test string"));
-// Assert.assertFalse(model.contains(S, P, "test string", "en"));
-// }
-//
-// @Test
-// public void testRemoveStatementByIterator() {
-// Statement[] stmts = statements("moon orbits earth; earth orbits sun");
-// StmtIterator iter = new StmtIteratorImpl(Arrays.asList(stmts)
-// .iterator());
-// model.remove(iter);
-// for (Statement s : stmts) {
-// assertFalse(String.format("%s is still in model", s),
-// model.contains(s));
-// }
-// assertEquals(0, model.size());
-// }
-//
-// @Test
-// public void testRemoveModel() {
-// final Model model2 = getModelProducer().newModel();
-// modelAdd(model, "a P b; c P d; x Q 1; y Q 2");
-// model2.add(model).remove(model);
-// Assert.assertEquals(0, model2.size());
-// Assert.assertFalse(model2.listStatements().hasNext());
-// }
-//
-// @Test
-// public void testRemoveModelPartial() {
-// Assert.assertEquals("precondition: model must be empty", 0,
-// model.size());
-// final Model A = modelWithStatements(getModelProducer(),
-// "clouds offer rain; trees offer shelter");
-// final Model B = modelWithStatements(getModelProducer(),
-// "x R y; y Q z; z P x");
-// model.add(A);
-// assertIsoModels(A, model);
-// model.add(B);
-// model.remove(A);
-// assertIsoModels(B, model);
-// model.remove(B);
-// assertEquals(0, model.size());
-// }
-//
-// private void testContains(final boolean yes, final String facts,
-// final String resource) {
-// final Model m = modelWithStatements(getModelProducer(), facts);
-// final RDFNode r = rdfNode(resource);
-// if (m.containsResource(r) != yes) {
-// Assert.fail(String.format("[%s] should%s contain %s", facts,
-// (yes ? "" : " not"), resource));
-// }
-// }
-//
-// @Test
-// public void testContainsWithNull() {
-// testCWN(false, "", null, null, null);
-// testCWN(true, "x R y", null, null, null);
-// testCWN(false, "x R y", null, null, res("z"));
-// testCWN(true, "x RR y", res("x"), prop("RR"), null);
-// testCWN(true, "a BB c", null, prop("BB"), res("c"));
-// testCWN(false, "a BB c", null, prop("ZZ"), res("c"));
-// }
-//
-// private void testCWN(final boolean yes, final String facts,
-// final Resource S, final Property P, final RDFNode O) {
-// Model m = modelWithStatements(getModelProducer(), facts);
-// if (m.contains(S, P, O) != yes) {
-// Assert.fail(String.format("[%s] should%s contain [%s, %s, %s]",
-// facts, (yes ? "" : " not"), S, P, O));
-// }
-// Assert.assertEquals(yes, modelWithStatements(getModelProducer(), facts)
-// .contains(S, P, O));
-// }
-//
-// // FIXME move this to modelCon specific test
-// @Test
-// public void testModelComContainsSPcallsContainsSPO() {
-// final Graph g = Factory.createDefaultGraph();
-// final boolean[] wasCalled = { false };
-// // FIXME change to dynamic proxy
-// final Model m = new ModelCom(g) {
-// @Override
-// public boolean contains(final Resource s, final Property p,
-// final RDFNode o) {
-// wasCalled[0] = true;
-// return super.contains(s, p, o);
-// }
-// };
-// Assert.assertFalse(m.contains(resource("r"), property("p")));
-// Assert.assertTrue("contains(S,P) should call contains(S,P,O)",
-// wasCalled[0]);
-// }
-//
-// /**
-// * test moving things between models
-// */
-// @Test
-// public void testAddingStatementsChangesModel() {
-// final Resource S = ResourceFactory.createResource();
-// final Property P = ResourceFactory
-// .createProperty("http://example.com/property");
-// final Resource O = ResourceFactory.createResource();
-// final Model model2 = getModelProducer().newModel();
-// final Statement stmt = model.createStatement(S, P, O);
-// Assert.assertEquals(model, stmt.getModel());
-// Assert.assertEquals(0, model.size());
-// Assert.assertEquals(model, stmt.getSubject().getModel());
-// Assert.assertEquals(model, stmt.getPredicate().getModel());
-// Assert.assertEquals(model, stmt.getObject().getModel());
-// model.add(stmt);
-// Assert.assertEquals(1, model.size());
-// Assert.assertEquals(model, stmt.getSubject().getModel());
-// Assert.assertEquals(model, stmt.getPredicate().getModel());
-// Assert.assertEquals(model, stmt.getObject().getModel());
-// model2.add(stmt);
-// Assert.assertEquals(1, model.size());
-// Assert.assertEquals(model, stmt.getSubject().getModel());
-// Assert.assertEquals(model, stmt.getPredicate().getModel());
-// Assert.assertEquals(model, stmt.getObject().getModel());
-// Assert.assertEquals(1, model2.size());
-// final Statement stmt2 = model2.listStatements().next();
-// Assert.assertEquals(model2, stmt2.getSubject().getModel());
-// Assert.assertEquals(model2, stmt2.getPredicate().getModel());
-// Assert.assertEquals(model2, stmt2.getObject().getModel());
-// }
-//
-// /*
-// * try { Statement stmt; StmtIterator sIter; //
-// * System.out.println("Beginning " + test);
-// *
-// * try { n=100; Resource r11 = m1.createResource(); // Resource r12 =
-// * m2.createResource(new ResTestObjF()); long size1 = m1.size(); long size2
-// * = m2.size();
-// *
-// * r11.addLiteral(RDF.value, 1); n++; if (! (m1.size() == ++size1))
-// * error(test, n); n++; if (! (m2.size() == size2)) error(test,n);
-// *
-// * // stmt = m2.createStatement(r11, RDF.value, r12); // n++; if (!
-// * (stmt.getSubject().getModel() == m2)) error(test,n); // n++; if (!
-// * (stmt.getResource().getModel() == m2)) error(test,n); // // m1.add(stmt);
-// * // n++; if (! (m1.size() == ++size1)) error(test, n); // n++; if (!
-// * (m2.size() == size2)) error(test,n); // // sIter = m1.listStatements( new
-// * SimpleSelector( r11, RDF.value, r12 ) ); // n++; if (! sIter.hasNext())
-// * error(test, n); // n++; stmt = sIter.nextStatement(); // n++; if (!
-// * (stmt.getSubject().getModel() == m1)) error(test,n); // n++; if (!
-// * (stmt.getResource().getModel() == m1)) error(test,n); // sIter.close();
-// *
-// *
-// * } catch (Exception e) { error(test, n, e); } } catch (Exception e) {
-// * logger.error( "test " + test + "[" + n + "]", e ); errors = true; } //
-// * System.out.println("End of " + test); }
-// */
-//
-// @Test
-// public void testGetAlt() {
-// final String uri = "http://aldabaran.hpl.hp.com/rdf/test4/" + 160;
-// model.createAlt(uri);
-// final Alt a = model.getAlt(uri);
-// Assert.assertEquals(uri, a.getURI());
-// Assert.assertTrue(model.contains(a, RDF.type, RDF.Alt));
-// }
-//
-// // FIXME move to resourec factory test
-// // public void testGetResourceFactory()
-// // {
-// // String uri = "http://aldabaran.hpl.hp.com/rdf/test4/a" + 120;
-// // Resource r = model.getResource( uri, new ResTestObjF() );
-// // assertEquals( uri, r.getURI() );
-// // }
-//
-// @Test
-// public void testGetBag() {
-// final String uri = "http://aldabaran.hpl.hp.com/rdf/test4/" + 150;
-// model.createBag(uri);
-// final Bag b = model.getBag(uri);
-// Assert.assertEquals(uri, b.getURI());
-// Assert.assertTrue(model.contains(b, RDF.type, RDF.Bag));
-// }
-//
-// @Test
-// public void testGetPropertyOneArg() {
-// final String uri = "http://aldabaran.hpl.hp.com/rdf/test4/a" + 130;
-// final Property p = model.getProperty(uri);
-// Assert.assertEquals(uri, p.getURI());
-// }
-//
-// @Test
-// public void testGetPropertyTwoArgs() {
-// final String ns = "http://aldabaran.hpl.hp.com/rdf/test4/a" + 140 + "/";
-// final Property p = model.getProperty(ns, "foo");
-// Assert.assertEquals(ns + "foo", p.getURI());
-// }
-//
-// @Test
-// public void testGetSeq() {
-// final String uri = "http://aldabaran.hpl.hp.com/rdf/test4/" + 170;
-// model.createSeq(uri);
-// final Seq s = model.getSeq(uri);
-// Assert.assertEquals(uri, s.getURI());
-// Assert.assertTrue(model.contains(s, RDF.type, RDF.Seq));
-// }
-//
-// @Test
-// public void testRemoveModelWithReifications() {
-// // final Model target = getModelProducer().newModel();
-// // addReification(target, "x", "S P O");
-// // addReification(target, "y", "A P B");
-// // final Model remove = getModelProducer().newModel();
-// // addReification(remove, "y", "A P B");
-// // final Model answer = getModelProducer().newModel();
-// // addReification(answer, "x", "S P O");
-// // target.remove(remove);
-// // assertIsoModels(answer, target);
-// }
-//
-// @Test
-// public void testRemoveModelSelf() {
-// final Model m = modelWithStatements(getModelProducer(),
-// "they sing together; he sings alone");
-// m.remove(m);
-// assertEquals("", 0, m.size());
-// }
-//
-// private void testContains(final Model m, final Statement[] statements) {
-// for (final Statement statement : statements) {
-// Assert.assertTrue(String.format("%s should be here", statement),
-// m.contains(statement));
-// }
-// }
-//
-// @Test
-// public void testRemoveStatementArray() {
-// Statement[] remove = statements("moon orbits earth; earth orbits sun");
-// Statement[] keep = statements("I drink tea; you drink coffee");
-// model.add(remove).add(keep);
-// testContains(model, remove);
-// testContains(model, keep);
-//
-// model.remove(remove);
-// testOmits(model, remove);
-// testContains(model, keep);
-// }
-//
-// @Test
-// public void testCreatingStatementDoesNotAddToModel() {
-// assertEquals("Model should be empty", 0, model.size());
-// model.createStatement(resource("a"), property("b"), resource("c"));
-// assertEquals("Model should be empty", 0, model.size());
-// }
-//
-// @Test
-// public void testRemoveStatementList() {
-// Statement[] remove = statements("moon orbits earth; earth orbits sun");
-// Statement[] keep = statements("I drink tea; you drink coffee");
-// model.add(remove).add(keep);
-// testContains(model, remove);
-// testContains(model, keep);
-//
-// model.remove(Arrays.asList(remove));
-// testOmits(model, remove);
-// testContains(model, keep);
-// }
-//
-// private void testOmits(final Model m, final Statement[] statements) {
-// for (final Statement statement : statements) {
-// Assert.assertFalse("it should not be here", m.contains(statement));
-// }
-// }
-//
-// @Test
-// public void testRemoveSPOCallsGraphDeleteTriple() {
-// modelAdd(model, "a P b; c P d; x Q 1; y Q 2");
-// final List<Triple> deleted = new ArrayList<Triple>();
-// RecordingListener listener = new RecordingListener();
-// model.getGraph().getEventManager().register(listener);
-// Model model2 = model.remove(resource("c"), property("P"), rdfNode("d"));
-// listener.assertHas(new Object[] { "delete", model.getGraph(),
-// triple("c P d") });
-// Assert.assertSame(model, model2);
-// }
-//
-// private void checkNumericContent(final Container cont2, final int num) {
-// final NodeIterator nit = cont2.iterator();
-// for (int i = 0; i < num; i += 1) {
-// Assert.assertEquals(i, ((Literal) nit.nextNode()).getInt());
-// }
-// Assert.assertFalse(nit.hasNext());
-// }
-//
-// private void retainOnlySpecified(final Container cont2, final int num,
-// final boolean[] retain) {
-// final NodeIterator nit = cont2.iterator();
-// for (int i = 0; i < num; i++) {
-// nit.nextNode();
-// if (retain[i] == false) {
-// nit.remove();
-// }
-// }
-// Assert.assertFalse(nit.hasNext());
-// }
-//
-// private void seeWhatsThere(final Container cont2, final boolean[] found) {
-// final NodeIterator nit = cont2.iterator();
-// while (nit.hasNext()) {
-// final int v = ((Literal) nit.nextNode()).getInt();
-// Assert.assertFalse(found[v]);
-// found[v] = true;
-// }
-// }
-//
-// private Set<Object> setOf(final Object x) {
-// final Set<Object> result = new HashSet<Object>();
-// result.add(x);
-// return result;
-// }
-//
-// private void testContainer(final Model model, final Container cont1,
-// final Container cont2) {
-// final Literal tvLiteral = model.createLiteral("test 12 string 2");
-// // Resource tvResObj = model.createResource( new ResTestObjF() );
-// final Object tvLitObj = new LitTestObj(1234);
-// model.createBag();
-// model.createAlt();
-// model.createSeq();
-// final String lang = "en";
-// //
-// Assert.assertEquals(0, cont1.size());
-// Assert.assertEquals(0, cont2.size());
-// //
-// Assert.assertTrue(cont1.add(tvBoolean).contains(tvBoolean));
-// Assert.assertTrue(cont1.add(tvByte).contains(tvByte));
-// Assert.assertTrue(cont1.add(tvShort).contains(tvShort));
-// Assert.assertTrue(cont1.add(tvInt).contains(tvInt));
-// Assert.assertTrue(cont1.add(tvLong).contains(tvLong));
-// Assert.assertTrue(cont1.add(tvFloat).contains(tvFloat));
-// Assert.assertTrue(cont1.add(tvDouble).contains(tvDouble));
-// Assert.assertTrue(cont1.add(tvChar).contains(tvChar));
-// Assert.assertTrue(cont1.add(tvString).contains(tvString));
-// Assert.assertFalse(cont1.contains(tvString, lang));
-// Assert.assertTrue(cont1.add(tvString, lang).contains(tvString, lang));
[... 3429 lines stripped ...]