jena-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From rve...@apache.org
Subject [46/50] [abbrv] jena git commit: JENA-808 : Upgrades for composit graphs. Remove deprecation.
Date Mon, 10 Nov 2014 10:53:51 GMT
JENA-808 : Upgrades for composit graphs.  Remove deprecation.

Project: http://git-wip-us.apache.org/repos/asf/jena/repo
Commit: http://git-wip-us.apache.org/repos/asf/jena/commit/bc6c1fb7
Tree: http://git-wip-us.apache.org/repos/asf/jena/tree/bc6c1fb7
Diff: http://git-wip-us.apache.org/repos/asf/jena/diff/bc6c1fb7

Branch: refs/heads/JENA-507
Commit: bc6c1fb7a7c5b38120b6bdfdd5ef97d17ce3b82e
Parents: b3f4e4c
Author: Andy Seaborne <andy@apache.org>
Authored: Sat Nov 8 19:37:17 2014 +0000
Committer: Andy Seaborne <andy@apache.org>
Committed: Sat Nov 8 19:37:17 2014 +0000

----------------------------------------------------------------------
 .../com/hp/hpl/jena/graph/compose/Delta.java    |  43 ++++--
 .../hp/hpl/jena/graph/compose/Difference.java   |   1 -
 .../hp/hpl/jena/graph/compose/Intersection.java |   4 +-
 .../hpl/jena/graph/compose/test/TestDelta.java  | 149 ++++++++++++++-----
 .../jena/graph/compose/test/TestDifference.java | 119 +++++++++++----
 .../hpl/jena/graph/compose/test/TestDyadic.java |   5 +-
 .../graph/compose/test/TestIntersection.java    | 138 +++++++++++------
 .../jena/graph/compose/test/TestPackage.java    |   9 +-
 .../hpl/jena/graph/compose/test/TestUnion.java  | 120 +++++++++++----
 9 files changed, 415 insertions(+), 173 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/jena/blob/bc6c1fb7/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Delta.java
----------------------------------------------------------------------
diff --git a/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Delta.java b/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Delta.java
index a977dfb..b7451f6 100644
--- a/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Delta.java
+++ b/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Delta.java
@@ -19,38 +19,46 @@
 package com.hp.hpl.jena.graph.compose ;
 
 import com.hp.hpl.jena.graph.* ;
+import com.hp.hpl.jena.graph.impl.SimpleEventManager;
 import com.hp.hpl.jena.util.iterator.* ;
 
 /**
  * Graph operation for wrapping a base graph and leaving it unchanged while
  * recording all the attempted updates for later access.
+ * 
+ * The behavior of this class is not well defined if triples are added to or
+ * removed from the base graph, the additions graph, or the deletions graph
+ * while this graph is in use.
  */
 
-@Deprecated
-public class Delta extends Dyadic implements Graph
+public class Delta extends CompositionBase implements Graph
 {
     private Graph base ;
+    private Graph additions ;
+    private Graph deletions ;
 
     public Delta(Graph base)
     {
-        super(Factory.createGraphMem(), Factory.createGraphMem()) ;
+        super() ;
         this.base = base ;
+        this.additions = Factory.createGraphMem();
+        this.deletions = Factory.createGraphMem();
     }
 
     /**
-     * Answer the graph of all triples added
+     * Answer the graph of all triples added.
      */
     public Graph getAdditions()
     {
-        return L ;
+        return additions ;
     }
 
     /**
-     * Answer the graph of all triples removed
+     * Answer the graph of all triples removed.
      */
     public Graph getDeletions()
     {
-        return R ;
+        return deletions ;
     }
 
     /**
@@ -60,9 +68,9 @@ public class Delta extends Dyadic implements Graph
     @Override
     public void performAdd(Triple t)
     {
-        if (!base.contains(t)) 
-            L.add(t) ;
-        R.delete(t) ;
+        if (!base.contains(t))
+            additions.add(t) ;
+        deletions.delete(t) ;
     }
 
     /**
@@ -71,9 +79,9 @@ public class Delta extends Dyadic implements Graph
     @Override
     public void performDelete(Triple t)
     {
-        L.delete(t) ;
-        if (base.contains(t)) 
-            R.add(t) ;
+        additions.delete(t) ;
+        if (base.contains(t))
+            deletions.add(t) ;
     }
 
     /**
@@ -81,9 +89,10 @@ public class Delta extends Dyadic implements Graph
      * add the ones that have been added.
      */
     @Override
-    protected ExtendedIterator<Triple> _graphBaseFind(TripleMatch tm)
+    protected ExtendedIterator<Triple> graphBaseFind(TripleMatch tm)
     {
-        return base.find(tm).filterDrop(ifIn(GraphUtil.findAll(R))).andThen(L.find(tm)) ;
+        ExtendedIterator<Triple> iterator = base.find(tm).filterDrop(ifIn(GraphUtil.findAll(deletions))).andThen(additions.find(tm))
;
+        return SimpleEventManager.notifyingRemove( this, iterator ) ;
     }
 
     @Override
@@ -91,11 +100,13 @@ public class Delta extends Dyadic implements Graph
     {
         super.close() ;
         base.close() ;
+        additions.close() ;
+        deletions.close() ;
     }
 
     @Override
     public int graphBaseSize()
     {
-        return base.size() + L.size() - R.size() ;
+        return base.size() + additions.size() - deletions.size() ;
     }
 }

http://git-wip-us.apache.org/repos/asf/jena/blob/bc6c1fb7/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Difference.java
----------------------------------------------------------------------
diff --git a/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Difference.java b/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Difference.java
index 38e3d67..8aa9e72 100644
--- a/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Difference.java
+++ b/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Difference.java
@@ -25,7 +25,6 @@ import com.hp.hpl.jena.util.iterator.*;
     Class representing the dynamic set difference L - R of two graphs. This is updatable;
     the updates are written through to one or other of the base graphs.
 */
-@Deprecated
 public class Difference extends Dyadic implements Graph 
 	{
     /**

http://git-wip-us.apache.org/repos/asf/jena/blob/bc6c1fb7/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Intersection.java
----------------------------------------------------------------------
diff --git a/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Intersection.java b/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Intersection.java
index f04df47..c917bc8 100644
--- a/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Intersection.java
+++ b/jena-core/src/main/java/com/hp/hpl/jena/graph/compose/Intersection.java
@@ -29,10 +29,8 @@ import com.hp.hpl.jena.util.iterator.*;
 
 
 /**
-    an implementation of a dynamic intersection of two models.
+    The dynamic intersection of two graphs L and R. <code>add()</code> affects
both L and R, whereas <code>delete()</code> affects L only.
 */
-
-@Deprecated
 public class Intersection extends Dyadic implements Graph
 	{
 	public Intersection( Graph L, Graph R )

http://git-wip-us.apache.org/repos/asf/jena/blob/bc6c1fb7/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDelta.java
----------------------------------------------------------------------
diff --git a/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDelta.java b/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDelta.java
index 2be1574..2eb517f 100755
--- a/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDelta.java
+++ b/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDelta.java
@@ -22,45 +22,116 @@ import junit.framework.TestSuite ;
 
 import com.hp.hpl.jena.graph.Graph ;
 import com.hp.hpl.jena.graph.compose.Delta ;
+import com.hp.hpl.jena.graph.test.AbstractTestGraph;
 
-@SuppressWarnings("deprecation")
-public class TestDelta extends TestDyadic 
-	{
-		
-	public TestDelta( String name )
-		{ super( name ); }
-		
-	public static TestSuite suite()
-    	{ return new TestSuite( TestDelta.class ); }			
-    	
-	@Override
-	public Graph getGraph()
-	{
-		Graph gBase = graphWith( "" );
+public class TestDelta extends AbstractTestGraph
+{
+
+    private static final String DEFAULT_TRIPLES = "x R y; p S q";
+
+    public TestDelta( String name )
+    {
+        super( name );
+    }
+
+    public static TestSuite suite()
+    {
+        return new TestSuite( TestDelta.class );
+    }
+
+    @Override
+    public Graph getGraph()
+    {
+        Graph gBase = graphWith( "" );
         return new Delta( gBase ); 
-	}
-	
-	public void testDelta() 
-		{
-		Graph x = graphWith( "x R y" );
-		assertContains( "x", "x R y", x );
-		x.delete( triple( "x R y" ) );
-		assertOmits( "x", x, "x R y" );
-	/* */	
-		Graph base = graphWith( "x R y; p S q; I like cheese; pins pop balloons" );
-		Graph save = graphWith( "x R y; p S q; I like cheese; pins pop balloons" );
+    }
+
+    public void testDeltaMirrorsBase()
+    {
+        Graph base = graphWith( DEFAULT_TRIPLES );
+        Delta delta = new Delta( base );
+        assertIsomorphic(base, delta);
+    }
+
+    public void testAddGoesToAdditions()
+    {
+        Graph base = graphWith( DEFAULT_TRIPLES );
         Delta delta = new Delta( base );
-		assertContainsAll( "Delta", delta, "x R y; p S q; I like cheese; pins pop balloons" );
-		assertContainsAll( "Delta", base, "x R y; p S q; I like cheese; pins pop balloons" );
-	/* */
-		delta.add( triple( "pigs fly winglessly" ) );
-		delta.delete( triple( "I like cheese" ) );
-	/* */
-		assertContainsAll( "changed Delta", delta, "x R y; p S q; pins pop balloons; pigs fly winglessly"
);
-		assertOmits( "changed delta", delta, "I like cheese" );
-		assertContains( "delta additions", "pigs fly winglessly", delta.getAdditions() );
-		assertOmits( "delta additions", delta.getAdditions(), "I like cheese" );
-		assertContains( "delta deletions", "I like cheese", delta.getDeletions() );
-		assertOmits( "delta deletions", delta.getDeletions(), "pigs fly winglessly" );
-		}
-	}
+        delta.add( triple( "x R z" ) );
+        assertIsomorphic(graphWith( DEFAULT_TRIPLES ), base);
+        assertIsomorphic(graphWith( "x R z" ), delta.getAdditions());
+        assertIsomorphic(graphWith( "" ), delta.getDeletions());
+        assertIsomorphic(graphWith( DEFAULT_TRIPLES + "; x R z" ), delta);
+    }
+
+    public void testDeleteGoesToDeletions()
+    {
+        Graph base = graphWith( DEFAULT_TRIPLES );
+        Delta delta = new Delta( base );
+        delta.delete( triple( "x R y" ) );
+        assertIsomorphic(graphWith( DEFAULT_TRIPLES ), base);
+        assertIsomorphic(graphWith( "x R y" ), delta.getDeletions());
+        assertIsomorphic(graphWith( "p S q" ), delta);
+    }
+
+    public void testRedundantAddNoOp()
+    {
+        Graph base = graphWith( DEFAULT_TRIPLES );
+        Delta delta = new Delta( base ) ;
+        delta.add( triple( "x R y" ) ) ;
+        assertIsomorphic(graphWith( DEFAULT_TRIPLES ), base);
+        assertIsomorphic(graphWith( "" ), delta.getAdditions());
+        assertIsomorphic(graphWith( "" ), delta.getDeletions());
+        assertIsomorphic(graphWith( DEFAULT_TRIPLES ), delta);
+    }
+
+    public void testRedundantDeleteNoOp()
+    {
+        Graph base = graphWith( DEFAULT_TRIPLES ) ;
+        Delta delta = new Delta( base ) ;
+        delta.delete( triple( "a T b" ) ) ;
+        assertIsomorphic(graphWith( DEFAULT_TRIPLES ), base);
+        assertIsomorphic(graphWith( "" ), delta.getAdditions());
+        assertIsomorphic(graphWith( "" ), delta.getDeletions());
+        assertIsomorphic(graphWith( DEFAULT_TRIPLES ), delta);
+    }
+
+    public void testAddThenDelete()
+    {
+        Graph base = graphWith( DEFAULT_TRIPLES ) ;
+        Delta delta = new Delta( base ) ;
+        delta.add( triple( "a T b" ) ) ;
+        delta.delete( triple( "a T b" ) ) ;
+        assertIsomorphic(graphWith( DEFAULT_TRIPLES ), base);
+        assertIsomorphic(graphWith( "" ), delta.getAdditions());
+        assertIsomorphic(graphWith( "" ), delta.getDeletions());
+        assertIsomorphic(graphWith( DEFAULT_TRIPLES ), delta);
+    }
+
+    public void testDeleteThenAdd()
+    {
+        Graph base = graphWith( DEFAULT_TRIPLES ) ;
+        Delta delta = new Delta( base ) ;
+        delta.delete( triple( "p S q" ) ) ;
+        delta.add( triple( "p S q" ) ) ;
+        assertIsomorphic(graphWith( DEFAULT_TRIPLES ), base);
+        assertIsomorphic(graphWith( "" ), delta.getAdditions());
+        assertIsomorphic(graphWith( "" ), delta.getDeletions());
+        assertIsomorphic(graphWith( DEFAULT_TRIPLES ), delta);
+    }
+
+    public void testAddAndDelete()
+    {
+        Graph base = graphWith( DEFAULT_TRIPLES ) ;
+        Delta delta = new Delta( base ) ;
+        delta.delete( triple( "a T b" ) ) ;
+        delta.add( triple( "x R z" ) ) ;
+        delta.delete( triple( "p S q" ) ) ;
+        delta.add( triple( "a T b" ) ) ;
+        assertIsomorphic(graphWith( DEFAULT_TRIPLES ), base);
+        assertIsomorphic(graphWith( "a T b; x R z" ), delta.getAdditions());
+        assertIsomorphic(graphWith( "p S q" ), delta.getDeletions());
+        assertIsomorphic(graphWith( "x R y ; x R z; a T b" ), delta);
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/bc6c1fb7/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDifference.java
----------------------------------------------------------------------
diff --git a/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDifference.java
b/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDifference.java
index 6af2c9c..0da6e70 100755
--- a/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDifference.java
+++ b/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDifference.java
@@ -23,34 +23,93 @@ import junit.framework.TestSuite ;
 import com.hp.hpl.jena.graph.Graph ;
 import com.hp.hpl.jena.graph.compose.Difference ;
 
-@SuppressWarnings("deprecation")
-public class TestDifference extends TestDyadic 
-	{
-	public TestDifference( String name )
-		{ super( name ); }
-			
-	public static TestSuite suite()
-    	{ return new TestSuite( TestDifference.class ); }	
-    	
-	@Override
-	public Graph getGraph()
-	{
-		Graph gBase = graphWith( "" ), g1 = graphWith( "" );
+public class TestDifference extends TestDyadic
+{
+    public TestDifference( String name )
+    { super( name ); }
+
+    public static TestSuite suite()
+    { return new TestSuite( TestDifference.class ); }	
+
+    @Override
+    public Graph getGraph()
+    {
+        Graph gBase = graphWith( "" ), g1 = graphWith( "" );
         return new Difference( gBase, g1 ); 
-	}
-	
-    public void testDifference()
-		{
-        Graph g1 = graphWith( "x R y; p R q" );
-        Graph g2 = graphWith( "r A s; x R y" );
-        Difference d = new Difference( g1, g2 );
-        assertOmits( "Difference", d, "x R y" );
-        assertContains( "Difference", "p R q", d ); 
-		assertOmits( "Difference", d, "r A s" );
-        if (d.size() != 1)
-            fail( "oops: size of difference is not 1" );
-        d.add( triple( "cats eat cheese" ) );
-        assertContains( "Difference.L", "cats eat cheese", g1 );
-        assertOmits( "Difference.R", g2, "cats eat cheese" );
-		}
-	}
+    }
+
+    public Difference differenceOf(String s1, String s2) {
+        return new Difference( graphWith( s1 ), graphWith( s2 ) );
+    }
+
+    public void testStaticDifference() {
+        assertIsomorphic( differenceOf( "", "" ), graphWith( "" ) );
+        assertIsomorphic( differenceOf( "x R y", "" ), graphWith( "x R y" ) );
+        assertIsomorphic( differenceOf( "", "x R y" ), graphWith( "" ) );
+        assertIsomorphic( differenceOf( "x R y", "x R y" ), graphWith( "" ) );
+        assertIsomorphic( differenceOf( "x R y; p R q", "r A s; x R y" ), graphWith( "p R
q" ) );
+    }
+    
+    public void testDifferenceReflectsChangesToOperands() {
+        Graph l = graphWith( "x R y" );
+        Graph r = graphWith( "x R y" );
+        Difference diff = new Difference( l, r );
+        assertIsomorphic( diff, graphWith( "" ) );
+        r.delete( triple( "x R y" ) );
+        assertIsomorphic( diff, graphWith( "x R y" ) );
+        l.add( triple( "x R z" ) );
+        assertIsomorphic( diff, graphWith( "x R y; x R z" ) );
+        r.add( triple( "x R z" ) );
+        assertIsomorphic( diff, graphWith( "x R y" ) );
+    }
+
+    public void testAdd() {
+        Graph l = graphWith( "x R y" );
+        Graph r = graphWith( "x R y; x R z" );
+        Difference diff = new Difference( l, r );
+        assertIsomorphic( diff, graphWith( "" ) );
+        
+        // case 1: add to the left operand
+        diff.add( triple( "p S q" ) );
+        assertIsomorphic( diff, graphWith( "p S q" ) );
+        assertIsomorphic( l, graphWith( "x R y; p S q" ) );
+        assertIsomorphic( r, graphWith( "x R y; x R z" ) );
+        
+        // case 2: remove from the right, and add to the left operand
+        diff.add( triple( "x R z" ) );
+        assertIsomorphic( diff, graphWith( "x R z; p S q" ) );
+        assertIsomorphic( l, graphWith( "x R y; x R z; p S q" ) );
+        assertIsomorphic( r, graphWith( "x R y" ) );
+        
+        // case 3: remove from the right operand
+        diff.add( triple( "x R y" ) );
+        assertIsomorphic( diff, graphWith( "x R y; x R z; p S q" ) );
+        assertIsomorphic( l, graphWith( "x R y; x R z; p S q" ) );
+        assertIsomorphic( r, graphWith( "" ) );
+    }
+    
+    public void testDelete() {
+        Graph l = graphWith( "x R y; x R z" );
+        Graph r = graphWith( "x R y" );
+        Difference diff = new Difference( l, r );
+        assertIsomorphic( diff, graphWith( "x R z" ) );
+        
+        // case 1: remove non-existent triple is a no-op
+        diff.delete( triple( "p S q" ) );
+        assertIsomorphic( diff, graphWith( "x R z" ) );
+        assertIsomorphic( l, graphWith( "x R y; x R z" ) );
+        assertIsomorphic( r, graphWith( "x R y" ) );
+        
+        // case 2: remove triple that exists in both - removes from left
+        diff.delete( triple( "x R y" ) );
+        assertIsomorphic( diff, graphWith( "x R z" ) );
+        assertIsomorphic( l, graphWith( "x R z" ) );
+        assertIsomorphic( r, graphWith( "x R y" ) );
+        
+        // case 3: remove triple that exists in left is removed
+        diff.delete( triple( "x R z" ) );
+        assertIsomorphic( diff, graphWith( "" ) );
+        assertIsomorphic( l, graphWith( "" ) );
+        assertIsomorphic( r, graphWith( "x R y" ) );
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/bc6c1fb7/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDyadic.java
----------------------------------------------------------------------
diff --git a/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDyadic.java b/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDyadic.java
index 6568157..bf802cd 100755
--- a/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDyadic.java
+++ b/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestDyadic.java
@@ -47,7 +47,10 @@ public abstract class TestDyadic extends AbstractTestGraph
 			};
 		}
 	
-	public void testDyadic() 
+	/**
+	 * Test the things() iterator generating utility function.
+	 */
+	public void testThings()
 		{
 		ExtendedIterator<String> it1 = things( "now is the time" );
 		ExtendedIterator<String> it2 = things( "now is the time" );

http://git-wip-us.apache.org/repos/asf/jena/blob/bc6c1fb7/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestIntersection.java
----------------------------------------------------------------------
diff --git a/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestIntersection.java
b/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestIntersection.java
index ed53373..cf519b4 100755
--- a/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestIntersection.java
+++ b/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestIntersection.java
@@ -18,50 +18,104 @@
 
 package com.hp.hpl.jena.graph.compose.test;
 
-import junit.framework.TestSuite ;
+import junit.framework.TestSuite;
 
-import com.hp.hpl.jena.graph.Graph ;
-import com.hp.hpl.jena.graph.GraphUtil ;
-import com.hp.hpl.jena.graph.compose.Intersection ;
+import com.hp.hpl.jena.graph.Graph;
+import com.hp.hpl.jena.graph.compose.Intersection;
 
-@SuppressWarnings("deprecation")
 public class TestIntersection extends TestDyadic
-	{
-	public TestIntersection( String name )
-		{ super( name ); }
-		
-	public static TestSuite suite()
-    	{ return new TestSuite( TestIntersection.class ); }	
-   
-	@Override
-	public Graph getGraph()
-	{
-		Graph gBase = graphWith( "" ), g1 = graphWith( "" );
+{
+    public TestIntersection( String name )
+    { super( name ); }
+
+    public static TestSuite suite()
+    { return new TestSuite( TestIntersection.class ); }
+
+    @Override
+    public Graph getGraph()
+    {
+        Graph gBase = graphWith( "" ), g1 = graphWith( "" );
         return new Intersection( gBase, g1 ); 
-	}
-	
-	public void testIntersection()
-		{
-        Graph g1 = graphWith( "x R y; p R q" );
-        Graph g2 = graphWith( "r A s; x R y" );
-        Intersection i = new Intersection( g1, g2 );
-        assertContains( "Intersection", "x R y", i );
- 		assertOmits( "Intersection", i, "p R q" );
-		assertOmits( "Intersection", i, "r A s" );
-        if (i.size() != 1)
-            fail( "oops: size of intersection is not 1" );
-        i.add( triple( "cats eat cheese" ) );
-        assertContains( "Intersection.L", "cats eat cheese", g1 );
-        assertContains( "Intersection.R", "cats eat cheese", g2 );
-        }
+    }
+
+    public Intersection intersectionOf(String s1, String s2) {
+        return new Intersection( graphWith( s1 ), graphWith( s2 ) );
+    }
+
+    public void testStaticIntersection() {
+        assertIsomorphic( graphWith( "" ), intersectionOf( "", "" ) );
+        assertIsomorphic( graphWith( "" ), intersectionOf( "x R y", "" ) );
+        assertIsomorphic( graphWith( "" ), intersectionOf( "", "x R y" ) );
+        assertIsomorphic( graphWith( "x R y" ), intersectionOf( "x R y", "x R y" ) );
+        assertIsomorphic( graphWith( "x R y" ), intersectionOf( "x R y; p R q", "r A s; x
R y" ) );
+    }
+
+    public void testIntersectionReflectsChangesToOperands() {
+        Graph l = graphWith( "x R y" );
+        Graph r = graphWith( "p S q" );
+        Intersection isec = new Intersection( l, r );
+        assertIsomorphic( graphWith( "" ), isec );
+
+        // add to the left what is already in the right
+        l.add( triple( "p S q" ) );
+        assertIsomorphic( graphWith( "p S q" ), isec );
+
+        // add to the right what is already in the left
+        r.add( triple( "x R y" ) );
+        assertIsomorphic( graphWith( "p S q; x R y" ), isec );
+
+        // add to a single graph is not reflected
+        l.add( triple( "p S o" ) );
+        r.add( triple( "x R z" ) );
+        assertIsomorphic( graphWith( "p S q; x R y" ), isec );
+
+        // remove from the left
+        l.delete( triple( "x R y" ) );
+        assertIsomorphic( graphWith( "p S q" ), isec );
+
+        // remove from the right
+        r.delete( triple( "p S q" ) );
+        assertIsomorphic( graphWith( "" ), isec );
+    }
+
+    public void testAdd() {
+        Graph l = graphWith( "x R y" );
+        Graph r = graphWith( "p S q" );
+        Intersection isec = new Intersection( l, r );
+        assertIsomorphic( graphWith( "" ), isec );
+
+        isec.add( triple( "r A s" ) );
+        assertIsomorphic( graphWith( "r A s" ), isec );
+        assertIsomorphic( graphWith( "x R y; r A s" ), l );
+        assertIsomorphic( graphWith( "p S q; r A s" ), r );
+
+        isec.add( triple ( "x R y" ) );
+        assertIsomorphic( graphWith( "r A s; x R y" ), isec );
+        assertIsomorphic( graphWith( "x R y; r A s" ), l );
+        assertIsomorphic( graphWith( "p S q; r A s; x R y" ), r );
+
+        isec.add( triple ( "p S q" ) );
+        assertIsomorphic( graphWith( "p S q; r A s; x R y" ), isec );
+        assertIsomorphic( graphWith( "p S q; r A s; x R y" ), l );
+        assertIsomorphic( graphWith( "p S q; r A s; x R y" ), r );
+    }
     
-    public void testDeleteDoesNotUpdateR()
-        {
-    	Graph L = graphWith( "a pings b; b pings c; c pings a" );
-    	Graph R = graphWith( "c pings a; b pings c; x captures y" );
-    	Graph join = new Intersection( L, R );
-    	GraphUtil.deleteFrom(L, R) ;
-        assertIsomorphic( "R should not change", graphWith( "c pings a; b pings c; x captures
y" ), R );
-        assertIsomorphic( graphWith( "a pings b" ), L );
-		}
-	}
+    public void testDelete() {
+        Graph l = graphWith( "r A s; x R y" );
+        Graph r = graphWith( "x R y; p S q" );
+        Intersection isec = new Intersection( l, r );
+        assertIsomorphic( graphWith( "x R y" ), isec );
+
+        // removing non-contained triples is a no-op
+        isec.delete( triple( "r A s" ) );
+        assertIsomorphic( graphWith( "r A s; x R y" ), l);
+        isec.delete( triple( "p S q" ) );
+        assertIsomorphic( graphWith( "x R y; p S q" ), r);
+
+        // removing a contained triple removes it from the left operand
+        isec.delete( triple( "x R y" ) );
+        assertIsomorphic( graphWith( "" ), isec );
+        assertIsomorphic( graphWith( "r A s" ), l );
+        assertIsomorphic( graphWith( "x R y; p S q" ), r );
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/bc6c1fb7/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestPackage.java
----------------------------------------------------------------------
diff --git a/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestPackage.java b/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestPackage.java
index a877875..ec1c892 100755
--- a/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestPackage.java
+++ b/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestPackage.java
@@ -32,14 +32,9 @@ import junit.framework.*;
 
 public class TestPackage extends TestCase {
     
-    @SuppressWarnings("deprecation")
     public static TestSuite suite() {
     	TestSuite result = new TestSuite();
-    	/*
-        suite( result, Intersection.class );
-        suite( result, Union.class );
-        suite( result, Difference.class );
-        */
+
     	GraphModelFactory gmf = new GraphModelFactory(){
 
 			@Override
@@ -81,7 +76,6 @@ public class TestPackage extends TestCase {
     	{
     		result.addTest( atp.testAt(i) );
     	}
-    	//suite.addTestSuite( new PlainModelTestSuite( ))
     /* */
         result.addTest( TestDelta.suite() );
         result.addTest( TestUnion.suite() );
@@ -95,7 +89,6 @@ public class TestPackage extends TestCase {
         return  result;
     }
 
-    
     private static abstract class GraphModelFactory implements TestingModelFactory
 	{
     	abstract Graph getGraph();

http://git-wip-us.apache.org/repos/asf/jena/blob/bc6c1fb7/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestUnion.java
----------------------------------------------------------------------
diff --git a/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestUnion.java b/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestUnion.java
index e86cad8..cfc8e8e 100755
--- a/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestUnion.java
+++ b/jena-core/src/test/java/com/hp/hpl/jena/graph/compose/test/TestUnion.java
@@ -24,37 +24,91 @@ import com.hp.hpl.jena.graph.Graph ;
 import com.hp.hpl.jena.graph.compose.Union ;
 
 public class TestUnion extends TestDyadic 
-	{
-	public TestUnion( String name )
-		{ super( name ); }
-			
-	public static TestSuite suite()
-    	{ return new TestSuite( TestUnion.class ); }
-    	
-	@Override
-	public Graph getGraph()
-	{
-		Graph gBase = graphWith( "" ), g1 = graphWith( "" );
+{
+    public TestUnion( String name )
+    { super( name ); }
+
+    public static TestSuite suite()
+    { return new TestSuite( TestUnion.class ); }
+
+    @Override
+    public Graph getGraph()
+    {
+        Graph gBase = graphWith( "" ), g1 = graphWith( "" );
         return new Union( gBase, g1 ); 
-	}
-	
-	public void testUnion() 
-		{
-        Graph g1 = graphWith( "x R y; p R q" );
-        Graph g2 = graphWith( "r A s; x R y" );
-        Union u = new Union( g1, g2 );
-        assertContains( "Union", "x R y", u );
-        assertContains( "Union", "p R q", u );
-        assertContains( "Union", "r A s", u );
-        if (u.size() != 3)
-            fail( "oops: size of union is not 3" );
-        u.add( triple( "cats eat cheese" ) );
-        assertContains( "Union", "cats eat cheese", u );
-        if 
-        	(
-        	contains( g1, "cats eat cheese" ) == false
-        	&& contains( g2, "cats eat cheese" ) == false
-        	)
-            fail( "oops: neither g1 nor g2 contains `cats eat cheese`" );
-		}
-	}
+    }
+
+    public Union unionOf( String s1, String s2 )
+    {
+        return new Union( graphWith( s1 ), graphWith ( s2 ) );
+    }
+
+    public void testStaticUnion()
+    {
+        assertIsomorphic(graphWith( "" ), unionOf( "", "" ));
+        assertIsomorphic(graphWith( "x R y" ), unionOf( "x R y", "" ) );
+        assertIsomorphic(graphWith( "x R y" ), unionOf( "", "x R y" ) );
+        assertIsomorphic(graphWith( "x R y; x R z" ), unionOf( "x R y", "x R z" ) );
+        assertIsomorphic(graphWith( "x R y" ), unionOf( "x R y", "x R y" ) );
+    }
+
+    public void testUnionReflectsChangesToOperands() {
+        Graph l = graphWith( "x R y" );
+        Graph r = graphWith( "x R y" );
+        Union u = new Union( l, r );
+
+        assertIsomorphic( graphWith( "x R y" ), u );
+
+        l.add( triple( "x R z" ) );
+        assertIsomorphic( graphWith( "x R y; x R z" ), u );
+
+        l.delete( triple( "x R y" ) );
+        assertIsomorphic( graphWith( "x R y; x R z" ), u );
+
+        r.add( triple( "p S q" ) );
+        assertIsomorphic( graphWith( "x R y; x R z; p S q" ), u );
+
+        r.delete( triple( "x R y" ) );
+        assertIsomorphic( graphWith( "x R z; p S q" ), u );
+    }
+
+    public void testAdd() {
+        Graph l = graphWith( "x R y" );
+        Graph r = graphWith( "x R y; p S q" );
+        Union u = new Union( l, r );
+
+        u.add( triple("x R y") );
+        assertIsomorphic( graphWith( "x R y" ), l);
+        assertIsomorphic( graphWith( "x R y; p S q" ), r);
+
+        u.add( triple("p S q") );
+        assertIsomorphic( graphWith( "x R y; p S q" ), l);
+        assertIsomorphic( graphWith( "x R y; p S q" ), r);
+
+        u.add( triple("r A s") );
+        assertIsomorphic( graphWith( "x R y; p S q; r A s" ), l);
+        assertIsomorphic( graphWith( "x R y; p S q" ), r);
+    }
+
+    public void testDelete() {
+        Graph l = graphWith( "x R y; x R z" );
+        Graph r = graphWith( "x R y; p S q" );
+        Union u = new Union( l, r );
+
+        u.delete( triple( "r A s" ) );
+        assertIsomorphic( graphWith( "x R y; x R z" ), l);
+        assertIsomorphic( graphWith( "x R y; p S q" ), r);
+
+        u.delete( triple( "x R z" ) );
+        assertIsomorphic( graphWith( "x R y" ), l);
+        assertIsomorphic( graphWith( "x R y; p S q" ), r);
+
+        u.delete( triple ( "p S q" ) );
+        assertIsomorphic( graphWith( "x R y" ), l);
+        assertIsomorphic( graphWith( "x R y" ), r);
+
+        u.delete( triple ( "x R y" ) );
+        assertIsomorphic( graphWith( "" ), l);
+        assertIsomorphic( graphWith( "" ), r);
+    }
+}


Mime
View raw message