Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /* 
    * Licensed to Aduna under one or more contributor license agreements.  
    * See the NOTICE.txt file distributed with this work for additional 
    * information regarding copyright ownership. 
    *
    * Aduna licenses this file to you under the terms of the Aduna BSD 
    * License (the "License"); you may not use this file except in compliance 
    * with the License. See the LICENSE.txt file distributed with this work 
    * for the full License.
   *
   * 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.openrdf.repository;
  
  import static org.hamcrest.CoreMatchers.hasItem;
  import static org.hamcrest.core.AnyOf.anyOf;
  import static org.hamcrest.core.Is.is;
  import static org.hamcrest.core.IsCollectionContaining.hasItems;
  import static org.hamcrest.core.IsEqual.equalTo;
  import static org.hamcrest.core.IsNot.not;
  import static org.hamcrest.core.IsNull.notNullValue;
  import static org.hamcrest.core.IsNull.nullValue;
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertFalse;
  import static org.junit.Assert.assertNotNull;
  import static org.junit.Assert.assertNull;
  import static org.junit.Assert.assertThat;
  import static org.junit.Assert.assertTrue;
  import static org.junit.Assert.fail;
  
  import java.io.Reader;
  import java.util.Arrays;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  
  import org.junit.After;
  import org.junit.Before;
  import org.junit.Ignore;
  import org.junit.Rule;
  import org.junit.Test;
  
  
 
 public abstract class RepositoryConnectionTest {

Timeout all individual tests after 1 minute.
 
 	public Timeout to = new Timeout(60000);
 
 	private static final String URN_TEST_OTHER = "urn:test:other";
 
 	private static final String SPARQL_DEL_ALL = "DELETE { ?s ?p ?o } WHERE { ?s ?p ?o }";
 
 	private static final String URN_TEST_O1 = "urn:test:o1";
 
 	private static final String URN_TEST_S1 = "urn:test:s1";
 
 	private static final String URN_TEST_P2 = "urn:test:p2";
 
 	private static final String URN_TEST_P1 = "urn:test:p1";
 
 	private static final String URN_PRED = "urn:pred";
 
 	private static final String RDF_PREFIX = "rdf";
 
 	private static final String RDFS_NS = "http://www.w3.org/2000/01/rdf-schema#";
 
 	private static final String RDFS_PREFIX = "rdfs";
 
 	private static final String EXAMPLE_NS = "http://example.org/";
 
 	private static final String EXAMPLE = "example";
 
 	private static final String ASK = "ASK ";
 
 	private static final String PREFIX_FOAF = "PREFIX foaf: <";
 
 	private static final String PERSON = "person";
 
 	private static final String UNEXPECTED_TYPE = "unexpected query object type: ";
 
 	private static final String UNSUPPORTED_OP = "unsupported operation: ";
 
 	private static final String NEWLY_ADDED = "Repository should contain newly added statement";
 
 	private static final String MBOX = "mbox";
 
 	private static final String NAME = "name";
 
 	protected static final String FOAF_NS = "http://xmlns.com/foaf/0.1/";
 
 	public static final String TEST_DIR_PREFIX = "/testcases/";
 
 
 
 
 	protected ValueFactory vf;
 
 	protected Resource bob;
 
 	protected Resource alice;
 
 	protected Resource alexander;
 
 	protected URI name;
 
 	protected URI mbox;
 
 	protected final URI publisher = .;
 
 	protected URI unknownContext;
 
 	protected URI context1;
 
 	protected URI context2;
 
 	protected Literal nameAlice;
 
 	protected Literal nameBob;
 
 	protected Literal mboxAlice;
 
 	protected Literal mboxBob;
 
 
 	public void setUp()
 		throws Exception
 	{
 
 
 
 
 		// Initialize values
 
 
 		 = .createLiteral("Alice");
 		 = .createLiteral("Bob");
 
 		 = .createLiteral("alice@example.org");
 		 = .createLiteral("bob@example.org");
 
 		 = .createLiteral("Александър");
 
 		 = new URIImpl("urn:unknownContext");
 
 		 = .createURI("urn:x-local:graph1");
 		 = .createURI("urn:x-local:graph2");
 	}
 
 	public void tearDown()
 		throws Exception
 	{
 	}

Gets an (uninitialized) instance of the repository that should be tested.

Returns:
an uninitialized repository.
 
 	protected abstract Repository createRepository()
 		throws Exception;
 
 	public void testAddStatement()
 		throws Exception
 	{
 
 
 		.add(statement);
 
 		assertTrue(.hasStatement(statementfalse));
 
 		Repository tempRep = new SailRepository(new MemoryStore());
 		tempRep.initialize();
 		RepositoryConnection con = tempRep.getConnection();
 
 		con.add(.getStatements(nullnullnullfalse));
 
 		assertTrue("Temp Repository should contain newly added statement",
 				con.hasStatement(false));
 		con.close();
 		tempRep.shutDown();
 	}
 
 	public void testAddLiteralWithNewline()
 		throws Exception
 	{
 		Literal test = .createLiteral("this is a test\n");
 		.add(.test);
 
 	}
 
 	public void testTransactionIsolation()
 		throws Exception
 	{
 	}
 
 	public void testAddReader()
 		throws Exception
 	{
 		Reader defaultGraph = new InputStreamReader(
 				"UTF-8");
 		.add(defaultGraph"".);
 		defaultGraph.close();
 
 		// add file graph1.ttl to context1
 				+ "graph1.ttl");
 		Reader graph1 = new InputStreamReader(graph1Stream"UTF-8");
 		.add(graph1"".);
 		graph1.close();
 
 		// add file graph2.ttl to context2
 				+ "graph2.ttl");
 		Reader graph2 = new InputStreamReader(graph2Stream"UTF-8");
 		.add(graph2"".);
 		graph2.close();
 		assertTrue("alice should be known in the store".hasStatement(nullfalse));
 		assertFalse("alice should not be known in context1",
 				.hasStatement(nullfalse));
 		assertTrue("alice should be known in context2",
 				.hasStatement(nullfalse));
 		assertTrue("bob should be known in the store".hasStatement(nullfalse));
 		assertFalse("bob should not be known in context2",
 				.hasStatement(nullfalse));
 		assertTrue("bib should be known in context1",
 				.hasStatement(nullfalse));
 	}
 
 	public void testAddInputStream()
 		throws Exception
 	{
 		// add file default-graph.ttl to repository, no context
 				+ "default-graph.ttl");
 		.add(defaultGraph"".);
 		defaultGraph.close();
 
 		// add file graph1.ttl to context1
 		.add(graph1"".);
 		graph1.close();
 
 		// add file graph2.ttl to context2
 		.add(graph2"".);
 		graph2.close();
 		assertTrue("alice should be known in the store".hasStatement(nullfalse));
 		assertFalse("alice should not be known in context1",
 				.hasStatement(nullfalse));
 		assertTrue("alice should be known in context2",
 				.hasStatement(nullfalse));
 		assertTrue("bob should be known in the store".hasStatement(nullfalse));
 		assertFalse("bob should not be known in context2",
 				.hasStatement(nullfalse));
 		assertTrue("bib should be known in context1",
 				.hasStatement(nullfalse));
 	}
 
 	public void testAddGzipInputStream()
 		throws Exception
 	{
 		// add file default-graph.ttl to repository, no context
 				+ "default-graph.ttl.gz");
 		try {
 			.add(defaultGraph"".);
 		}
 		finally {
 			defaultGraph.close();
 		}
 
 
 	}
 
 	public void testAddZipFile()
 		throws Exception
 	{
 		assertTrue("alice should be known in the store".hasStatement(nullfalse));
 		assertTrue("bob should be known in the store".hasStatement(nullfalse));
 	}
 
 		throws Exception
 	{
 		try {
 					RepositoryConnectionTest.class.getResourceAsStream( + "malformed-literals.ttl"),
 			fail("upload of malformed literals should fail with error in default configuration");
 		}
 		catch (RDFParseException e) {
 			// ignore, as expected
 		}
 	}
 
 		throws Exception
 	{
 		Set<RioSetting<?>> empty = Collections.emptySet();
 
 		try {
 					RepositoryConnectionTest.class.getResourceAsStream( + "malformed-literals.ttl"),
 			fail("upload of malformed literals should fail with error in strict configuration");
 
 		}
 		catch (RDFParseException e) {
 			// ingnore, as expected.
 		}
 	}
 
 	public void testAutoCommit()
 		throws Exception
 	{
 
 		assertTrue("Uncommitted update should be visible to own connection",
 
 
 		assertTrue("Repository should contain statement after commit",
 	}
 
 	public void testRollback()
 		throws Exception
 	{
 
 		assertTrue("Uncommitted updates should be visible to own connection",
 
 
 		assertFalse("Repository should not contain statement after rollback",
 	}
 
 	public void testSimpleTupleQuery()
 		throws Exception
 	{
 		StringBuilder queryBuilder = new StringBuilder(128);
 		queryBuilder.append(" SELECT name, mbox");
 		queryBuilder.append(" FROM {} foaf:name {name};");
 		queryBuilder.append("         foaf:mbox {mbox}");
 		queryBuilder.append(" USING NAMESPACE foaf = <" +  + ">");
 		try {
 			assertThat(resultis(notNullValue()));
 			assertThat(result.hasNext(), is(equalTo(true)));
 			while (result.hasNext()) {
 				BindingSet solution = result.next();
 				assertThat(solution.hasBinding(), is(equalTo(true)));
 				assertThat(solution.hasBinding(), is(equalTo(true)));
 				Value nameResult = solution.getValue();
 				Value mboxResult = solution.getValue();
 			}
 		}
 		finally {
 			result.close();
 		}
 	}
 
 	public void testPrepareSeRQLQuery()
 		throws Exception
 	{
 
 		StringBuilder queryBuilder = new StringBuilder();
 		queryBuilder.append(" SELECT person");
 		queryBuilder.append(" FROM {person} foaf:name {").append(.getLabel()).append("}");
 		queryBuilder.append(" USING NAMESPACE foaf = <" +  + ">");
 
 		try {
 		}
 		}
 		catch (ClassCastException e) {
 		}
 
 		queryBuilder = new StringBuilder();
 		queryBuilder.append(" (SELECT person");
 		queryBuilder.append(" FROM {person} foaf:name {").append(.getLabel()).append("}");
 		queryBuilder.append(") UNION ");
 		queryBuilder.append("(SELECT x FROM {x} p {y} )");
 		queryBuilder.append(" USING NAMESPACE foaf = <" +  + ">");
 
 		try {
 		}
 		}
 		catch (ClassCastException e) {
 		}
 	}
 
 	public void testPrepareSPARQLQuery()
 		throws Exception
 	{
 
 		StringBuilder queryBuilder = new StringBuilder();
 		queryBuilder.append(" PREFIX foaf: <" +  + ">");
 		queryBuilder.append(" SELECT ?person");
 		queryBuilder.append(" WHERE { ?person foaf:name ?y . }");
 
 		try {
 		}
 		}
 		catch (ClassCastException e) {
 		}
 
 		queryBuilder = new StringBuilder();
 		queryBuilder.append(" BASE <http://base.uri>");
 		queryBuilder.append(" PREFIX foaf: <" +  + ">");
 		queryBuilder.append(" PREFIX ex: <http://example.org/>");
 		queryBuilder.append(" PREFIX : <http://example.org/foo#>");
 		queryBuilder.append(" SELECT ?person");
 		queryBuilder.append(" WHERE { ?person foaf:name ?y . }");
 
 		try {
 		}
 		}
 		catch (ClassCastException e) {
 		}
 	}
 
 		throws Exception
 	{
 		StringBuilder queryBuilder = new StringBuilder(128);
 		queryBuilder.append(" SELECT person");
 		queryBuilder.append(" FROM {person} foaf:name {").append(.getLabel()).append("}");
 		queryBuilder.append(" USING NAMESPACE foaf = <" +  + ">");
 		try {
 			assertThat(resultis(notNullValue()));
 			assertThat(result.hasNext(), is(equalTo(true)));
 			while (result.hasNext()) {
 				BindingSet solution = result.next();
 				assertThat(solution.hasBinding(), is(equalTo(true)));
 			}
 		}
 		finally {
 			result.close();
 		}
 	}
 
 	public void testPreparedTupleQuery()
 		throws Exception
 	{
 		StringBuilder queryBuilder = new StringBuilder();
 		queryBuilder.append(" SELECT name, mbox");
 		queryBuilder.append(" FROM {} foaf:name {name};");
 		queryBuilder.append("         foaf:mbox {mbox}");
 		queryBuilder.append(" USING NAMESPACE foaf = <" +  + ">");
 		TupleQueryResult result = query.evaluate();
 		try {
 			assertThat(resultis(notNullValue()));
 			assertThat(result.hasNext(), is(equalTo(true)));
 			while (result.hasNext()) {
 				BindingSet solution = result.next();
 				assertThat(solution.hasBinding(), is(equalTo(true)));
 				assertThat(solution.hasBinding(), is(equalTo(true)));
 				Value nameResult = solution.getValue();
 				Value mboxResult = solution.getValue();
 				assertEquals("unexpected value for name: " + nameResultnameResult);
 				assertEquals("unexpected value for mbox: " + mboxResultmboxResult);
 			}
 		}
 		finally {
 			result.close();
 		}
 	}
 
 	public void testPreparedTupleQuery2()
 		throws Exception
 	{
 		StringBuilder queryBuilder = new StringBuilder();
 		queryBuilder.append(" SELECT name, mbox");
 		queryBuilder.append(" FROM {p} foaf:name {name};");
 		queryBuilder.append("         foaf:mbox {mbox}");
 		queryBuilder.append(" WHERE p = VAR");
 		queryBuilder.append(" USING NAMESPACE foaf = <" +  + ">");
 		query.setBinding("VAR");
 		TupleQueryResult result = query.evaluate();
 		try {
 			assertThat(resultis(notNullValue()));
 			assertThat(result.hasNext(), is(equalTo(true)));
 			while (result.hasNext()) {
 				BindingSet solution = result.next();
 				assertThat(solution.hasBinding(), is(equalTo(true)));
 				assertThat(solution.hasBinding(), is(equalTo(true)));
 				Value nameResult = solution.getValue();
 				Value mboxResult = solution.getValue();
 				assertEquals("unexpected value for name: " + nameResultnameResult);
 				assertEquals("unexpected value for mbox: " + mboxResultmboxResult);
 			}
 		}
 		finally {
 			result.close();
 		}
 	}
 
 		throws Exception
 	{
 
 		StringBuilder queryBuilder = new StringBuilder();
 		queryBuilder.append(" SELECT person");
 		queryBuilder.append(" FROM {person} foaf:name {name}");
 		queryBuilder.append(" USING NAMESPACE foaf = <" +  + ">");
 
 
 		TupleQueryResult result = query.evaluate();
 
 		try {
 			assertThat(resultis(notNullValue()));
 			assertThat(result.hasNext(), is(equalTo(true)));
 
 			while (result.hasNext()) {
 				BindingSet solution = result.next();
 				assertThat(solution.hasBinding(), is(equalTo(true)));
 			}
 		}
 		finally {
 			result.close();
 		}
 	}
 
 	public void testSimpleGraphQuery()
 		throws Exception
 	{
 
 
 		StringBuilder queryBuilder = new StringBuilder(128);
 		queryBuilder.append(" CONSTRUCT *");
 		queryBuilder.append(" FROM {} foaf:name {name};");
 		queryBuilder.append("         foaf:mbox {mbox}");
 		queryBuilder.append(" USING NAMESPACE foaf = <" +  + ">");
 
 
 		try {
 			assertThat(resultis(notNullValue()));
 			assertThat(result.hasNext(), is(equalTo(true)));
 
 			while (result.hasNext()) {
 				Statement st = result.next();
 				if (.equals(st.getPredicate())) {
 				}
 				else {
 				}
 			}
 		}
 		finally {
 			result.close();
 		}
 	}
 
 	public void testPreparedGraphQuery()
 		throws Exception
 	{
 		StringBuilder queryBuilder = new StringBuilder(128);
 		queryBuilder.append(" CONSTRUCT *");
 		queryBuilder.append(" FROM {} foaf:name {name};");
 		queryBuilder.append("         foaf:mbox {mbox}");
 		queryBuilder.append(" USING NAMESPACE foaf = <" +  + ">");
 		GraphQueryResult result = query.evaluate();
 		try {
 			assertThat(resultis(notNullValue()));
 			assertThat(result.hasNext(), is(equalTo(true)));
 			while (result.hasNext()) {
 				Statement st = result.next();
 				URI predicate = st.getPredicate();
 				assertThat(predicateanyOf(is(equalTo()), is(equalTo())));
 				Value object = st.getObject();
 				if (.equals(predicate)) {
 					assertEquals("unexpected value for name: " + objectobject);
 				}
 				else {
 					assertThat(predicateis(equalTo()));
 					assertEquals("unexpected value for mbox: " + objectobject);
 				}
 			}
 		}
 		finally {
 			result.close();
 		}
 	}
 
 	public void testSimpleBooleanQuery()
 		throws Exception
 	{
 
 
 		StringBuilder queryBuilder = new StringBuilder(64);
 		queryBuilder.append( +  + "> ");
 		queryBuilder.append();
 		queryBuilder.append("{ ?p foaf:name ?name }");
 
 		boolean exists = .prepareBooleanQuery(.queryBuilder.toString()).evaluate();
 
 		assertThat(existsis(equalTo(true)));
 	}
 
 	public void testPreparedBooleanQuery()
 		throws Exception
 	{
 
 
 		StringBuilder queryBuilder = new StringBuilder();
 		queryBuilder.append( +  + "> ");
 		queryBuilder.append();
 		queryBuilder.append("{ ?p foaf:name ?name }");
 
 
 		assertThat(query.evaluate(), is(equalTo(true)));
 	}
 
 	public void testDataset()
 		throws Exception
 	{
 		StringBuilder queryBuilder = new StringBuilder();
 		queryBuilder.append( +  + "> ");
 		queryBuilder.append();
 		queryBuilder.append("{ ?p foaf:name ?name }");
 		assertThat(query.evaluate(), is(equalTo(true)));
 		DatasetImpl dataset = new DatasetImpl();
 
 		// default graph: {context1}
 		query.setDataset(dataset);
 		assertThat(query.evaluate(), is(equalTo(true)));
 
 		// default graph: {context1, context2}
 		query.setDataset(dataset);
 		assertThat(query.evaluate(), is(equalTo(true)));
 
 		// default graph: {context2}
 		query.setDataset(dataset);
 		assertThat(query.evaluate(), is(equalTo(false)));
 		queryBuilder.setLength(0);
 		queryBuilder.append( +  + "> ");
 		queryBuilder.append();
 		queryBuilder.append("{ GRAPH ?g { ?p foaf:name ?name } }");
 
 		// default graph: {context2}; named graph: {}
 		query.setDataset(dataset);
 		assertThat(query.evaluate(), is(equalTo(false)));
 
 		// default graph: {context1, context2}; named graph: {context2}
 		query.setDataset(dataset);
 		assertThat(query.evaluate(), is(equalTo(false)));
 
 		// default graph: {context1, context2}; named graph: {context1, context2}
 		query.setDataset(dataset);
 		assertThat(query.evaluate(), is(equalTo(true)));
 	}
 
 	public void testGetStatements()
 		throws Exception
 	{
 
 		assertTrue("Repository should contain statement".hasStatement(false));
 
 		RepositoryResult<Statementresult = .getStatements(nullnullfalse);