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.sail;
  
  import static org.junit.Assert.*;
  
  
  import org.junit.After;
  import org.junit.Before;
  import org.junit.Rule;
  import org.junit.Test;
  
  
A JUnit test for testing Sail implementations that store RDF data. This is purely a test for data storage and retrieval which assumes that no inferencing or whatsoever is performed. This is an abstract class that should be extended for specific Sail implementations.
  
  public abstract class RDFStoreTest {

Timeout all individual tests after 1 minute.
  
  	@Rule
  	public Timeout to = new Timeout(60000);
  
  	/*-----------*
  	 * Constants *
  	 *-----------*/
  
  	private static final String EXAMPLE_NS = "http://example.org/";
  
  	private static final String PAINTER = "Painter";
  
  	private static final String PAINTS = "paints";
  
  	private static final String PAINTING = "Painting";
  
  	private static final String PICASSO = "picasso";
  
  	private static final String REMBRANDT = "rembrandt";
  
  	private static final String GUERNICA = "guernica";
  
  	private static final String NIGHTWATCH = "nightwatch";
  
  	private static final String CONTEXT_1 = "context1";
  
  	private static final String CONTEXT_2 = "context2";
  
  	/*-----------*
 	 * Variables *
 	 *-----------*/
 
 	protected URI painter;
 
 	protected URI paints;
 
 	protected URI painting;
 
 	protected URI picasso;
 
 	protected URI rembrandt;
 
 	protected URI guernica;
 
 	protected URI nightwatch;
 
 	protected URI context1;
 
 	protected URI context2;
 
 	protected Sail sail;
 
 	protected SailConnection con;
 
 	protected ValueFactory vf;
 
 	/*--------------*
 	 * Constructors *
 	 *--------------*/
 
 	public RDFStoreTest() {
 	}
 
 	/*---------*
 	 * Methods *
 	 *---------*/

Gets an instance of the Sail that should be tested. The returned repository should already have been initialized.

Returns:
an initialized Sail.
Throws:
org.openrdf.sail.SailException If the initialization of the repository failed.
 
 	protected abstract Sail createSail()
 		throws SailException;
 
 	public void setUp()
 		throws Exception
 	{
 
 
 		// Create values
 
 
 
 	}
 
 	public void tearDown()
 		throws Exception
 	{
 		try {
 			if (.isOpen()) {
 			}
 		}
 		finally {
 			 = null;
 		}
 	}
 
 	public void testEmptyRepository()
 		throws Exception
 	{
 		// repository should be empty
 		assertEquals("Empty repository should not return any statements", 0, countAllElements());
 
 		assertEquals("Named context should be empty", 0, countContext1Elements());
 
 		assertEquals("Empty repository should not return any context identifiers", 0,
 
 		assertEquals("Empty repository should not return any query results", 0,
 				countQueryResults("select * from {S} P {O}"));
 	}
 
 	public void testValueRoundTrip1()
 		throws Exception
 	{
 		URI subj = new URIImpl( + );
 		URI pred = new URIImpl( + );
 		URI obj = new URIImpl( + );
 
 		testValueRoundTrip(subjpredobj);
 	}
 
 	public void testValueRoundTrip2()
 		throws Exception
 	{
 		BNode subj = .createBNode();
 		URI pred = new URIImpl( + );
 		URI obj = new URIImpl( + );
 
 		testValueRoundTrip(subjpredobj);
 	}
 
 	public void testValueRoundTrip3()
 		throws Exception
 	{
 		URI subj = new URIImpl( + );
 		URI pred = new URIImpl( + );
 		Literal obj = new LiteralImpl("guernica");
 
 		testValueRoundTrip(subjpredobj);
 	}
 
 	public void testValueRoundTrip4()
 		throws Exception
 	{
 		URI subj = new URIImpl( + );
 		URI pred = new URIImpl( + );
 		Literal obj = new LiteralImpl("guernica""es");
 
 		testValueRoundTrip(subjpredobj);
 	}
 
 	public void testValueRoundTrip5()
 		throws Exception
 	{
 		URI subj = new URIImpl( + );
 		URI pred = new URIImpl( + );
 		Literal obj = new NumericLiteralImpl(3);
 
 		testValueRoundTrip(subjpredobj);
 	}
 
 	public void testDecimalRoundTrip()
 		throws Exception
 	{
 		URI subj = new URIImpl( + );
 		URI pred = new URIImpl( + );
 
 		testValueRoundTrip(subjpredobj);
 	}
 
 	public void testTimeZoneRoundTrip()
 		throws Exception
 	{
 		URI subj = new URIImpl( + );
 		URI pred = new URIImpl( + );
 		Literal obj = new LiteralImpl("2006-08-23+00:00".);
 		testValueRoundTrip(subjpredobj);
 
 		.removeStatements(nullnullnull);
 
 		obj = new LiteralImpl("2006-08-23".);
 		testValueRoundTrip(subjpredobj);
 	}
 
 	public void testLongURIRoundTrip()
 		throws Exception
 	{
 		StringBuffer sb = new StringBuffer();
 		for (int i = 0; i < 512; i++) {
 			sb.append(Character.toChars('A' + (i % 26)));
 		}
 		URI subj = new URIImpl( + );
 		URI pred = new URIImpl( + );
 		URI obj = new URIImpl( +  + sb.toString());
 
 		testValueRoundTrip(subjpredobj);
 	}
 
 	public void testLongLiteralRoundTrip()
 		throws Exception
 	{
 		StringBuffer sb = new StringBuffer();
 		for (int i = 0; i < 512; i++) {
 			sb.append(Character.toChars('A' + (i % 26)));
 		}
 		URI subj = new URIImpl( + );
 		URI pred = new URIImpl( + );
 		Literal obj = new LiteralImpl("guernica" + sb.toString());
 
 		testValueRoundTrip(subjpredobj);
 	}
 
 		throws Exception
 	{
 		StringBuffer sb = new StringBuffer();
 		for (int i = 0; i < 1024000; i++) {
 			sb.append(Character.toChars('A' + (i % 26)));
 		}
 		URI subj = new URIImpl( + );
 		URI pred = new URIImpl( + );
 		Literal obj = new LiteralImpl("guernica" + sb.toString());
 
 		testValueRoundTrip(subjpredobj);
 	}
 
 	public void testLongLangRoundTrip()
 		throws Exception
 	{
 		StringBuffer sb = new StringBuffer();
 		for (int i = 0; i < 512; i++) {
 			sb.append(Character.toChars('A' + (i % 26)));
 		}
 		URI subj = new URIImpl( + );
 		URI pred = new URIImpl( + );
 		Literal obj = new LiteralImpl("guernica" + sb.toString(), "es");
 
 		testValueRoundTrip(subjpredobj);
 	}
 
 	private void testValueRoundTrip(Resource subjURI predValue obj)
 		throws Exception
 	{
 		.addStatement(subjpredobj);
 
 		CloseableIteration<? extends StatementSailExceptionstIter = .getStatements(nullnullnull,
 				false);
 
 		try {
 			assertTrue(stIter.hasNext());
 
 			Statement st = stIter.next();
 			assertEquals(subjst.getSubject());
 			assertEquals(predst.getPredicate());
 			assertEquals(objst.getObject());
 			assertTrue(!stIter.hasNext());
 		}
 		finally {
 			stIter.close();
 		}
 
 		ParsedTupleQuery tupleQuery = QueryParserUtil.parseTupleQuery(.,
 				"SELECT S, P, O FROM {S} P {O} WHERE P = <" + pred.stringValue() + ">"null);
 
 		iter = .evaluate(tupleQuery.getTupleExpr(), null, EmptyBindingSet.getInstance(), false);
 
 		try {
 
 			BindingSet bindings = iter.next();
 			assertEquals(subjbindings.getValue("S"));
 			assertEquals(predbindings.getValue("P"));
 			assertEquals(objbindings.getValue("O"));
 			assertTrue(!iter.hasNext());
 		}
 		finally {
 			iter.close();
 		}
 	}
 
 	public void testCreateURI1()
 		throws Exception
 	{
 		URI picasso1 = .createURI();
 		URI picasso2 = .createURI( + );
 
 		assertEquals("createURI(Sring) and createURI(String, String) should create equal URIs", 1, .size());
 	}
 
 	public void testCreateURI2()
 		throws Exception
 	{
 		URI picasso1 = .createURI( + );
 		URI picasso2 = .createURI();
 
 		assertEquals("createURI(Sring) and createURI(String, String) should create equal URIs", 1, .size());
 	}
 
 	public void testInvalidDateTime()
 		throws Exception
 	{
 		// SES-711
 		Literal date1 = .createLiteral("2004-12-20".);
 		Literal date2 = .createLiteral("2004-12-20".);
 		assertEquals(date1date2);
 	}
 
 	public void testSize()
 		throws Exception
 	{
 		assertEquals("Size of empty repository should be 0", 0, .size());
 
 		// Add some data to the repository
 
 		assertEquals("Size of repository should be 5", 5, .size());
 		assertEquals("Size of named context should be 3", 3, .size());
 
 		URI unknownContext = new URIImpl( + "unknown");
 
 		assertEquals("Size of unknown context should be 0", 0, .size(unknownContext));
 
 		URIImpl uriImplContext1 = new URIImpl(.toString());
 
 		assertEquals("Size of named context (defined as URIImpl) should be 3", 3, .size(uriImplContext1));
 	}
 
 	public void testAddData()
 		throws Exception
 	{
 		// Add some data to the repository
 
 		assertEquals("Repository should contain 5 statements in total", 5, countAllElements());
 
 		assertEquals("Named context should contain 3 statements", 3, countContext1Elements());
 
 		assertEquals("Repository should have 1 context identifier", 1, countElements(.getContextIDs()));
 
 		assertEquals("Repository should contain 5 statements in total", 5,
 				countQueryResults("select * from {S} P {O}"));
 
 		// Check for presence of the added statements
 		assertEquals("Statement (Painter, type, Class) should be in the repository", 1,
 				countQueryResults("select 1 from {ex:Painter} rdf:type {rdfs:Class}"));
 
 		assertEquals("Statement (picasso, type, Painter) should be in the repository", 1,
 				countQueryResults("select 1 from {ex:picasso} rdf:type {ex:Painter}"));
 
 		// Check for absense of non-added statements
 		assertEquals("Statement (Painter, paints, Painting) should not be in the repository", 0,
 				countQueryResults("select 1 from {ex:Painter} ex:paints {ex:Painting}"));
 
 		assertEquals("Statement (picasso, creates, guernica) should not be in the repository", 0,
 				countQueryResults("select 1 from {ex:picasso} ex:creates {ex:guernica}"));
 
 		// Various other checks
 		assertEquals("Repository should contain 2 statements matching (picasso, _, _)", 2,
 				countQueryResults("select * from {ex:picasso} P {O}"));
 
 		assertEquals("Repository should contain 1 statement matching (picasso, paints, _)", 1,
 				countQueryResults("select * from {ex:picasso} ex:paints {O}"));
 
 		assertEquals("Repository should contain 4 statements matching (_, type, _)", 4,
 				countQueryResults("select * from {S} rdf:type {O}"));
 
 		assertEquals("Repository should contain 2 statements matching (_, _, Class)", 2,
 				countQueryResults("select * from {S} P {rdfs:Class}"));
 
 		assertEquals("Repository should contain 0 statements matching (_, _, type)", 0,
 				countQueryResults("select * from {S} P {rdf:type}"));
 	}
 
 	public void testAddWhileQuerying()
 		throws Exception
 	{
 		// Add some data to the repository
 
 		ParsedTupleQuery tupleQuery = QueryParserUtil.parseTupleQuery(.,
 				"SELECT C FROM {} rdf:type {C}"null);
 
 		iter = .evaluate(tupleQuery.getTupleExpr(), null, EmptyBindingSet.getInstance(), false);
 
 
 		while (iter.hasNext()) {
 			BindingSet bindings = iter.next();
 			Value c = bindings.getValue("C");
 			if (c instanceof Resource) {
 			}
 		}
 
 
 
 		// simulate auto-commit
 		tupleQuery = QueryParserUtil.parseTupleQuery(."SELECT P FROM {} P {}"null);
 		iter = .evaluate(tupleQuery.getTupleExpr(), null, EmptyBindingSet.getInstance(), false);
 
 		while (iter.hasNext()) {
 			BindingSet bindings = iter.next();
 			Value p = bindings.getValue("P");
 			if (p instanceof URI) {
 			}
 		}
 
 	}
 
 	public void testRemoveAndClear()
 		throws Exception
 	{
 		// Add some data to the repository
 
 		// Test removal of statements
 
 		assertEquals("Repository should contain 4 statements in total", 4, countAllElements());
 
 		assertEquals("Named context should contain 3 statements", 3, countContext1Elements());
 
 		assertEquals("Statement (Painting, type, Class) should no longer be in the repository", 0,
 				countQueryResults("select 1 from {ex:Painting} rdf:type {rdfs:Class}"));
 
 		.removeStatements(nullnullnull);
 
 		assertEquals("Repository should contain 1 statement in total", 1, countAllElements());
 
 		assertEquals("Named context should be empty", 0, countContext1Elements());
 
 
 		assertEquals("Repository should no longer contain any statements", 0, countAllElements());
 	}
 
 	public void testClose() {
 		try {
 			fail("Operation on connection after close should result in IllegalStateException");
 		}
 		catch (IllegalStateException e) {
 			// do nothing, this is expected
 		}
 		catch (SailException e) {
 		}
 	}
 
 	public void testContexts()
 		throws Exception
 	{
 		// Add schema data to the repository, no context
 
 		// Add stuff about picasso to context1
 
 		// Add stuff about rembrandt to context2
 
 
 		assertEquals("context1 should contain 3 statements", 3, countContext1Elements());
 		assertEquals("context2 should contain 3 statements", 3,
 				countElements(.getStatements(nullnullnullfalse)));
 		assertEquals("Repository should contain 8 statements", 8, countAllElements());
 		assertEquals("statements without context should equal 2", 2,
 				countElements(.getStatements(nullnullnullfalse, (Resource)null)));
 
 		assertEquals("Statements without context and statements in context 1 together should total 5", 5,
 				countElements(.getStatements(nullnullnullfalsenull)));
 
 		assertEquals("Statements without context and statements in context 2 together should total 5", 5,
 				countElements(.getStatements(nullnullnullfalsenull)));
 
 		assertEquals("Statements in context 1 and in context 2 together should total 6", 6,
 				countElements(.getStatements(nullnullnullfalse)));
 
 		// remove two statements from context1.
 
 		assertEquals("context1 should contain 1 statements", 1, countContext1Elements());
 
 		assertEquals("Repository should contain 6 statements", 6, countAllElements());
 
 		assertEquals("Statements without context and statements in context 1 together should total 3", 3,
 				countElements(.getStatements(nullnullnullfalsenull)));
 
 		assertEquals("Statements without context and statements in context 2 together should total 5", 5,
 				countElements(.getStatements(nullnullnullfalsenull)));
 
 		assertEquals("Statements in context 1 and in context 2 together should total 4", 4,
 				countElements(.getStatements(nullnullnullfalse)));
 	}
 
 	public void testQueryBindings()
 		throws Exception
 	{
 		// Add some data to the repository
 
 		// Query 1
 		ParsedTupleQuery tupleQuery = QueryParserUtil.parseTupleQuery(.,
 				"select X from {X} rdf:type {Y} rdf:type {rdfs:Class}"null);
 		TupleExpr tupleExpr = tupleQuery.getTupleExpr();
 
 		MapBindingSet bindings = new MapBindingSet(2);
 
 		iter = .evaluate(tupleExprnullbindingsfalse);
 		int resultCount = verifyQueryResult(iter, 1);
 		assertEquals("Wrong number of query results", 2, resultCount);
 
 		bindings.addBinding("Y");
 		iter = .evaluate(tupleExprnullbindingsfalse);
 		resultCount = verifyQueryResult(iter, 1);
 		assertEquals("Wrong number of query results", 1, resultCount);
 
 		bindings.addBinding("Z");
 		iter = .evaluate(tupleExprnullbindingsfalse);
 		resultCount = verifyQueryResult(iter, 1);
 		assertEquals("Wrong number of query results", 1, resultCount);
 
 		bindings.removeBinding("Y");
 		iter = .evaluate(tupleExprnullbindingsfalse);
 		resultCount = verifyQueryResult(iter, 1);
 		assertEquals("Wrong number of query results", 2, resultCount);
 
 		// Query 2
 		tupleQuery = QueryParserUtil.parseTupleQuery(.,
 				"select X from {X} rdf:type {Y} rdf:type {rdfs:Class} where Y = Z"null);
 		tupleExpr = tupleQuery.getTupleExpr();
 		bindings.clear();
 
 		iter = .evaluate(tupleExprnullbindingsfalse);
 		resultCount = verifyQueryResult(iter, 1);
 		assertEquals("Wrong number of query results", 0, resultCount);
 
 		bindings.addBinding("Z");
 		iter = .evaluate(tupleExprnullbindingsfalse);
 		resultCount = verifyQueryResult(iter, 1);
 		assertEquals("Wrong number of query results", 1, resultCount);
 	}
 
 	public void testMultiThreadedAccess() {
 
 		Runnable runnable = new Runnable() {
 
 
 			public void run() {
 				assertTrue( != null);
 
 				try {
 					while (.isActive()) {
 						Thread.sleep(10);
 					}
 
 					// wait a bit to allow other thread to add stuff as well.
 					Thread.sleep(500L);
 							nullnulltrue);
 
 					assertTrue(result.hasNext());
 					int numberOfStatements = 0;
 					while (result.hasNext()) {
 						numberOfStatements++;
 						Statement st = result.next();
 					}
 					assertTrue("we should have retrieved statements from both threads"numberOfStatements == 2);
 
 				}
 				catch (SailException e) {
 				}
 				catch (InterruptedException e) {
 				}
 
 				// let this thread sleep so the other thread can invoke close()
 				// first.
 				try {
 					Thread.sleep(1000L);
 
 					// the connection should now be closed (by the other thread),
 					// invoking any further operation should cause a
 					// IllegalStateException
 					.getStatements(nullnullnulltrue);
 					fail("should have caused an IllegalStateException");
 				}
 				catch (InterruptedException e) {
 				}
 				catch (SailException e) {
 				}
 				catch (IllegalStateException e) {
 					// do nothing, this is the expected behaviour
 				}
 			}
 		}; // end anonymous class declaration
 
 		// execute the other thread
 		Thread newThread = new Thread(runnable"B (parallel)");
 		newThread.start();
 
 		try {
 			while (.isActive()) {
 				Thread.sleep(10);
 			}
 			// let this thread sleep to enable other thread to finish its business.
 			Thread.sleep(1000L);
 		}
 		catch (SailException e) {
 		}
 		catch (InterruptedException e) {
 		}
 	}
 
 	public void testStatementEquals()
 		throws Exception
 	{
 	}
 
 		throws Exception
 	{
 
 		out.writeObject(st);
 		out.close();
 
 		Statement deserializedStatement = (Statement)in.readObject();
 		in.close();
 
 		assertTrue(st.equals(deserializedStatement));
 	}
 
 	public void testGetNamespaces()
 		throws Exception
 	{
 
 		CloseableIteration<? extends NamespaceSailExceptionnamespaces = .getNamespaces();
 		try {
 			assertTrue(namespaces.hasNext());
 			Namespace rdf = namespaces.next();
 			assertEquals("rdf"rdf.getPrefix());
 			assertTrue(!namespaces.hasNext());
 		}
 		finally {
 			namespaces.close();
 		}
 	}
 
 	public void testGetNamespace()
 		throws Exception
 	{
 	}
 
 	public void testClearNamespaces()
 		throws Exception
 	{
 	}
 
 	public void testRemoveNamespaces()
 		throws Exception
 	{
 	}
 
 		throws Exception
 	{
 		try {
 			.setNamespace("foo"null);
 			fail("Expected NullPointerException");
 		}
 		catch (NullPointerException e) {
 			// expected
 		}
 	}
 
 	public void testNullPrefixDisallowed()
 		throws Exception
 	{
 		try {
 			.setNamespace(null"foo");
 			fail("Expected NullPointerException");
 		}
 		catch (NullPointerException e) {
 			// expected
 		}
 		try {
 			fail("Expected NullPointerException");
 		}
 		catch (NullPointerException e) {
 			// expected
 		}
 		try {
 			fail("Expected NullPointerException");
 		}
 		catch (NullPointerException e) {
 			// expected
 		}
 	}
 
 	public void testGetContextIDs()
 		throws Exception
 	{
 
 		// load data
 
 
 
 	}
 
 	public void testOldURI()
 		throws Exception
 	{
 
 
 	}
 
 	public void testDualConnections()
 		throws Exception
 	{
 		try {