Return-Path: X-Original-To: apmail-jena-commits-archive@www.apache.org Delivered-To: apmail-jena-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 1D2E910417 for ; Tue, 27 Aug 2013 06:01:36 +0000 (UTC) Received: (qmail 16058 invoked by uid 500); 27 Aug 2013 06:01:35 -0000 Delivered-To: apmail-jena-commits-archive@jena.apache.org Received: (qmail 16028 invoked by uid 500); 27 Aug 2013 06:01:31 -0000 Mailing-List: contact commits-help@jena.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@jena.apache.org Delivered-To: mailing list commits@jena.apache.org Received: (qmail 16020 invoked by uid 99); 27 Aug 2013 06:01:29 -0000 Received: from athena.apache.org (HELO athena.apache.org) (140.211.11.136) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 27 Aug 2013 06:01:29 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=5.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 27 Aug 2013 06:01:24 +0000 Received: from eris.apache.org (localhost [127.0.0.1]) by eris.apache.org (Postfix) with ESMTP id CA6782388AA9; Tue, 27 Aug 2013 06:01:03 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1517755 [1/2] - in /jena/Experimental/new-test: ./ .settings/ src/ src/test/ src/test/java/ src/test/java/com/ src/test/java/com/hp/ src/test/java/com/hp/hpl/ src/test/java/com/hp/hpl/jena/ src/test/java/com/hp/hpl/jena/graph/ src/test/jav... Date: Tue, 27 Aug 2013 06:01:02 -0000 To: commits@jena.apache.org From: claude@apache.org X-Mailer: svnmailer-1.0.9 Message-Id: <20130827060103.CA6782388AA9@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Author: claude Date: Tue Aug 27 06:01:01 2013 New Revision: 1517755 URL: http://svn.apache.org/r1517755 Log: Initial checkin of JENA-380 Added: jena/Experimental/new-test/.classpath (with props) jena/Experimental/new-test/.project (with props) jena/Experimental/new-test/.settings/ jena/Experimental/new-test/.settings/org.eclipse.core.resources.prefs (with props) jena/Experimental/new-test/.settings/org.eclipse.jdt.core.prefs (with props) jena/Experimental/new-test/.settings/org.eclipse.m2e.core.prefs (with props) jena/Experimental/new-test/pom.xml (with props) jena/Experimental/new-test/src/ jena/Experimental/new-test/src/test/ jena/Experimental/new-test/src/test/java/ jena/Experimental/new-test/src/test/java/com/ jena/Experimental/new-test/src/test/java/com/hp/ jena/Experimental/new-test/src/test/java/com/hp/hpl/ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/AbstractGraphTest.java (with props) jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/GraphProducerInterface.java (with props) jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/GraphTestUtils.java (with props) jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/MemGraphTest.java (with props) jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/NodeCreateUtils.java (with props) jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/RecordingListener.java (with props) jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/impl/ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/impl/TestCollectionGraph.java (with props) jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/test/ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/test/TestUtils.java (with props) jena/Experimental/new-test/src/test/resources/ jena/Experimental/new-test/src/test/resources/com/ jena/Experimental/new-test/src/test/resources/com/hp/ jena/Experimental/new-test/src/test/resources/com/hp/hpl/ jena/Experimental/new-test/src/test/resources/com/hp/hpl/jena/ jena/Experimental/new-test/src/test/resources/com/hp/hpl/jena/graph/ jena/Experimental/new-test/src/test/resources/regression/ jena/Experimental/new-test/src/test/resources/regression/testModelEquals/ jena/Experimental/new-test/src/test/resources/regression/testModelEquals/1-1.rdf jena/Experimental/new-test/src/test/resources/regression/testModelEquals/1-2.rdf jena/Experimental/new-test/src/test/resources/regression/testModelEquals/2-1.rdf jena/Experimental/new-test/src/test/resources/regression/testModelEquals/2-2.rdf jena/Experimental/new-test/src/test/resources/regression/testModelEquals/3-1.rdf jena/Experimental/new-test/src/test/resources/regression/testModelEquals/3-2.rdf jena/Experimental/new-test/src/test/resources/regression/testModelEquals/4-1.rdf jena/Experimental/new-test/src/test/resources/regression/testModelEquals/4-2.rdf jena/Experimental/new-test/src/test/resources/regression/testModelEquals/5-1.rdf jena/Experimental/new-test/src/test/resources/regression/testModelEquals/5-2.rdf jena/Experimental/new-test/src/test/resources/regression/testModelEquals/6-1.rdf jena/Experimental/new-test/src/test/resources/regression/testModelEquals/6-2.rdf jena/Experimental/new-test/src/test/resources/regression/testModelEquals/7-1.nt jena/Experimental/new-test/src/test/resources/regression/testModelEquals/7-2.nt jena/Experimental/new-test/src/test/resources/regression/testModelEquals/8-1.nt jena/Experimental/new-test/src/test/resources/regression/testModelEquals/8-2.nt jena/Experimental/new-test/src/test/resources/regression/testModelEquals/README_LICENSE Added: jena/Experimental/new-test/.classpath URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/.classpath?rev=1517755&view=auto ============================================================================== --- jena/Experimental/new-test/.classpath (added) +++ jena/Experimental/new-test/.classpath Tue Aug 27 06:01:01 2013 @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + Propchange: jena/Experimental/new-test/.classpath ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: jena/Experimental/new-test/.project URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/.project?rev=1517755&view=auto ============================================================================== --- jena/Experimental/new-test/.project (added) +++ jena/Experimental/new-test/.project Tue Aug 27 06:01:01 2013 @@ -0,0 +1,23 @@ + + + new-test + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.jdt.core.javanature + org.eclipse.m2e.core.maven2Nature + + Propchange: jena/Experimental/new-test/.project ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: jena/Experimental/new-test/.settings/org.eclipse.core.resources.prefs URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/.settings/org.eclipse.core.resources.prefs?rev=1517755&view=auto ============================================================================== --- jena/Experimental/new-test/.settings/org.eclipse.core.resources.prefs (added) +++ jena/Experimental/new-test/.settings/org.eclipse.core.resources.prefs Tue Aug 27 06:01:01 2013 @@ -0,0 +1,3 @@ +eclipse.preferences.version=1 +encoding//src/test/java=UTF-8 +encoding/=UTF-8 Propchange: jena/Experimental/new-test/.settings/org.eclipse.core.resources.prefs ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: jena/Experimental/new-test/.settings/org.eclipse.jdt.core.prefs URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/.settings/org.eclipse.jdt.core.prefs?rev=1517755&view=auto ============================================================================== --- jena/Experimental/new-test/.settings/org.eclipse.jdt.core.prefs (added) +++ jena/Experimental/new-test/.settings/org.eclipse.jdt.core.prefs Tue Aug 27 06:01:01 2013 @@ -0,0 +1,5 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 +org.eclipse.jdt.core.compiler.compliance=1.6 +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.source=1.6 Propchange: jena/Experimental/new-test/.settings/org.eclipse.jdt.core.prefs ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: jena/Experimental/new-test/.settings/org.eclipse.m2e.core.prefs URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/.settings/org.eclipse.m2e.core.prefs?rev=1517755&view=auto ============================================================================== --- jena/Experimental/new-test/.settings/org.eclipse.m2e.core.prefs (added) +++ jena/Experimental/new-test/.settings/org.eclipse.m2e.core.prefs Tue Aug 27 06:01:01 2013 @@ -0,0 +1,4 @@ +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 Propchange: jena/Experimental/new-test/.settings/org.eclipse.m2e.core.prefs ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: jena/Experimental/new-test/pom.xml URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/pom.xml?rev=1517755&view=auto ============================================================================== --- jena/Experimental/new-test/pom.xml (added) +++ jena/Experimental/new-test/pom.xml Tue Aug 27 06:01:01 2013 @@ -0,0 +1,26 @@ + + 4.0.0 + org.apache.jena + new-test + 2.10.2-SNAPSHOT + new Jena tests + New test suite for Jena project. This is a complete rewrite of the existing tests + + org.apache.jena + jena-parent + 7-SNAPSHOT + + + + junit + junit + ${ver.junit} + + + org.apache.jena + apache-jena-libs + ${version} + pom + + + \ No newline at end of file Propchange: jena/Experimental/new-test/pom.xml ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/AbstractGraphTest.java URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/AbstractGraphTest.java?rev=1517755&view=auto ============================================================================== --- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/AbstractGraphTest.java (added) +++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/AbstractGraphTest.java Tue Aug 27 06:01:01 2013 @@ -0,0 +1,1092 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.hp.hpl.jena.graph; + +import java.io.InputStream ; +import java.net.MalformedURLException ; +import java.net.URISyntaxException ; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Set; + +import org.junit.Test; + +import com.hp.hpl.jena.graph.Capabilities; +import com.hp.hpl.jena.graph.Factory; +import com.hp.hpl.jena.graph.Graph; +import com.hp.hpl.jena.graph.GraphEventManager; +import com.hp.hpl.jena.graph.GraphEvents; +import com.hp.hpl.jena.graph.GraphListener; +import com.hp.hpl.jena.graph.GraphStatisticsHandler; +import com.hp.hpl.jena.graph.GraphUtil; +import com.hp.hpl.jena.graph.Node; +import com.hp.hpl.jena.graph.TransactionHandler; +import com.hp.hpl.jena.graph.Triple; +import com.hp.hpl.jena.mem.TrackingTripleIterator ; +import com.hp.hpl.jena.rdf.model.Model ; +import com.hp.hpl.jena.rdf.model.ModelFactory ; +import com.hp.hpl.jena.rdf.model.impl.ReifierStd ; +import com.hp.hpl.jena.shared.Command ; +import com.hp.hpl.jena.shared.JenaException ; +import com.hp.hpl.jena.util.CollectionFactory ; +import com.hp.hpl.jena.util.iterator.ClosableIterator ; +import com.hp.hpl.jena.util.iterator.ExtendedIterator ; +import static com.hp.hpl.jena.graph.GraphTestUtils.*; +import static org.junit.Assert.*; + +/** + AbstractTestGraph provides a bunch of basic tests for something that + purports to be a Graph. The abstract method getGraph must be overridden + in subclasses to deliver a Graph of interest. + */ +public abstract class AbstractGraphTest +{ + private GraphProducerInterface graphProducer; + + protected AbstractGraphTest( GraphProducerInterface graphProducer ) + { + this.graphProducer = graphProducer; + } + + protected Graph getGraph() + { + return graphProducer.newGraph(); + } + + public Graph getGraphWith( String facts ) + { + Graph g = getGraph(); + graphAdd( g, facts ); + return g; + } + + @Test + public void testCloseSetsIsClosed() + { + Graph g = getGraph(); + assertFalse( "unclosed Graph shouild not be isClosed()", g.isClosed() ); + g.close(); + assertTrue( "closed Graph should be isClosed()", g.isClosed() ); + } + + /** + This test case was generated by Ian and was caused by GraphMem + not keeping up with changes to the find interface. + */ + @Test + public void testFindAndContains() + { + Graph g = getGraph(); + Node r = NodeCreateUtils.create( "r" ), s = NodeCreateUtils.create( "s" ), p = NodeCreateUtils.create( "P" ); + g.add( Triple.create( r, p, s ) ); + assertTrue( g.contains( r, p, Node.ANY ) ); + assertEquals( 1, g.find( r, p, Node.ANY ).toList().size() ); + } + + @Test + public void testRepeatedSubjectDoesNotConceal() + { + Graph g = getGraphWith( "s P o; s Q r" ); + assertTrue( g.contains( triple( "s P o" ) ) ); + assertTrue( g.contains( triple( "s Q r" ) ) ); + assertTrue( g.contains( triple( "?? P o" ) ) ); + assertTrue( g.contains( triple( "?? Q r" ) ) ); + assertTrue( g.contains( triple( "?? P ??" ) ) ); + assertTrue( g.contains( triple( "?? Q ??" ) ) ); + } + + @Test + public void testFindByFluidTriple() + { + Graph g = getGraphWith( "x y z " ); + Set expect = tripleSet( "x y z" ); + assertEquals( expect, g.find( triple( "?? y z" ) ).toSet() ); + assertEquals( expect, g.find( triple( "x ?? z" ) ).toSet() ); + assertEquals( expect, g.find( triple( "x y ??" ) ).toSet() ); + } + + @Test + public void testContainsConcrete() + { + Graph g = getGraphWith( "s P o; _x _R _y; x S 0" ); + assertTrue( g.contains( triple( "s P o" ) ) ); + assertTrue( g.contains( triple( "_x _R _y" ) ) ); + assertTrue( g.contains( triple( "x S 0" ) ) ); + /* */ + assertFalse( g.contains( triple( "s P Oh" ) ) ); + assertFalse( g.contains( triple( "S P O" ) ) ); + assertFalse( g.contains( triple( "s p o" ) ) ); + assertFalse( g.contains( triple( "_x _r _y" ) ) ); + assertFalse( g.contains( triple( "x S 1" ) ) ); + } + + @Test + public void testContainsFluid() + { + Graph g = getGraphWith( "x R y; a P b" ); + assertTrue( g.contains( triple( "?? R y" ) ) ); + assertTrue( g.contains( triple( "x ?? y" ) ) ); + assertTrue( g.contains( triple( "x R ??" ) ) ); + assertTrue( g.contains( triple( "?? P b" ) ) ); + assertTrue( g.contains( triple( "a ?? b" ) ) ); + assertTrue( g.contains( triple( "a P ??" ) ) ); + assertTrue( g.contains( triple( "?? R y" ) ) ); + /* */ + assertFalse( g.contains( triple( "?? R b" ) ) ); + assertFalse( g.contains( triple( "a ?? y" ) ) ); + assertFalse( g.contains( triple( "x P ??" ) ) ); + assertFalse( g.contains( triple( "?? R x" ) ) ); + assertFalse( g.contains( triple( "x ?? R" ) ) ); + assertFalse( g.contains( triple( "a S ??" ) ) ); + } + + /** + Check that contains respects by-value semantics. + */ + @Test + public void testContainsByValue() + { + if (getGraph().getCapabilities().handlesLiteralTyping()) + { + Graph g1 = getGraphWith( "x P '1'xsd:integer" ); + assertTrue( g1.contains( triple( "x P '01'xsd:int" ) ) ); + // + Graph g2 = getGraphWith( "x P '1'xsd:int" ); + assertTrue( g2.contains( triple( "x P '1'xsd:integer" ) ) ); + // + Graph g3 = getGraphWith( "x P '123'xsd:string" ); + assertTrue( g3.contains( triple( "x P '123'" ) ) ); + } + } + + @Test + public void testMatchLanguagedLiteralCaseInsensitive() + { + Graph m = graphWith( "a p 'chat'en" ); + if (m.getCapabilities().handlesLiteralTyping()) + { + Node chaten = node( "'chat'en" ), chatEN = node( "'chat'EN" ); + assertDiffer( chaten, chatEN ); + assertTrue( chaten.sameValueAs( chatEN ) ); + assertEquals( chaten.getIndexingValue(), chatEN.getIndexingValue() ); + assertEquals( 1, m.find( Node.ANY, Node.ANY, chaten ).toList().size() ); + assertEquals( 1, m.find( Node.ANY, Node.ANY, chatEN ).toList().size() ); + } + } + + @Test + public void testMatchBothLanguagedLiteralsCaseInsensitive() + { + Graph m = graphWith( "a p 'chat'en; a p 'chat'EN" ); + if (m.getCapabilities().handlesLiteralTyping()) + { + Node chaten = node( "'chat'en" ), chatEN = node( "'chat'EN" ); + assertDiffer( chaten, chatEN ); + assertTrue( chaten.sameValueAs( chatEN ) ); + assertEquals( chaten.getIndexingValue(), chatEN.getIndexingValue() ); + assertEquals( 2, m.find( Node.ANY, Node.ANY, chaten ).toList().size() ); + assertEquals( 2, m.find( Node.ANY, Node.ANY, chatEN ).toList().size() ); + } + } + + @Test + public void testNoMatchAgainstUnlanguagesLiteral() + { + Graph m = graphWith( "a p 'chat'en; a p 'chat'" ); + if (m.getCapabilities().handlesLiteralTyping()) + { + Node chaten = node( "'chat'en" ), chatEN = node( "'chat'EN" ); + assertDiffer( chaten, chatEN ); + assertTrue( chaten.sameValueAs( chatEN ) ); + assertEquals( chaten.getIndexingValue(), chatEN.getIndexingValue() ); + assertEquals( 1, m.find( Node.ANY, Node.ANY, chaten ).toList().size() ); + assertEquals( 1, m.find( Node.ANY, Node.ANY, chatEN ).toList().size() ); + } + } + + /** + test isEmpty - moved from the QueryHandler code. + */ + @Test + public void testIsEmpty() + { + Graph g = getGraph(); + if (canBeEmpty( g )) + { + assertTrue( g.isEmpty() ); + g.add( NodeCreateUtils.createTriple( "S P O" ) ); + assertFalse( g.isEmpty() ); + g.add( NodeCreateUtils.createTriple( "A B C" ) ); + assertFalse( g.isEmpty() ); + g.add( NodeCreateUtils.createTriple( "S P O" ) ); + assertFalse( g.isEmpty() ); + g.delete( NodeCreateUtils.createTriple( "S P O" ) ); + assertFalse( g.isEmpty() ); + g.delete( NodeCreateUtils.createTriple( "A B C" ) ); + assertTrue( g.isEmpty() ); + } + } + + + @Test + public void testAGraph() + { + String title = this.getClass().getName(); + Graph g = getGraph(); + int baseSize = g.size(); + graphAdd( g, "x R y; p S q; a T b" ); + /* */ + assertContainsAll( title + ": simple graph", g, "x R y; p S q; a T b" ); + assertEquals( title + ": size", baseSize + 3, g.size() ); + graphAdd( g, "spindizzies lift cities; Diracs communicate instantaneously" ); + assertEquals( title + ": size after adding", baseSize + 5, g.size() ); + g.delete( triple( "x R y" ) ); + g.delete( triple( "a T b" ) ); + assertEquals( title + ": size after deleting", baseSize + 3, g.size() ); + assertContainsAll( title + ": modified simple graph", g, "p S q; spindizzies lift cities; Diracs communicate instantaneously" ); + assertOmitsAll( title + ": modified simple graph", g, "x R y; a T b" ); + /* */ + ClosableIterator it = g.find( Node.ANY, node("lift"), Node.ANY ); + assertTrue( title + ": finds some triple(s)", it.hasNext() ); + assertEquals( title + ": finds a 'lift' triple", triple("spindizzies lift cities"), it.next() ); + assertFalse( title + ": finds exactly one triple", it.hasNext() ); + it.close(); + } + + // public void testStuff() + // { + //// testAGraph( "StoreMem", new GraphMem() ); + //// testAGraph( "StoreMemBySubject", new GraphMem() ); + //// String [] empty = new String [] {}; + //// Graph g = graphWith( "x R y; p S q; a T b" ); + //// /* */ + //// assertContainsAll( "simple graph", g, "x R y; p S q; a T b" ); + //// graphAdd( g, "spindizzies lift cities; Diracs communicate instantaneously" ); + //// g.delete( triple( "x R y" ) ); + //// g.delete( triple( "a T b" ) ); + //// assertContainsAll( "modified simple graph", g, "p S q; spindizzies lift cities; Diracs communicate instantaneously" ); + //// assertOmitsAll( "modified simple graph", g, "x R y; a T b" ); + // } + + /** + Test that Graphs have transaction support methods, and that if they fail + on some g they fail because they do not support the operation. + */ + @Test + public void testHasTransactions() + { + Graph g = getGraph(); + TransactionHandler th = g.getTransactionHandler(); + th.transactionsSupported(); + try { th.begin(); } catch (UnsupportedOperationException x) {} + try { th.abort(); } catch (UnsupportedOperationException x) {} + try { th.begin(); th.commit(); } catch (UnsupportedOperationException x) {} + /* */ + Command cmd = new Command() + { @Override + public Object execute() { return null; } }; + try { th.executeInTransaction( cmd ); } + catch (UnsupportedOperationException x) {} + } + + @Test + public void testExecuteInTransactionCatchesThrowable() + {Graph g = getGraph(); + TransactionHandler th = g.getTransactionHandler(); + if (th.transactionsSupported()) + { + Command cmd = new Command() + { @Override + public Object execute() throws Error { throw new Error(); } }; + try { th.executeInTransaction( cmd ); } + catch (JenaException x) {} + } + } + + static final Triple [] tripleArray = tripleArray( "S P O; A R B; X Q Y" ); + + static final List tripleList = Arrays.asList( tripleArray( "i lt j; p equals q" ) ); + + static final Triple [] setTriples = tripleArray + ( "scissors cut paper; paper wraps stone; stone breaks scissors" ); + + static final Set tripleSet = CollectionFactory.createHashedSet( Arrays.asList( setTriples ) ); + + @Test + public void testBulkUpdate() + { + Graph g = getGraph(); + Graph items = graphWith( "pigs might fly; dead can dance" ); + int initialSize = g.size(); + /* */ + GraphUtil.add( g, tripleArray ); + testContains( g, tripleArray ); + testOmits( g, tripleList ); + /* */ + GraphUtil.add( g, tripleList ); + testContains( g, tripleList ); + testContains( g, tripleArray ); + /* */ + GraphUtil.add( g, tripleSet.iterator() ); + testContains( g, tripleSet.iterator() ); + testContains( g, tripleList ); + testContains( g, tripleArray ); + /* */ + GraphUtil.addInto( g, items ); + testContains( g, items ); + testContains( g, tripleSet.iterator() ); + testContains( g, tripleArray ); + testContains( g, tripleList ); + /* */ + GraphUtil.delete( g, tripleArray ); + testOmits( g, tripleArray ); + testContains( g, tripleList ); + testContains( g, tripleSet.iterator() ); + testContains( g, items ); + /* */ + GraphUtil.delete( g, tripleSet.iterator() ); + testOmits( g, tripleSet.iterator() ); + testOmits( g, tripleArray ); + testContains( g, tripleList ); + testContains( g, items ); + /* */ + GraphUtil.deleteFrom( g, items ); + testOmits( g, tripleSet.iterator() ); + testOmits( g, tripleArray ); + testContains( g, tripleList ); + testOmits( g, items ); + /* */ + GraphUtil.delete( g, tripleList ); + assertEquals( "graph has original size", initialSize, g.size() ); + } + + @Test + public void testAddWithReificationPreamble() + { + Graph g = getGraph(); + xSPO( g ); + assertFalse( g.isEmpty() ); + } + + protected void xSPOyXYZ( Graph g) + { + xSPO( g ); + ReifierStd.reifyAs( g, NodeCreateUtils.create( "y" ), NodeCreateUtils.createTriple( "X Y Z" ) ); + } + + protected void aABC( Graph g ) + { ReifierStd.reifyAs( g , NodeCreateUtils.create( "a" ), NodeCreateUtils.createTriple( "A B C" ) ); } + + protected void xSPO( Graph g ) + { ReifierStd.reifyAs( g , NodeCreateUtils.create( "x" ), NodeCreateUtils.createTriple( "S P O" ) ); } + + @Test + public void testRemove() + { + testRemove( "?? ?? ??", "?? ?? ??" ); + testRemove( "S ?? ??", "S ?? ??" ); + testRemove( "S ?? ??", "?? P ??" ); + testRemove( "S ?? ??", "?? ?? O" ); + testRemove( "?? P ??", "S ?? ??" ); + testRemove( "?? P ??", "?? P ??" ); + testRemove( "?? P ??", "?? ?? O" ); + testRemove( "?? ?? O", "S ?? ??" ); + testRemove( "?? ?? O", "?? P ??" ); + testRemove( "?? ?? O", "?? ?? O" ); + } + + protected void testRemove( String findRemove, String findCheck ) + { + Graph g = getGraphWith( "S P O" ); + ExtendedIterator it = g.find( NodeCreateUtils.createTriple( findRemove ) ); + try + { + it.next(); it.remove(); it.close(); + assertEquals( "remove with " + findRemove + ":", 0, g.size() ); + assertFalse( g.contains( NodeCreateUtils.createTriple( findCheck ) ) ); + } + catch (UnsupportedOperationException e) { + it.close(); + assertFalse( g.getCapabilities().iteratorRemoveAllowed() ); + } + it.close(); + } + + @Test + public void testHasCapabilities() + { + Graph g = getGraph(); + Capabilities c = g.getCapabilities(); + boolean sa = c.sizeAccurate(); + boolean aaSome = c.addAllowed(); + boolean aaAll = c.addAllowed( true ); + boolean daSome = c.deleteAllowed(); + boolean daAll = c.deleteAllowed( true ); + boolean cbe = c.canBeEmpty(); + } + + @Test + public void testFind() + { + Graph g = getGraph(); + graphAdd( g, "S P O" ); + assertDiffer( new HashSet(), g.find( Node.ANY, Node.ANY, Node.ANY ).toSet() ); + assertDiffer( new HashSet(), g.find( Triple.ANY ).toSet() ); + } + + protected boolean canBeEmpty( Graph g ) + { return g.isEmpty(); } + + public void testEventRegister() + { + Graph g = getGraph(); + GraphEventManager gem = g.getEventManager(); + assertSame( gem, gem.register( new RecordingListener() ) ); + } + + /** + Test that we can safely unregister a listener that isn't registered. + */ + @Test + public void testEventUnregister() + { + getGraph().getEventManager().unregister( L ); + } + + /** + Handy triple for test purposes. + */ + protected Triple SPO = NodeCreateUtils.createTriple( "S P O" ); + protected RecordingListener L = new RecordingListener(); + + /** + Utility: get a graph, register L with its manager, return the graph. + */ + protected Graph getAndRegister( GraphListener gl ) + { + Graph g = getGraph(); + g.getEventManager().register( gl ); + return g; + } + + @Test + public void testAddTriple() + { + Graph g = getAndRegister( L ); + g.add( SPO ); + L.assertHas( new Object[] {"add", g, SPO} ); + } + + @Test + public void testDeleteTriple() + { + Graph g = getAndRegister( L ); + g.delete( SPO ); + L.assertHas( new Object[] { "delete", g, SPO} ); + } + + @Test + public void testListSubjects() + { + Set emptySubjects = listSubjects( getGraphWith( "" ) ); + Graph g = getGraphWith( "x P y; y Q z" ); + assertEquals( nodeSet( "x y" ), remove( listSubjects( g ), emptySubjects ) ); + g.delete( triple( "x P y" ) ); + assertEquals( nodeSet( "y" ), remove( listSubjects( g ), emptySubjects ) ); + } + + protected Set listSubjects( Graph g ) + { + return GraphUtil.listSubjects( g, Node.ANY, Node.ANY ).toSet(); + } + + @Test + public void testListPredicates() + { + Set emptyPredicates = listPredicates( getGraphWith( "" ) ); + Graph g = getGraphWith( "x P y; y Q z" ); + assertEquals( nodeSet( "P Q" ), remove( listPredicates( g ), emptyPredicates ) ); + g.delete( triple( "x P y" ) ); + assertEquals( nodeSet( "Q" ), remove( listPredicates( g ), emptyPredicates ) ); + } + + protected Set listPredicates( Graph g ) + { + return GraphUtil.listPredicates( g, Node.ANY, Node.ANY ).toSet(); + } + + @Test + public void testListObjects() + { + Set emptyObjects = listObjects( getGraphWith( "" ) ); + Graph g = getGraphWith( "x P y; y Q z" ); + assertEquals( nodeSet( "y z" ), remove( listObjects( g ), emptyObjects ) ); + g.delete( triple( "x P y" ) ); + assertEquals( nodeSet( "z" ), remove( listObjects( g ), emptyObjects ) ); + } + + protected Set listObjects( Graph g ) + { + return GraphUtil.listObjects( g, Node.ANY, Node.ANY ).toSet(); + } + + /** + Answer a set with all the elements of A except those + in B. + */ + private Set remove( Set A, Set B ) + { + Set result = new HashSet( A ); + result.removeAll( B ); + return result; + } + + /** + Ensure that triples removed by calling .remove() on the iterator returned by + a find() will generate deletion notifications. + */ + @Test + public void testEventDeleteByFind() + { + Graph g = getAndRegister( L ); + if (g.getCapabilities().iteratorRemoveAllowed()) + { + Triple toRemove = triple( "remove this triple" ); + g.add( toRemove ); + ExtendedIterator rtr = g.find( toRemove ); + assertTrue( "ensure a(t least) one triple", rtr.hasNext() ); + rtr.next(); rtr.remove(); rtr.close(); + L.assertHas( new Object[] { "add", g, toRemove, "delete", g, toRemove} ); + } + } + + @Test + public void testTwoListeners() + { + RecordingListener L1 = new RecordingListener(); + RecordingListener L2 = new RecordingListener(); + Graph g = getGraph(); + GraphEventManager gem = g.getEventManager(); + gem.register( L1 ).register( L2 ); + g.add( SPO ); + L2.assertHas( new Object[] {"add", g, SPO} ); + L1.assertHas( new Object[] {"add", g, SPO} ); + } + + @Test + public void testUnregisterWorks() + { + Graph g = getGraph(); + GraphEventManager gem = g.getEventManager(); + gem.register( L ).unregister( L ); + g.add( SPO ); + L.assertHas( new Object[] {} ); + } + + @Test + public void testRegisterTwice() + { + Graph g = getAndRegister( L ); + g.getEventManager().register( L ); + g.add( SPO ); + L.assertHas( new Object[] {"add", g, SPO, "add", g, SPO} ); + } + + @Test + public void testUnregisterOnce() + { + Graph g = getAndRegister( L ); + g.getEventManager().register( L ).unregister( L ); + g.delete( SPO ); + L.assertHas( new Object[] {"delete", g, SPO} ); + } + + @Test + public void testBulkAddArrayEvent() + { + Graph g = getAndRegister( L ); + Triple [] triples = tripleArray( "x R y; a P b" ); + GraphUtil.add(g, triples ); + L.assertHas( new Object[] {"add[]", g, triples} ); + } + + @Test + public void testBulkAddList() + { + Graph g = getAndRegister( L ); + List elems = Arrays.asList( tripleArray( "bells ring loudly; pigs might fly" ) ); + GraphUtil.add(g, elems) ; + L.assertHas( new Object[] {"addList", g, elems} ); + } + + @Test + public void testBulkDeleteArray() + { + Graph g = getAndRegister( L ); + Triple [] triples = tripleArray( "x R y; a P b" ); + GraphUtil.delete( g, triples ); + L.assertHas( new Object[] {"delete[]", g, triples} ); + } + + @Test + public void testBulkDeleteList() + { + Graph g = getAndRegister( L ); + List elems = Arrays.asList( tripleArray( "bells ring loudly; pigs might fly" ) ); + GraphUtil.delete( g, elems ); + L.assertHas( new Object[] {"deleteList", g, elems} ); + } + + @Test + public void testBulkAddIterator() + { + Graph g = getAndRegister( L ); + Triple [] triples = tripleArray( "I wrote this; you read that; I wrote this" ); + GraphUtil.add(g, asIterator( triples ) ); + L.assertHas( new Object[] {"addIterator", g, Arrays.asList( triples )} ); + } + + @Test + public void testBulkDeleteIterator() + { + Graph g = getAndRegister( L ); + Triple [] triples = tripleArray( "I wrote this; you read that; I wrote this" ); + GraphUtil.delete( g, asIterator( triples ) ); + L.assertHas( new Object[] {"deleteIterator", g, Arrays.asList( triples )} ); + } + + public Iterator asIterator( Triple [] triples ) + { return Arrays.asList( triples ).iterator(); } + + @Test + public void testBulkAddGraph() + { + Graph g = getAndRegister( L ); + Graph triples = graphWith( "this type graph; I type slowly" ); + GraphUtil.addInto( g, triples ); + L.assertHas( new Object[] {"addGraph", g, triples} ); + } + + @Test + public void testBulkDeleteGraph() + { + Graph g = getAndRegister( L ); + Graph triples = graphWith( "this type graph; I type slowly" ); + GraphUtil.deleteFrom( g, triples ); + L.assertHas( new Object[] {"deleteGraph", g, triples} ); + } + + @Test + public void testGeneralEvent() + { + Graph g = getAndRegister( L ); + Object value = new int[]{}; + g.getEventManager().notifyEvent( g, value ); + L.assertHas( new Object[] { "someEvent", g, value } ); + } + + @Test + public void testRemoveAllEvent() + { + Graph g = getAndRegister( L ); + g.clear(); + L.assertHas( new Object[] { "someEvent", g, GraphEvents.removeAll } ); + } + + @Test + public void testRemoveSomeEvent() + { + Graph g = getAndRegister( L ); + Node S = node( "S" ), P = node( "??" ), O = node( "??" ); + g.remove( S, P, O ); + Object event = GraphEvents.remove( S, P, O ); + L.assertHas( new Object[] { "someEvent", g, event } ); + } + + /** + * Test that nodes can be found in all triple positions. + * However, testing for literals in subject positions is suppressed + * at present to avoid problems with InfGraphs which try to prevent + * such constructs leaking out to the RDF layer. + */ + @Test + public void testContainsNode() + { + Graph g = getGraph(); + graphAdd( g, "a P b; _c _Q _d; a 11 12" ); + assertTrue( containsNode( g, node( "a" ) ) ); + assertTrue( containsNode( g, node( "P" ) ) ); + assertTrue( containsNode( g, node( "b" ) ) ); + assertTrue( containsNode( g, node( "_c" ) ) ); + assertTrue( containsNode( g, node( "_Q" ) ) ); + assertTrue( containsNode( g, node( "_d" ) ) ); + // assertTrue( qh.containsNode( node( "10" ) ) ); + assertTrue( containsNode( g, node( "11" ) ) ); + assertTrue( containsNode( g, node( "12" ) ) ); + /* */ + assertFalse( containsNode( g, node( "x" ) ) ); + assertFalse( containsNode( g, node( "_y" ) ) ); + assertFalse( containsNode( g, node( "99" ) ) ); + } + + + + private boolean containsNode(Graph g, Node node) + { + return GraphUtil.containsNode(g, node) ; + } + + @Test + public void testSubjectsFor() + { + // First get the answer from the empty graph (not empty for an inf graph) + Graph b = getGraphWith( "" ); + Set B = GraphUtil.listSubjects( b, Node.ANY, Node.ANY ).toSet(); + + Graph g = getGraphWith( "a P b; a Q c; a P d; b P x; c Q y" ); + + testSubjects( g, B, Node.ANY, Node.ANY, node("a"), node("b"), node("c") ); + testSubjects( g, B, node( "P" ), Node.ANY, node("a"), node("b")); + testSubjects( g, B, node( "Q" ), node( "c" ), node("a") ); + testSubjects( g, B, node( "Q" ), node( "y" ), node("c") ); + testSubjects( g, B, node( "Q" ), node( "a" )); + testSubjects( g, B, node( "Q" ), node( "z" )); + } + + protected void testSubjects( Graph g, Collection exclude, Node p, Node o, Node... expected ) + { + List R = GraphUtil.listSubjects( g, p, o ).toList(); + R.removeAll(exclude) ; + assertSameUnordered(R, exclude, expected) ; + } + + // Same - except for order + private void assertSameUnordered(List x1, Collectionexclude, Node[] expected) + { + List x = new ArrayList() ; + x.addAll(x1) ; + x.removeAll(exclude) ; + + assertEquals(expected.length, x.size()) ; + Set X = new HashSet() ; + X.addAll(x) ; + + Set R = new HashSet() ; + R.addAll(Arrays.asList(expected)) ; + + assertEquals( R, X); + + } + + @Test + public void testListSubjectsNoRemove() + { + Graph g = getGraphWith( "a P b; b Q c; c R a" ); + Iterator it = GraphUtil.listSubjects( g, Node.ANY, Node.ANY ); + it.next(); + try { it.remove(); fail( "listSubjects for " + g.getClass() + " should not support .remove()" ); } + catch (UnsupportedOperationException expected) { + // expected result + } + } + + @Test + public void testObjectsFor() + { + // First get the answer from the empty graph (not empty for an inf graph) + Graph b = getGraphWith( "" ); + Set B = GraphUtil.listObjects( b, Node.ANY, Node.ANY ).toSet(); + + Graph g = getGraphWith( "b P a; c Q a; d P a; x P b; y Q c" ); + testObjects( g, B, Node.ANY, Node.ANY, node("a"), node("b"), node("c") ); + testObjects( g, B, Node.ANY, node( "P" ), node("a"), node("b") ); + testObjects( g, B, node( "c" ), node( "Q" ), node("a") ); + testObjects( g, B, node( "y" ), node( "Q" ), node("c") ); + testObjects( g, B, node( "a" ), node( "Q" )); + testObjects( g, B, node( "z" ), node( "Q" )); + } + + protected void testObjects( Graph g, Collection exclude, Node s, Node p, Node... expected ) + { + List X = GraphUtil.listObjects( g, s, p ).toList(); + assertSameUnordered(X, exclude, expected) ; + } + + @Test + public void testPredicatesFor() + { + // First get the answer from the empty graph (not empty for an inf graph) + Graph b = getGraphWith( "" ); + Set B = GraphUtil.listPredicates( b, Node.ANY, Node.ANY ).toSet(); + + Graph g = getGraphWith( "a P b; z P b; c Q d; e R f; g P b; h Q i" ); + testPredicates( g, B, Node.ANY, Node.ANY, node("P"), node("Q"), node("R") ); + testPredicates( g, B, Node.ANY, node( "b" ), node("P") ); + testPredicates( g, B, node( "g" ), Node.ANY, node("P")) ; + testPredicates( g, B, node( "c" ), node( "d" ), node("Q") ); + testPredicates( g, B, node( "e" ), node( "f" ), node("R") ); + testPredicates( g, B, node( "e" ), node( "a" )); + testPredicates( g, B, node( "z" ), node( "y" )); + } + + protected void testPredicates( Graph g, Collection exclude, Node s, Node o, Node... expected ) + { + List X = GraphUtil.listPredicates( g, s, o ).toList(); + assertSameUnordered(X, exclude, expected) ; + } + + @Test + public void testListObjectsNoRemove() + { + Graph g = getGraphWith( "a P b; b Q c; c R a" ); + Iterator it = GraphUtil.listObjects( g, Node.ANY, Node.ANY ); + it.next(); + try { it.remove(); fail( "listObjects for " + g.getClass() + " should not support .remove()" ); } + catch (UnsupportedOperationException e) { +// expected + } + } + + @Test + public void testListPredicatesNoRemove() + { + Graph g = getGraphWith( "a P b; b Q c; c R a" ); + Iterator it = GraphUtil.listPredicates( g, Node.ANY, Node.ANY ); + it.next(); + try { it.remove(); fail( "listPredicates for " + g.getClass() + " should not support .remove()" ); } + catch (UnsupportedOperationException e) { +//expected + } + } + + @Test + public void testRemoveAll() + { + testRemoveAll( "" ); + testRemoveAll( "a R b" ); + testRemoveAll( "c S d; e:ff GGG hhhh; _i J 27; Ell Em 'en'" ); + } + + + protected void testRemoveAll( String triples ) + { + Graph g = getGraph(); + graphAdd( g, triples ); + g.clear(); + assertTrue( g.isEmpty() ); + } + + @Test + public void failingTestDoubleRemoveAll() { + final Graph g = getGraph(); + if (g.getCapabilities().iteratorRemoveAllowed() ) { + graphAdd(g,"c S d; e:ff GGG hhhh; _i J 27; Ell Em 'en'" ); + Iterator it = new TrackingTripleIterator(g.find(Triple.ANY)){ + @Override + public void remove() { + super.remove(); // removes current + g.delete(current); // no-op. + } + }; + while (it.hasNext()) { + it.next(); + it.remove(); + } + assertTrue( g.isEmpty() ); + } + } + + @Test + public void testGetStatisticsHandler() + { + Graph g = getGraph(); + GraphStatisticsHandler h = g.getStatisticsHandler(); + assertSame( h, g.getStatisticsHandler() ); + } + + /** + Test cases for RemoveSPO(); each entry is a triple (add, remove, result). +
    +
  • add - the triples to add to the graph to start with +
  • remove - the pattern to use in the removal +
  • result - the triples that should remain in the graph +
+ */ + 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() + { + for (int i = 0; i < cases.length; i += 1) + for (int j = 0; j < 3; j += 1) + { + Graph content = getGraph(); + Graph baseContent = copy( content ); + graphAdd( content, cases[i][0] ); + Triple remove = triple( cases[i][1] ); + Graph expected = graphWith( cases[i][2] ); + content.remove( remove.getSubject(), remove.getPredicate(), remove.getObject() ); + Graph finalContent = remove( copy( content ), baseContent ); + assertIsomorphic( cases[i][1], expected, finalContent ); + } + } + + /** testIsomorphism from file data + * @throws FileNotFoundException */ + @Test + public void testIsomorphismFile() throws URISyntaxException, MalformedURLException { + testIsomorphismXMLFile(1,true); + testIsomorphismXMLFile(2,true); + testIsomorphismXMLFile(3,true); + testIsomorphismXMLFile(4,true); + testIsomorphismXMLFile(5,false); + testIsomorphismXMLFile(6,false); + testIsomorphismNTripleFile(7,true); + testIsomorphismNTripleFile(8,false); + + } + private void testIsomorphismNTripleFile(int i, boolean result) throws URISyntaxException, MalformedURLException { + testIsomorphismFile(i,"N-TRIPLE","nt",result); + } + + private void testIsomorphismXMLFile(int i, boolean result) throws URISyntaxException, MalformedURLException { + testIsomorphismFile(i,"RDF/XML","rdf",result); + + } + + private InputStream getInputStream( int n, int n2, String suffix) throws URISyntaxException, MalformedURLException + { + String urlStr = String.format( "regression/testModelEquals/%s-%s.%s", n, n2, suffix); + return AbstractGraphTest.class.getClassLoader().getResourceAsStream( urlStr ); + } + + private void testIsomorphismFile(int n, String lang, String suffix, boolean result) throws URISyntaxException, MalformedURLException { + + Graph g1 = getGraph(); + Graph g2 = getGraph(); + Model m1 = ModelFactory.createModelForGraph(g1); + Model m2 = ModelFactory.createModelForGraph(g2); + + m1.read( + getInputStream(n, 1, suffix), + "http://www.example.org/",lang); + m2.read( + getInputStream(n, 2, suffix), + "http://www.example.org/",lang); + + boolean rslt = g1.isIsomorphicWith(g2) == result; + if (!rslt) { + System.out.println("g1:"); + m1.write(System.out, "N-TRIPLE"); + System.out.println("g2:"); + m2.write(System.out, "N-TRIPLE"); + } + assertTrue("Isomorphism test failed",rslt); + } + + protected void add( Graph toUpdate, Graph toAdd ) + { + GraphUtil.addInto( toUpdate, toAdd) ; + } + + protected Graph remove( Graph toUpdate, Graph toRemove ) + { + GraphUtil.deleteFrom(toUpdate, toRemove) ; + return toUpdate; + } + + + protected Graph copy( Graph g ) + { + Graph result = Factory.createDefaultGraph(); + GraphUtil.addInto(result, g) ; + return result; + } + + protected Graph getClosed() + { + Graph result = getGraph(); + result.close(); + return result; + } + + // public void testClosedDelete() + // { + // try { getClosed().delete( triple( "x R y" ) ); fail( "delete when closed" ); } + // catch (ClosedException c) { /* as required */ } + // } + // + // public void testClosedAdd() + // { + // try { getClosed().add( triple( "x R y" ) ); fail( "add when closed" ); } + // catch (ClosedException c) { /* as required */ } + // } + // + // public void testClosedContainsTriple() + // { + // try { getClosed().contains( triple( "x R y" ) ); fail( "contains[triple] when closed" ); } + // catch (ClosedException c) { /* as required */ } + // } + // + // public void testClosedContainsSPO() + // { + // Node a = Node.ANY; + // try { getClosed().contains( a, a, a ); fail( "contains[SPO] when closed" ); } + // catch (ClosedException c) { /* as required */ } + // } + // + // public void testClosedFindTriple() + // { + // try { getClosed().find( triple( "x R y" ) ); fail( "find [triple] when closed" ); } + // catch (ClosedException c) { /* as required */ } + // } + // + // public void testClosedFindSPO() + // { + // Node a = Node.ANY; + // try { getClosed().find( a, a, a ); fail( "find[SPO] when closed" ); } + // catch (ClosedException c) { /* as required */ } + // } + // + // public void testClosedSize() + // { + // try { getClosed().size(); fail( "size when closed (" + this.getClass() + ")" ); } + // catch (ClosedException c) { /* as required */ } + // } + +} Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/AbstractGraphTest.java ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/GraphProducerInterface.java URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/GraphProducerInterface.java?rev=1517755&view=auto ============================================================================== --- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/GraphProducerInterface.java (added) +++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/GraphProducerInterface.java Tue Aug 27 06:01:01 2013 @@ -0,0 +1,14 @@ +package com.hp.hpl.jena.graph; + +/** + * Creates the graph for testing + * + */ +public interface GraphProducerInterface { + + /** + * Returns a Graph to take part in the test. Must be overridden in a subclass. + * @return The graph implementation to test. + */ + public abstract Graph newGraph(); +} Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/GraphProducerInterface.java ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/GraphTestUtils.java URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/GraphTestUtils.java?rev=1517755&view=auto ============================================================================== --- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/GraphTestUtils.java (added) +++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/GraphTestUtils.java Tue Aug 27 06:01:01 2013 @@ -0,0 +1,431 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.hp.hpl.jena.graph; + +/** + An extension of JenaTestBase (which see) with Graph-specific methods. +*/ + +import static org.junit.Assert.*; +import java.io.FileNotFoundException; +import java.lang.reflect.Constructor ; +import java.net.URISyntaxException; +import java.net.URL; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.StringTokenizer; + +import com.hp.hpl.jena.graph.Factory; +import com.hp.hpl.jena.graph.Graph; +import com.hp.hpl.jena.graph.GraphUtil; +import com.hp.hpl.jena.graph.Node; +import com.hp.hpl.jena.graph.Triple; +import com.hp.hpl.jena.ontology.impl.TestListSyntaxCategories; +import com.hp.hpl.jena.shared.JenaException ; +import com.hp.hpl.jena.shared.PrefixMapping ; +import com.hp.hpl.jena.test.TestUtils; +import com.hp.hpl.jena.util.CollectionFactory ; +import com.hp.hpl.jena.util.IteratorCollection ; +import com.hp.hpl.jena.util.iterator.ExtendedIterator ; + +public class GraphTestUtils extends TestUtils + { + protected static String getFileName( String fn ) + { + URL u = TestListSyntaxCategories.class.getClassLoader().getResource( fn ); + if (u == null) + { + throw new RuntimeException( new FileNotFoundException( fn )); + } + try { + return u.toURI().toString(); + } catch (URISyntaxException e) { + throw new RuntimeException( e ); + } + } + + /** + Answer a Node as described by x; a shorthand for + Node.create(x), which see. + */ + public static Node node( String x ) + { return NodeCreateUtils.create( x ); } + + /** + Answer a set containing the elements from the iterator it; + a shorthand for IteratorCollection.iteratorToSet(it), + which see. + */ + public static Set iteratorToSet( Iterator it ) + { return IteratorCollection.iteratorToSet( it ); } + + /** + Answer a list containing the elements from the iterator it, + in order; a shorthand for IteratorCollection.iteratorToList(it), + which see. + */ + public static List iteratorToList( Iterator it ) + { return IteratorCollection.iteratorToList( it ); } + + /** + Answer a set of the nodes described (as per node()) by + the space-separated substrings of nodes. + */ + public static Set nodeSet( String nodes ) + { + Set result = CollectionFactory.createHashedSet(); + StringTokenizer st = new StringTokenizer( nodes ); + while (st.hasMoreTokens()) result.add( node( st.nextToken() ) ); + return result; + } + + /** + Answer a set of the elements of A. + */ + public static Set arrayToSet( T [] A ) + { return CollectionFactory.createHashedSet( Arrays.asList( A ) ); } + + /** + Answer a triple described by the three space-separated node descriptions + in fact; a shorthand for Triple.create(fact), + which see. + */ + public static Triple triple( String fact ) + { return NodeCreateUtils.createTriple( fact ); } + + /** + Answer a triple described by the three space-separated node descriptions + in fact, using prefix-mappings from pm; a + shorthand for Triple.create(pm, fact), which see. + */ + public static Triple triple( PrefixMapping pm, String fact ) + { return NodeCreateUtils.createTriple( pm, fact ); } + + /** + Answer an array of triples; each triple is described by one of the + semi-separated substrings of facts, as per + triple with prefix-mapping Extended. + */ + public static Triple [] tripleArray( String facts ) + { + ArrayList al = new ArrayList(); + StringTokenizer semis = new StringTokenizer( facts, ";" ); + while (semis.hasMoreTokens()) al.add( triple( PrefixMapping.Extended, semis.nextToken() ) ); + return al.toArray( new Triple [al.size()] ); + } + + /** + Answer a set of triples where the elements are described by the + semi-separated substrings of facts, as per + triple. + */ + public static Set tripleSet( String facts ) + { + Set result = new HashSet(); + StringTokenizer semis = new StringTokenizer( facts, ";" ); + while (semis.hasMoreTokens()) result.add( triple( semis.nextToken() ) ); + return result; + } + + /** + Answer a list of nodes, where the nodes are described by the + space-separated substrings of items as per + node(). + */ + public static List nodeList( String items ) + { + ArrayList nl = new ArrayList(); + StringTokenizer nodes = new StringTokenizer( items ); + while (nodes.hasMoreTokens()) nl.add( node( nodes.nextToken() ) ); + return nl; + } + + /** + Answer an array of nodes, where the nodes are described by the + space-separated substrings of items as per + */ + public static Node [] nodeArray( String items ) + { + List nl = nodeList( items ); + return nl.toArray( new Node [nl.size()] ); + } + + /** + Answer the graph g after adding to it every triple + encoded in s in the fashion of tripleArray, + a semi-separated sequence of space-separated node descriptions. + */ + public static Graph graphAdd( Graph g, String s ) + { + StringTokenizer semis = new StringTokenizer( s, ";" ); + while (semis.hasMoreTokens()) g.add( triple( PrefixMapping.Extended, semis.nextToken() ) ); + return g; + } + + /** + Answer a new memory-based graph with Extended prefixes. + */ + public static Graph newGraph() + { + Graph result = Factory.createGraphMem(); + result.getPrefixMapping().setNsPrefixes( PrefixMapping.Extended ); + return result; + } + + /** + Answer a new memory-based graph with initial contents as described + by s in the fashion of graphAdd(). + Not over-ridable; do not use for abstraction. + */ + public static Graph graphWith( String s ) + { return graphAdd( newGraph(), s ); } + + /** + Assert that the graph g is isomorphic to the graph + described by template in the fashion of + graphWith. + */ + public static void assertEqualsTemplate( String title, Graph g, String template ) + { assertIsomorphic( title, graphWith( template ), g ); } + + /** + Assert that the supplied graph got is isomorphic with the + the desired graph expected; if not, display a readable + description of both graphs. + */ + public static void assertIsomorphic( String title, Graph expected, Graph got ) + { + if (!expected.isIsomorphicWith( got )) + { + Map map = CollectionFactory.createHashedMap(); + fail( title + ": wanted " + nice( expected, map ) + "\nbut got " + nice( got, map ) ); + } + } + + /** + Answer a string which is a newline-separated list of triples (as + produced by niceTriple) in the graph g. The map + bnodes maps already-seen bnodes to their "nice" strings. + */ + public static String nice( Graph g, Map bnodes ) + { + StringBuffer b = new StringBuffer( g.size() * 100 ); + ExtendedIterator it = GraphUtil.findAll( g ); + while (it.hasNext()) niceTriple( b, bnodes, it.next() ); + return b.toString(); + } + + /** + Append to the string buffer b a "nice" representation + of the triple t on a new line, using (and updating) + bnodes to supply "nice" strings for any blank nodes. + */ + protected static void niceTriple( StringBuffer b, Map bnodes, Triple t ) + { + b.append( "\n " ); + appendNode( b, bnodes, t.getSubject() ); + appendNode( b, bnodes, t.getPredicate() ); + appendNode( b, bnodes, t.getObject() ); + } + + /** + A counter for new bnode strings; it starts at 1000 so as to make + the bnode strings more uniform (at least for the first 9000 bnodes). + */ + protected static int bnc = 1000; + + /** + Append to the string buffer b a space followed by the + "nice" representation of the node n. If n + is a bnode, re-use any existing string for it from bnodes + or make a new one of the form _bNNNN with NNNN a new integer. + */ + protected static void appendNode( StringBuffer b, Map bnodes, Node n ) + { + b.append( ' ' ); + if (n.isBlank()) + { + Object already = bnodes.get( n ); + if (already == null) bnodes.put( n, already = "_b" + bnc++ ); + b.append( already ); + } + else + b.append( nice( n ) ); + } + + /** + Answer the "nice" representation of this node, the string returned by + n.toString(PrefixMapping.Extended,true). + */ + protected static String nice( Node n ) + { return n.toString( PrefixMapping.Extended, true ); } + + /** + Assert that the computed graph got is isomorphic with the + desired graph expected; if not, fail with a default + message (and pretty output of the graphs). + */ + public static void assertIsomorphic( Graph expected, Graph got ) + { assertIsomorphic( "graphs must be isomorphic", expected, got ); } + + /** + Assert that the graph g must contain the triple described + by s; if not, fail with pretty output of both graphs + and a message containing name. + */ + public static void assertContains( String name, String s, Graph g ) + { + assertTrue( name + " must contain " + s, g.contains( triple( s ) ) ); + } + + /** + Assert that the graph g contains all the triples described + by the string sname. + */ + public static void assertContainsAll( String name, Graph g, String s ) + { + StringTokenizer semis = new StringTokenizer( s, ";" ); + while (semis.hasMoreTokens()) assertContains( name, semis.nextToken(), g ); + } + + /** + Assert that the graph g does not contain the triple + described by s; if it does, fail with a message containing + name. + */ + public static void assertOmits( String name, Graph g, String s ) + { + assertFalse( name + " must not contain " + s, g.contains( triple( s ) ) ); + } + + /** + Assert that the graph g contains none of the triples + described by s in the usual way; otherwise, fail with + a message containing name. + */ + public static void assertOmitsAll( String name, Graph g, String s ) + { + StringTokenizer semis = new StringTokenizer( s, ";" ); + while (semis.hasMoreTokens()) assertOmits( name, g, semis.nextToken() ); + } + + /** + Assert that g contains the triple described by + fact in the usual way. + */ + public static boolean contains( Graph g, String fact ) + { return g.contains( triple( fact ) ); } + + /** + Assert that g contains every triple in triples. + */ + public static void testContains( Graph g, Triple [] triples ) + { + for (int i = 0; i < triples.length; i += 1) + assertTrue( "contains " + triples[i], g.contains( triples[i] ) ); + } + + /** + Assert that g contains every triple in triples. + */ + public static void testContains( Graph g, List triples ) + { + for (int i = 0; i < triples.size(); i += 1) + assertTrue( g.contains( triples.get(i) ) ); + } + + /** + Assert that g contains every triple in it. + */ + public static void testContains( Graph g, Iterator it ) + { while (it.hasNext()) assertTrue( g.contains( it.next() ) ); } + + /** + Assert that g contains every triple in other. + */ + public static void testContains( Graph g, Graph other ) + { testContains( g, GraphUtil.findAll( other ) ); } + + /** + Assert that g contains none of the triples in + triples. + */ + public static void testOmits( Graph g, Triple [] triples ) + { for (int i = 0; i < triples.length; i += 1) assertFalse( "", g.contains( triples[i] ) ); } + + /** + Assert that g contains none of the triples in + triples. + */ + public static void testOmits( Graph g, List triples ) + { + for (int i = 0; i < triples.size(); i += 1) + assertFalse( "", g.contains( triples.get(i) ) ); + } + + /** + Assert that g contains none of the triples in + it. + */ + public static void testOmits( Graph g, Iterator it ) + { while (it.hasNext()) assertFalse( "", g.contains( it.next() ) ); } + + /** + Assert that g contains none of the triples in + other. + */ + public static void testOmits( Graph g, Graph other ) + { testOmits( g, GraphUtil.findAll( other ) ); } + + /** + Answer an instance of graphClass. If graphClass has + a constructor that takes a ReificationStyle argument, then that + constructor is run on style to get the instance. Otherwise, if it has a # + constructor that takes an argument of wrap's class before the + ReificationStyle, that constructor is used; this allows non-static inner + classes to be used for graphClass, with wrap being + the outer class instance. If no suitable constructor exists, a JenaException is thrown. + + @param wrap the outer class instance if graphClass is an inner class + @param graphClass a class implementing Graph + @return an instance of graphClass with the given style + @throws RuntimeException or JenaException if construction fails + */ + public static Graph getGraph( Object wrap, Class graphClass) + { + try + { + Constructor cons = getConstructor( graphClass, new Class[] {} ); + if (cons != null) return (Graph) cons.newInstance( new Object[] { } ); + Constructor cons2 = getConstructor( graphClass, new Class [] {wrap.getClass()} ); + if (cons2 != null) return (Graph) cons2.newInstance( new Object[] { wrap} ); + throw new JenaException( "no suitable graph constructor found for " + graphClass ); + } + catch (RuntimeException e) + { throw e; } + catch (Exception e) + { throw new JenaException( e ); } + } + } Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/GraphTestUtils.java ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/MemGraphTest.java URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/MemGraphTest.java?rev=1517755&view=auto ============================================================================== --- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/MemGraphTest.java (added) +++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/MemGraphTest.java Tue Aug 27 06:01:01 2013 @@ -0,0 +1,19 @@ +package com.hp.hpl.jena.graph; + +import com.hp.hpl.jena.sparql.graph.GraphFactory; + +public class MemGraphTest extends AbstractGraphTest { + + public MemGraphTest() { + super( new GraphProducer() ); + } + + private static class GraphProducer implements GraphProducerInterface + { + @Override + public Graph newGraph() { + return GraphFactory.createGraphMem(); + } + } + +} Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/MemGraphTest.java ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/NodeCreateUtils.java URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/NodeCreateUtils.java?rev=1517755&view=auto ============================================================================== --- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/NodeCreateUtils.java (added) +++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/NodeCreateUtils.java Tue Aug 27 06:01:01 2013 @@ -0,0 +1,170 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.hp.hpl.jena.graph; + +import java.util.StringTokenizer; + +import com.hp.hpl.jena.datatypes.xsd.XSDDatatype; +import com.hp.hpl.jena.graph.Node; +import com.hp.hpl.jena.graph.NodeFactory ; +import com.hp.hpl.jena.graph.Triple; +import com.hp.hpl.jena.graph.impl.LiteralLabel; +import com.hp.hpl.jena.graph.impl.LiteralLabelFactory; +import com.hp.hpl.jena.rdf.model.AnonId; +import com.hp.hpl.jena.shared.*; + +/** + Creating nodes from string specifications. +*/ +public class NodeCreateUtils + { + /** + Returns a Node described by the string, primarily for testing purposes. + The string represents a URI, a numeric literal, a string literal, a bnode label, + or a variable. +
    +
  • 'some text' :: a string literal with that text +
  • 'some text'someLanguage:: a string literal with that text and language +
  • 'some text'someURI:: a typed literal with that text and datatype +
  • digits :: a literal [OF WHAT TYPE] with that [numeric] value +
  • _XXX :: a bnode with an AnonId built from _XXX +
  • ?VVV :: a variable with name VVV +
  • &PPP :: to be done +
  • name:stuff :: the URI; name may be expanded using the Extended map +
+ @param x the string describing the node + @return a node of the appropriate type with the appropriate label + */ + public static Node create( String x ) + { return create( PrefixMapping.Extended, x ); } + + /** + Returns a Node described by the string, primarily for testing purposes. + The string represents a URI, a numeric literal, a string literal, a bnode label, + or a variable. +
    +
  • 'some text' :: a string literal with that text +
  • 'some text'someLanguage:: a string literal with that text and language +
  • 'some text'someURI:: a typed literal with that text and datatype +
  • digits :: a literal [OF WHAT TYPE] with that [numeric] value +
  • _XXX :: a bnode with an AnonId built from _XXX +
  • ?VVV :: a variable with name VVV +
  • &PPP :: to be done +
  • name:stuff :: the URI; name may be expanded using the Extended map +
+ + @param pm the PrefixMapping for translating pre:X strings + @param x the string encoding the node to create + @return a node with the appropriate type and label + */ + public static Node create( PrefixMapping pm, String x ) + { + if (x.equals( "" )) + throw new JenaException( "Node.create does not accept an empty string as argument" ); + char first = x.charAt( 0 ); + if (first == '\'' || first == '\"') + return NodeFactory.createLiteral( newString( pm, first, x ) ); + if (Character.isDigit( first )) + return NodeFactory.createLiteral( x, "", XSDDatatype.XSDinteger ); + if (first == '_') + return NodeFactory.createAnon( new AnonId( x ) ); + if (x.equals( "??" )) + return Node.ANY; + if (first == '?') + return NodeFactory.createVariable( x.substring( 1 ) ); + if (first == '&') + return NodeFactory.createURI( "q:" + x.substring( 1 ) ); + int colon = x.indexOf( ':' ); + String d = pm.getNsPrefixURI( "" ); + return colon < 0 + ? NodeFactory.createURI( (d == null ? "eh:/" : d) + x ) + : NodeFactory.createURI( pm.expandPrefix( x ) ) + ; + } + + public static String unEscape( String spelling ) + { + if (spelling.indexOf( '\\' ) < 0) return spelling; + StringBuffer result = new StringBuffer( spelling.length() ); + int start = 0; + while (true) + { + int b = spelling.indexOf( '\\', start ); + if (b < 0) break; + result.append( spelling.substring( start, b ) ); + result.append( unEscape( spelling.charAt( b + 1 ) ) ); + start = b + 2; + } + result.append( spelling.substring( start ) ); + return result.toString(); + } + + public static char unEscape( char ch ) + { + switch (ch) + { + case '\\': + case '\"': + case '\'': return ch; + case 'n': return '\n'; + case 's': return ' '; + case 't': return '\t'; + default: return 'Z'; + } + } + + public static LiteralLabel literal( PrefixMapping pm, String spelling, String langOrType ) + { + String content = unEscape( spelling ); + int colon = langOrType.indexOf( ':' ); + return colon < 0 + ? LiteralLabelFactory.create( content, langOrType, false ) + : LiteralLabelFactory.createLiteralLabel( content, "", NodeFactory.getType( pm.expandPrefix( langOrType ) ) ) + ; + } + + public static LiteralLabel newString( PrefixMapping pm, char quote, String nodeString ) + { + int close = nodeString.lastIndexOf( quote ); + return literal( pm, nodeString.substring( 1, close ), nodeString.substring( close + 1 ) ); + } + + /** + Utility factory as for create(String), but allowing the PrefixMapping to + be specified explicitly. + */ + public static Triple createTriple( PrefixMapping pm, String fact ) + { + StringTokenizer st = new StringTokenizer( fact ); + Node sub = create( pm, st.nextToken() ); + Node pred = create( pm, st.nextToken() ); + Node obj = create( pm, st.nextToken() ); + return Triple.create( sub, pred, obj ); + } + + /** + Utility factory method for creating a triple based on the content of an + "S P O" string. The S, P, O are processed by Node.create, see which for + details of the supported syntax. This method exists to support test code. + Nodes are interpreted using the Standard prefix mapping. + */ + + public static Triple createTriple( String fact ) + { return createTriple( PrefixMapping.Standard, fact ); } + } Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/NodeCreateUtils.java ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/RecordingListener.java URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/RecordingListener.java?rev=1517755&view=auto ============================================================================== --- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/RecordingListener.java (added) +++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/RecordingListener.java Tue Aug 27 06:01:01 2013 @@ -0,0 +1,121 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.hp.hpl.jena.graph; + +import java.util.ArrayList ; +import java.util.Arrays ; +import java.util.Iterator ; +import java.util.List ; + +import org.junit.Assert ; +import com.hp.hpl.jena.graph.Graph ; +import com.hp.hpl.jena.graph.GraphListener ; +import com.hp.hpl.jena.graph.Triple ; + +/** + This testing listener records the event names and data, and provides + a method for comparing the actual with the expected history. +*/ +public class RecordingListener implements GraphListener + { + public List history = new ArrayList(); + + @Override + public void notifyAddTriple( Graph g, Triple t ) + { record( "add", g, t ); } + + @Override + public void notifyAddArray( Graph g, Triple [] triples ) + { record( "add[]", g, triples ); } + + @Override + public void notifyAddList( Graph g, List triples ) + { record( "addList", g, triples ); } + + @Override + public void notifyAddIterator( Graph g, Iterator it ) + { record( "addIterator", g, GraphTestUtils.iteratorToList( it ) ); } + + @Override + public void notifyAddGraph( Graph g, Graph added ) + { record( "addGraph", g, added ); } + + @Override + public void notifyDeleteTriple( Graph g, Triple t ) + { record( "delete", g, t ); } + + @Override + public void notifyDeleteArray( Graph g, Triple [] triples ) + { record( "delete[]", g, triples ); } + + @Override + public void notifyDeleteList( Graph g, List triples ) + { record( "deleteList", g, triples ); } + + @Override + public void notifyDeleteIterator( Graph g, Iterator it ) + { record( "deleteIterator", g, GraphTestUtils.iteratorToList( it ) ); } + + @Override + public void notifyDeleteGraph( Graph g, Graph removed ) + { record( "deleteGraph", g, removed ); } + + @Override + public void notifyEvent( Graph source, Object event ) + { record( "someEvent", source, event ); } + + protected void record( String tag, Object x, Object y ) + { history.add( tag ); history.add( x ); history.add( y ); } + + protected void record( String tag, Object info ) + { history.add( tag ); history.add( info ); } + + public void clear() + { history.clear(); } + + public boolean has( List things ) + { return Arrays.deepEquals(history.toArray(), things.toArray() ); } + + public boolean hasStart( List L ) + { return L.size() <= history.size() && L.equals( history.subList( 0, L.size() ) ); } + + public boolean hasEnd( List L ) + { return L.size() <= history.size() && L.equals( history.subList( history.size() - L.size(), history.size() ) ); } + + public boolean has( Object [] things ) + { return Arrays.deepEquals(history.toArray(), things ); } + + public void assertHas( List things ) + { if (has( things ) == false) Assert.fail( "expected " + things + " but got " + history ); } + + public void assertHas( Object [] things ) + { assertHas( Arrays.asList( things ) ); } + + public void assertHasStart( Object [] start ) + { + List L = Arrays.asList( start ); + if (hasStart( L ) == false) Assert.fail( "expected " + L + " at the beginning of " + history ); + } + + public void assertHasEnd( Object [] end ) + { + List L = Arrays.asList( end ); + if (hasEnd( L ) == false) Assert.fail( "expected " + L + " at the end of " + history ); + } + } Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/RecordingListener.java ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/impl/TestCollectionGraph.java URL: http://svn.apache.org/viewvc/jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/impl/TestCollectionGraph.java?rev=1517755&view=auto ============================================================================== --- jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/impl/TestCollectionGraph.java (added) +++ jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/impl/TestCollectionGraph.java Tue Aug 27 06:01:01 2013 @@ -0,0 +1,43 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.hp.hpl.jena.graph.impl; + +import java.util.HashSet; + +import com.hp.hpl.jena.graph.GraphProducerInterface; +import com.hp.hpl.jena.graph.AbstractGraphTest; +import com.hp.hpl.jena.graph.Graph; +import com.hp.hpl.jena.graph.Triple; +import com.hp.hpl.jena.graph.impl.CollectionGraph; + +public class TestCollectionGraph extends AbstractGraphTest { + + public TestCollectionGraph() { + super( new GraphProducer() ); + } + + public static class GraphProducer implements GraphProducerInterface + { + @Override + public Graph newGraph() { + return new CollectionGraph( new HashSet() ); + } + } + +} Propchange: jena/Experimental/new-test/src/test/java/com/hp/hpl/jena/graph/impl/TestCollectionGraph.java ------------------------------------------------------------------------------ svn:mime-type = text/plain