abstracttestgraph.java

Jena推理机

        bu.add( graphToAdd, withReifications );
        assertIsomorphic
            ( 
            withReifications ? getReificationTriples( addedReifier ) : graphWith( "" ), 
            getReificationTriples( updatedReifier ) 
            );
        }
        
    protected void xSPOyXYZ( Reifier r )
        {
        xSPO( r );
        r.reifyAs( Node.create( "y" ), Triple.create( "X Y Z" ) );       
        }

    protected void aABC( Reifier r )
        { r.reifyAs( Node.create( "a" ), Triple.create( "A B C" ) ); }
        
    protected void xSPO( Reifier r )
        { r.reifyAs( Node.create( "x" ), Triple.create( "S P O" ) ); }
        
    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" );
        }
    
    public void testRemove( String findRemove, String findCheck )
        {
        Graph g = getGraphWith( "S P O" );
        ExtendedIterator it = g.find( Triple.create( findRemove ) );
        try 
            {
            it.next(); it.remove(); it.close();
            assertEquals( "remove with " + findRemove + ":", 0, g.size() );
            assertFalse( g.contains( Triple.create( findCheck ) ) );
            }
        catch (UnsupportedOperationException e) {
            it.close();
            assertFalse( g.getCapabilities().iteratorRemoveAllowed() ); 
        }
        it.close();
        }
    
    public void testBulkRemoveWithReification()
        {        
        testBulkUpdateRemoveWithReification( true );
        testBulkUpdateRemoveWithReification( false );
        }
        
    public void testBulkUpdateRemoveWithReification( boolean withReifications )
        {
        Graph g = getGraph();
        BulkUpdateHandler bu = g.getBulkUpdateHandler();
        Graph items = graphWith( "pigs might fly; dead can dance" );
        Reifier gr = g.getReifier(), ir = items.getReifier();
        xSPOyXYZ( ir );
        xSPO( gr ); aABC( gr ); 
        bu.delete( items, withReifications );
        Graph answer = graphWith( "" );
        Reifier ar = answer.getReifier();
        if (withReifications)
            aABC( ar ); 
        else
            {
            xSPO( ar );
            aABC( ar );
            }
        assertIsomorphic( getReificationTriples( ar ), getReificationTriples( gr ) );
        }
                                        
    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();
        }
        
    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.
    */
    public void testEventUnregister()
        {
        getGraph().getEventManager().unregister( L );
        }
        
    /**
        Handy triple for test purposes.
    */
    protected Triple SPO = Triple.create( "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;
        }
        
    public void testAddTriple()
        {
        Graph g = getAndRegister( L );
        g.add( SPO );
        L.assertHas( new Object[] {"add", g, SPO} );
        }
        
    public void testDeleteTriple()
        {        
        Graph g = getAndRegister( L );
        g.delete( SPO );
        L.assertHas( new Object[] { "delete", g, SPO} );
        }
    
    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 iteratorToSet( g.queryHandler().subjectsFor( Node.ANY, Node.ANY ) );
        }
    
    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 iteratorToSet( g.queryHandler().predicatesFor( Node.ANY, Node.ANY ) );
        }    
    
    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 iteratorToSet( g.queryHandler().objectsFor( Node.ANY, Node.ANY ) );
        }

    /**
        Answer a set with all the elements of <code>A</code> except those
        in <code>B</code>.
    */
    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.
    */
    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} );
            }
        }
    
    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} );
        }
        
    public void testUnregisterWorks()
        {
        Graph g = getGraph();
        GraphEventManager gem = g.getEventManager();
        gem.register( L ).unregister( L );
        g.add( SPO );
        L.assertHas( new Object[] {} );
        }
        
    public void testRegisterTwice()
        {
        Graph g = getAndRegister( L );
        g.getEventManager().register( L );
        g.add( SPO );
        L.assertHas( new Object[] {"add", g, SPO, "add", g, SPO} );
        }
        
    public void testUnregisterOnce()
        {
        Graph g = getAndRegister( L );
        g.getEventManager().register( L ).unregister( L );
        g.delete( SPO );
        L.assertHas( new Object[] {"delete", g, SPO} );
        }
        
    public void testBulkAddArrayEvent()
        {
        Graph g = getAndRegister( L );
        Triple [] triples = tripleArray( "x R y; a P b" );
        g.getBulkUpdateHandler().add( triples );
        L.assertHas( new Object[] {"add[]", g, triples} );
        }
      
    public void testBulkAddList()
        {
        Graph g = getAndRegister( L );
        List elems = Arrays.asList( tripleArray( "bells ring loudly; pigs might fly" ) );
        g.getBulkUpdateHandler().add( elems );
        L.assertHas( new Object[] {"addList", g, elems} );
        }
    
    public void testBulkDeleteArray()
        {
        Graph g = getAndRegister( L );
        Triple [] triples = tripleArray( "x R y; a P b" );
        g.getBulkUpdateHandler().delete( triples );
        L.assertHas( new Object[] {"delete[]", g, triples} );
        }
        
    public void testBulkDeleteList()
        {
        Graph g = getAndRegister( L );
        List elems = Arrays.asList( tripleArray( "bells ring loudly; pigs might fly" ) );
        g.getBulkUpdateHandler().delete( elems );
        L.assertHas( new Object[] {"deleteList", g, elems} );
        }
        
    public void testBulkAddIterator()
        {
        Graph g = getAndRegister( L ); 
        Triple [] triples = tripleArray( "I wrote this; you read that; I wrote this" );
        g.getBulkUpdateHandler().add( asIterator( triples ) );
        L.assertHas( new Object[] {"addIterator", g, Arrays.asList( triples )} );
        }
        
    public void testBulkDeleteIterator()
        {
        Graph g = getAndRegister( L );
        Triple [] triples = tripleArray( "I wrote this; you read that; I wrote this" );
        g.getBulkUpdateHandler().delete( asIterator( triples ) );
        L.assertHas( new Object[] {"deleteIterator", g, Arrays.asList( triples )} );
        }
        
    public Iterator asIterator( Triple [] triples )
        { return Arrays.asList( triples ).iterator(); }
    
    public void testBulkAddGraph()
        {