newregressionseq.java

Jena推理机

/*
 	(c) Copyright 2005, 2006, 2007 Hewlett-Packard Development Company, LP
 	All rights reserved - see end of file.
 	$Id: NewRegressionSeq.java,v 1.4 2007/01/02 11:49:22 andy_seaborne Exp $
*/

package com.hp.hpl.jena.regression;

import java.util.*;

import junit.framework.*;

import com.hp.hpl.jena.rdf.model.*;
import com.hp.hpl.jena.regression.Regression.*;
import com.hp.hpl.jena.vocabulary.RDF;

public class NewRegressionSeq extends NewRegressionBase
    {
    public NewRegressionSeq( String name )
        { super( name ); }

    public static Test suite()
        { return new TestSuite( NewRegressionSeq.class ); }

    protected Model getModel()
        { return ModelFactory.createDefaultModel(); }

    protected Model m;
    
    public void setUp()
        { m = getModel(); }
    
    public void tearDown()
        { m = null; }
    
    public void testSeqAdd()
        {
        Seq seq = m.createSeq();
        assertEquals( 0, seq.size() );
        assertTrue( m.contains( seq, RDF.type, RDF.Seq ) );
    //    
        seq.add( tvBoolean );
        assertTrue( seq.contains( tvBoolean ) );
        assertFalse( seq.contains( !tvBoolean ) );
    //  
        seq.add( tvByte );
        assertTrue( seq.contains( tvByte ) );
        assertFalse( seq.contains( (byte) 101 ) );
    //
        seq.add( tvShort );
        assertTrue( seq.contains( tvShort ) );
        assertFalse( seq.contains( (short) 102 ) );
    //
        seq.add( tvInt );
        assertTrue( seq.contains( tvInt ) );
        assertFalse( seq.contains( (int) -101 ) );
    //
        seq.add( tvLong );
        assertTrue( seq.contains( tvLong ) );
        assertFalse( seq.contains( (long) -102 ) );
   //     
        seq.add( tvChar );
        assertTrue( seq.contains( tvChar ) );
        assertFalse( seq.contains( '?' ) );
   //     
        seq.add( 123.456f );
        assertTrue( seq.contains( 123.456f ) );
        assertFalse( seq.contains( 456.123f ) );
   //     
        seq.add( -123.456d );
        assertTrue( seq.contains( -123.456d ) );
        assertFalse( seq.contains( -456.123d ) );
   //     
        seq.add( "a string" );
        assertTrue( seq.contains( "a string" ) );
        assertFalse( seq.contains( "a necklace" ) );
   //     
        seq.add( m.createLiteral( "another string" ) );
        assertTrue( seq.contains( "another string" ) );
        assertFalse( seq.contains( "another necklace" ) );
   //     
        seq.add( new LitTestObj( 12345 ) );
        assertTrue( seq.contains( new LitTestObj( 12345 ) ) );
        assertFalse( seq.contains( new LitTestObj( 54321 ) ) );
   //     
        Resource present = m.createResource( new ResTestObjF() );
        Resource absent = m.createResource( new ResTestObjF() );
        seq.add( present );
        assertTrue( seq.contains( present ) );
        assertFalse( seq.contains( absent ) );
    //    
        assertEquals( 12, seq.size() );
        }
    
    public void testSeqAddInts()
        {
        final int num = 10;
        Seq seq = m.createSeq();
        for (int i = 0; i < num; i += 1) seq.add( i );
        assertEquals( num, seq.size() );
        List L = iteratorToList( seq.iterator() );
        assertEquals( num, L.size() );
        for (int i = 0; i < num; i +=1 ) 
            assertEquals( i, ((Literal) L.get(i)).getInt() );
        }
    
    public void testRemoveA()
        { testRemove( bools( "tttffffftt" ) ); }
    
    public void testRemoveB()
        { testRemove( bools( "ftftttttft" ) ); }    
    
    public void testRemoveC()
        { testRemove( bools( "ffffffffff" ) ); }
    
    protected boolean [] bools( String s )
        {
        boolean [] result = new boolean [s.length()];
        for (int i = 0; i < s.length(); i += 1) result[i] = s.charAt(i) == 't';
        return result;
        }
    
    protected void testRemove( boolean[] retain )
        {
        final int num = retain.length;
        Seq seq = m.createSeq();
        for (int i = 0; i < num; i += 1) seq.add( i );
    //                         
        List retained = new ArrayList();
    //    
        NodeIterator nIter = seq.iterator();
        for (int i = 0; i < num; i += 1) 
            {
            RDFNode x = nIter.nextNode();
            if (retain[i]) retained.add( x ); else nIter.remove();
            }
    //    
        assertFalse( nIter.hasNext() );                
        assertEquals( retained, iteratorToList( seq.iterator() ) );
        }

    public void testSeqAccessByIndexing()
        {
        LitTestObj tvObject = new LitTestObj(12345);
        Literal    tvLiteral = m.createLiteral("test 12 string 2");
        Resource   tvResource = m.createResource();
        Resource   tvResObj = m.createResource(new ResTestObjF());
        Object     tvLitObj = new LitTestObj(1234);
        Bag        tvBag    = m.createBag();
        Alt        tvAlt    = m.createAlt();
        Seq        tvSeq    = m.createSeq();
    //
        Seq seq = m.createSeq();
        seq.add( true );
        assertEquals( true, seq.getBoolean( 1 ) );
        seq.add( (byte) 1 );
        assertEquals( (byte) 1, seq.getByte( 2 ) );
        seq.add( (short) 2 );
        assertEquals( (short) 2, seq.getShort( 3 ) );
        seq.add( (int) -1 );
        assertEquals( (int) -1, seq.getInt( 4 ) );
        seq.add( (long) -2 );
        assertEquals( (long) -2, seq.getLong( 5 ) );
        seq.add( '!' );
        assertEquals( '!', seq.getChar( 6 ) );
        seq.add( 123.456f );
        assertEquals( 123.456f, seq.getFloat( 7 ), 0.00005 );
        seq.add( 12345.67890 );
        assertEquals( 12345.67890, seq.getDouble( 8 ), 0.00000005 );
        seq.add( "some string" );
        assertEquals( "some string", seq.getString( 9 ) );
        seq.add( tvLitObj );
        assertEquals( tvLitObj, seq.getObject( 10, new LitTestObjF() ) );
        seq.add( tvResource );
        assertEquals( tvResource, seq.getResource( 11 ) );
        seq.add( tvResObj );
        assertEquals( tvResObj, seq.getResource( 12, new ResTestObjF() ) );
        seq.add( tvLiteral );
        assertEquals( tvLiteral, seq.getLiteral( 13 ) );
        seq.add( tvBag );
        assertEquals( tvBag, seq.getBag( 14 ) );
        seq.add( tvAlt );
        assertEquals( tvAlt, seq.getAlt( 15 ) );
        seq.add( tvSeq );
        assertEquals( tvSeq, seq.getSeq( 16 ) );
    //
        try { seq.getInt( 17 ); fail( "there is no element 17" ); }
        catch (SeqIndexBoundsException e) { pass(); }
        try { seq.getInt( 0 ); fail( "there is no element 0" ); }
        catch (SeqIndexBoundsException e) { pass(); }
        }
    
    public void testSeqInsertByIndexing()
        {
        LitTestObj tvObject = new LitTestObj(12345);
        Literal    tvLiteral = m.createLiteral("test 12 string 2");
        Resource   tvResource = m.createResource();
        Resource   tvResObj = m.createResource(new ResTestObjF());
        Object     tvLitObj = new LitTestObj(1234);
        Bag        tvBag    = m.createBag();
        Alt        tvAlt    = m.createAlt();
        Seq        tvSeq    = m.createSeq();
        
        Seq seq = m.createSeq();
        seq.add( m.createResource() );