abstracttestreifiedstatements.java

Jena推理机

        testStatementAndModel( "fromStatement", SPO.createReifiedStatement(), model, SPO );
        }

    public void testConstructionFromModels()
        {
        testStatementAndModel( "fromModel", model.createReifiedStatement( SPO ) , model, SPO );    
        }
    
    /**
        utility method: get a set of all the elements delivered by
        _m.listReifiedStatements_.
    */  
    public Set getSetRS( Model m )
        { return GraphTestBase.iteratorToSet( m.listReifiedStatements() ); }
   
    protected static Set empty = CollectionFactory.createHashedSet();
    
    /**
        test that listReifiedStatements produces an iterator that contains
        the right reified statements. We *don't* test that they're not
        duplicated, because they might be; disallowing duplicates
        could be expensive.
    */
    public void testListReifiedStatements()
        {
        assertEquals( "initially: no reified statements", empty, getSetRS( model ) );
        ReifiedStatement rs = model.createReifiedStatement( aURI, SPO );
        // assertEquals( "still: no reified statements", empty, getSetRS( m ) );
    /* */
        model.add( rs, P, O );   
        Set justRS = arrayToSet( new Object [] {rs} );
        assertEquals( "post-add: one reified statement", justRS, getSetRS( model ) );
        model.add( S, P, rs );
        assertEquals( "post-add: still one reified statement", justRS, getSetRS( model ) );
    /* */
        ReifiedStatement rs2 = model.createReifiedStatement( anotherURI, SPO2 );
        Set bothRS = arrayToSet( new Object[] {rs, rs2} );
        model.add( rs2, P, O );
        assertEquals( "post-add: still one reified statement", bothRS, getSetRS( model ) );
        }

    /**
        this test appeared when TestStatementResources crashed using reified
        statements as a step-0 implementation for asSubject()/asObject(). Looks
        like there was a problem in modelReifier().getRS(), which we're fixing ...
    */
    public void testListDoesntCrash()
        {
        model.createReifiedStatement( SPO );
        model.createReifiedStatement( SPO2 );
        assertTrue( "should be non-empty", model.listReifiedStatements().hasNext() );
        }
        
    public Set getSetRS( Model m, Statement st )
        { return GraphTestBase.iteratorToSet( m.listReifiedStatements( st ) ); }
        
    public void testListReifiedSpecificStatements()
        {
        assertEquals( "no statements should match st", empty, getSetRS( model, SPO ) );
    /* */
        ReifiedStatement rs = model.createReifiedStatement( aURI, SPO );
        ReifiedStatement rs2 = model.createReifiedStatement( anotherURI, SPO2 );
        model.add( rs, P, O );
        // assertEquals( "still no matching statement", empty, getSetRS( m, stOther ) );
    /* */
        Set justRS2 = arrayToSet( new Object [] {rs2} );
        model.add( rs2, P, O );
        assertEquals( "now one matching statement", justRS2, getSetRS( model, SPO2 ) );        
        }
    
    public void testStatementListReifiedStatements()
        {
        Statement st = SPO;
        Model m = model;
        assertEquals( "it's not there yet", empty, GraphTestBase.iteratorToSet( st.listReifiedStatements() ) );
        ReifiedStatement rs = m.createReifiedStatement( aURI, st );
        Set justRS = arrayToSet( new Object [] {rs} );
        m.add( rs, P, O );
        assertEquals( "it's here now", justRS, GraphTestBase.iteratorToSet( st.listReifiedStatements() ) );    
        }
    
    public void testIsReified()
        {
        ReifiedStatement rs = model.createReifiedStatement( aURI, SPO );
        Resource BS = model.createResource( anchor + "BS" );
        Property BP = model.createProperty( anchor + "BP" );
        RDFNode BO = model.createProperty( anchor + "BO" );
        model.add( rs, P, O );
        assertTrue( "st should be reified now", SPO.isReified() );
        assertTrue( "m should have st reified now", model.isReified( SPO ) );
        assertFalse( "this new statement should not be reified", model.createStatement( BS, BP, BO ).isReified() );
        }
    
    public void testGetAny()
        {
        Resource r = model.getAnyReifiedStatement( SPO );
        assertInstanceOf( ReifiedStatement.class, r );
        assertEquals( "should get me the statement", SPO, ((ReifiedStatement) r).getStatement() );
        }
    
    public void testRemoveReificationWorks()
        {
        Statement st = SPO;
        Model m = model;
        m.createReifiedStatement( aURI, st );
        assertTrue( "st is now reified", st.isReified() );
        m.removeAllReifications( st );
        assertFalse( "st is no longer reified", st.isReified() );
        }
    
    /**
        Leo Bard spotted a problem whereby removing a reified statement from a model
        with style Standard didn't leave the model empty. Here's a test for it. 
    */
    public void testLeosBug()
        {
        Model A = getModel();
        Statement st = statement( A,  "pigs fly south" );
        ReifiedStatement rst = st.createReifiedStatement( "eh:pointer" );
        A.removeReification( rst );
        assertIsoModels( ModelFactory.createDefaultModel(), A );
        }
    
    public void testRR()
        {
        Statement st = SPO;
        Model m = model;
        ReifiedStatement rs1 = m.createReifiedStatement( aURI, st );
        ReifiedStatement rs2 = m.createReifiedStatement( anotherURI, st );
        m.removeReification( rs1 );
        testNotReifying( m, aURI );
        assertTrue( "st is still reified", st.isReified() );
        m.removeReification( rs2 );
        assertFalse( "st should no longer be reified", st.isReified() );
        }
    
    private void testNotReifying( Model m, String uri )
        {
        try 
            {
            m.createResource( uri ).as( ReifiedStatement.class );
            fail( "there should be no reifiedStatement for " + uri );
            }
        catch (DoesNotReifyException e)
            { /* that's what we require */ }
        }

    public void testDoesNotReifyElsewhere()
        {
        final String uri = "spoo:rubbish";
        Model m2 = getModel();
        model.createReifiedStatement( uri, SPO );
        testDoesNotReify( "blue model should not reify rubbish", m2.createResource( uri ) );
        }                                             
//    public void testXXX()
//        {
//        String root = "http://root/root#";
//        Model m = ModelFactory.createDefaultModel();
//        Model r = ModelFactory.createRDFSModel( m );
//        Resource S = r.createResource( root + "S" );
//        Property P = r.createProperty( root + "P" );
//        RDFNode O = r.createResource( root + "O" );
//        Statement st = r.createStatement( S, P, O );
//        ReifiedStatement rs = st.createReifiedStatement( root + "RS" );
//        }
    }


/*
    (c) Copyright 2002, 2003, 2004, 2005, 2006, 2007 Hewlett-Packard Development Company, LP
    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    1. Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.

    2. Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.

    3. The name of the author may not be used to endorse or promote products
       derived from this software without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
    IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/