testbasicoperations.java

Jena推理机

/*
  (c) Copyright 2003, 2004, 2005, 2006, 2007 Hewlett-Packard Development Company, LP
  [See end of file]
  $Id: TestBasicOperations.java,v 1.22 2007/01/17 17:31:05 andy_seaborne Exp $
*/

package com.hp.hpl.jena.db.test;

/**
 * 
 * This tests basic operations on the modelRDB.
 * 
 * It adds/removes statements of different types and verifys
 * that the correct statements exist at the correct times.
 * 
 * To run, you must have a mySQL database operational on
 * localhost with a database name of "test" and allow use
 * by a user named "test" with an empty password.
 * 
 * (Based in part on earlier Jena tests by bwm, kers, et al.)
 * 
 * @author csayers
*/

import java.util.Iterator;

import com.hp.hpl.jena.db.*;
import com.hp.hpl.jena.db.impl.IRDBDriver;
import com.hp.hpl.jena.rdf.model.*;
import com.hp.hpl.jena.vocabulary.RDF;

import junit.framework.TestCase;
import junit.framework.TestSuite;



public class TestBasicOperations extends TestCase {

	public TestBasicOperations(String name) {
		super(name);
	}

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

	ModelRDB model = null;
	IRDBDriver dbDriver = null;
	IDBConnection conn = null;

	protected void setUp() throws java.lang.Exception {
		conn = TestConnection.makeAndCleanTestConnection();
		model = ModelRDB.createModel(conn);
		dbDriver = conn.getDriver();
	}

	protected void tearDown() throws java.lang.Exception {
		if ( model != null ) model.close();
		model = null;
		if ( conn != null ) {
			conn.cleanDB();
			conn.close();
		}
		conn = null;
	}

	private void addRemove(Statement stmt) {
		model.add(stmt);
		assertTrue(model.contains(stmt));
		model.remove(stmt);
		assertTrue(!model.contains(stmt));
		model.add(stmt);
		assertTrue(model.contains(stmt));
		model.remove(stmt);
		assertTrue(!model.contains(stmt));
		model.add(stmt);
		model.add(stmt);
		assertTrue(model.contains(stmt));
		model.remove(stmt);
		assertTrue(!model.contains(stmt));
		model.add(stmt);
		model.add(stmt);
		model.add(stmt);
		model.add(stmt);
		model.add(stmt);
		model.add(stmt);
		assertTrue(model.contains(stmt));
		model.remove(stmt);
		assertTrue(!model.contains(stmt));
	}
	
	private Statement crAssertedStmt(String subj, String pred, String obj) {
		Resource s = model.createResource(subj);
		Property p = model.createProperty(pred);
		Resource o = model.createResource(obj);
		return crAssertedStmt(s, p, o);
	}
	
	private Statement crAssertedStmt(Resource s, Property p, RDFNode o) {
		Statement stmt = model.createStatement(s, p, o);
		model.add(stmt);
		return stmt;
	}
	
	private Resource crReifiedStmt(String node, Statement stmt) {
		Resource n = model.createResource(node);
		Resource s = stmt.getSubject();
		Property p = stmt.getPredicate();
		RDFNode o = stmt.getObject();
		
		crAssertedStmt(n,RDF.subject,s);
		crAssertedStmt(n,RDF.predicate,p);
		crAssertedStmt(n,RDF.object,o);
		crAssertedStmt(n,RDF.type,RDF.Statement);
		return n;
	}
	
	public void testAddRemoveURI() {
		Resource s = model.createResource("test#subject");
		Property p = model.createProperty("test#predicate");
		Resource o = model.createResource("test#object");

		addRemove(model.createStatement(s, p, o));
	}

	public void testAddRemoveLiteral() {
		Resource s = model.createResource("test#subject");
		Property p = model.createProperty("test#predicate");
		Literal l = model.createLiteral("testLiteral");

		addRemove(model.createStatement(s, p, l));
	}

	public void testSetLongObjectLenFailure() {
		try {
			int len = dbDriver.getLongObjectLength();
			dbDriver.setLongObjectLength(len / 2);
			assertTrue(false);
		} catch (Exception e) {
		}
	}

	public void testLongObjectLen() {
		long longLen = dbDriver.getLongObjectLength();
		assertTrue(longLen > 0 && longLen < 100000);

		String base = ".";
		StringBuffer buffer = new StringBuffer(1024 + (int) longLen);
		/* long minLongLen = longLen < 1024 ? longLen - (longLen/2) : longLen - 512; */
		/* long maxLongLen = longLen + 1024; */
		/* TODO: find out why this test takes sooooo long (minutes!) with the above bounds */
		long minLongLen = longLen - 32;
		long maxLongLen = longLen + 32;
		assertTrue(minLongLen > 0);

		Resource s = model.createResource("test#subject");
		Property p = model.createProperty("test#predicate");
		Literal l;
		Statement stmt;
		while (buffer.length() < minLongLen) { /*( build base string */
			buffer.append(base);
		}
		/* add stmts with long literals */
		long modelSizeBeg = model.size();
		while (buffer.length() < maxLongLen) {
			l = model.createLiteral(buffer.toString());
			stmt = model.createStatement(s, p, l);
			model.add(stmt);
			assertTrue(model.contains(stmt));
			assertTrue(stmt.getObject().equals(l));
			buffer.append(base);
		}
		assertTrue(model.size() == (modelSizeBeg + maxLongLen - minLongLen));
		/* remove stmts with long literals */
		while (buffer.length() > minLongLen) {
			buffer.deleteCharAt(0);
			l = model.createLiteral(buffer.toString());
			stmt = model.createStatement(s, p, l);
			assertTrue(model.contains(stmt));
			model.remove(stmt);
			assertTrue(!model.contains(stmt));
		}
		assertTrue(model.size() == modelSizeBeg);
	}

	public void testSetLongObjectLen() {
		int len = dbDriver.getLongObjectLength();
        int len2 = len - 2 ; 
		try {
			tearDown();
			conn = TestConnection.makeTestConnection();
			dbDriver = conn.getDriver();
			len = dbDriver.getLongObjectLength();
			dbDriver.setLongObjectLength(len2);
			model = ModelRDB.createModel(conn);
		} catch (Exception e) {
			assertTrue(false);
		}
		testLongObjectLen();

		// now make sure longObjectValue persists
		model.close();
		try {
			conn.close();
			conn = TestConnection.makeTestConnection();
			dbDriver = conn.getDriver();
			assertTrue(len == dbDriver.getLongObjectLength());
			model = ModelRDB.open(conn);
			assertTrue(len2 == dbDriver.getLongObjectLength());
		} catch (Exception e) {
			assertTrue(false);
		}
	}

	public void testSetLongObjectLenMax() {
		int len = dbDriver.getLongObjectLength();
		int newLen = len;
		int lenMax = dbDriver.getLongObjectLengthMax();
		int hdrLen = 32; // allow 32 bytes for hdrs, etc.
		try {
			tearDown();
			conn = TestConnection.makeTestConnection();
			dbDriver = conn.getDriver();
			len = dbDriver.getLongObjectLength();
			lenMax = dbDriver.getLongObjectLengthMax();
			if ( len == lenMax )
				return; // nothing to test
			newLen = lenMax - hdrLen;
			dbDriver.setLongObjectLength(newLen);
			model = ModelRDB.createModel(conn);
		} catch (Exception e) {
			assertTrue(false);
		}
		testLongObjectLen();

		// now make sure longObjectValue persists
		model.close();
		try {
			conn.close();
			conn = TestConnection.makeTestConnection();
			dbDriver = conn.getDriver();
			assertTrue(len == dbDriver.getLongObjectLength());
			model = ModelRDB.open(conn);
			assertTrue(newLen == dbDriver.getLongObjectLength());
		} catch (Exception e) {
			assertTrue(false);
		}
	}
	
    public void testAddRemoveUTFLiteral()
    {
        String str = Data.strLong ;
        Resource s = model.createResource("test#subject");
        Property p = model.createProperty("test#predicate");
        Literal l = model.createLiteral(str);

        addRemove(model.createStatement(s, p, l));
    }
    
    public void testAddRemoveLiteralSpecials()
    {
        String str = Data.strSpecial ;
        Resource s = model.createResource("test#subject");
        Property p = model.createProperty("test#predicate");
        Literal l = model.createLiteral(str);
        addRemove(model.createStatement(s, p, l));
    }
    
	public void testAddRemoveHugeLiteral() {
		String base = Data.strLong ;
		StringBuffer buffer = new StringBuffer(4096);
		while (buffer.length() < 4000)
			buffer.append(base);
		Resource s = model.createResource("test#subject");
		Property p = model.createProperty("test#predicate");
		Literal l = model.createLiteral(buffer.toString());

		addRemove(model.createStatement(s, p, l));
	}
	
	public void testCompressHugeURI() throws java.lang.Exception {
		// in this test, the prefix exceeed longObjectLength but the
		// compressed URI is less than longObjectLength
		IDBConnection conn = TestConnection.makeAndCleanTestConnection();
		IRDBDriver d = conn.getDriver();
		d.setDoCompressURI(true);
		model = ModelRDB.createModel(conn);
		String pfx = "a123456789";
		String longPfx = "";
		long longLen = dbDriver.getLongObjectLength();
		// make long prefix
		while ( longPfx.length() < longLen )
			longPfx += pfx;
		String URI = longPfx + ":/www.foo/#bar";
		Resource s = model.createResource(URI);
		Property p = model.createProperty("test#predicate");
		Resource o = model.createResource("test#object");
		addRemove(model.createStatement(s, p, o));
	}

	public void testCompressHugeURI1() throws java.lang.Exception {
		// in this test, the prefix exceeed longObjectLength but the
		// compressed URI also exceeds longObjectLength
		IDBConnection conn = TestConnection.makeAndCleanTestConnection();
		IRDBDriver d = conn.getDriver();
		d.setDoCompressURI(true);
		model = ModelRDB.createModel(conn);
		String pfx = "a123456789";
		String longPfx = "";
		long longLen = dbDriver.getLongObjectLength();
		// make long prefix
		while ( longPfx.length() < longLen )
			longPfx += pfx;
		String URI = longPfx + ":/www.foo/#bar" + longPfx;
		Resource s = model.createResource(URI);
		Property p = model.createProperty("test#predicate");
		Resource o = model.createResource("test#object");