Java tutorial
/******************************************************************************* * Copyright (c) 2004, 2007-2008 IBM Corporation and Cambridge Semantics Incorporated. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * File: $Source: /cvsroot/slrp/boca/com.ibm.adtech.boca.test/src/com/ibm/adtech/boca/test/AbstractBocaTest.java,v $ * Created by: Matthew Roy ( <a href="mailto:mroy@us.ibm.com">mroy@us.ibm.com </a>) * Created on: 9/17/2004 * Revision: $Id: AbstractTest.java 171 2007-07-31 14:11:17Z mroy $ * * Contributors: * IBM Corporation - initial API and implementation * Cambridge Semantics Incorporated - Fork to Anzo *******************************************************************************/ package org.openanzo.test; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Set; import java.util.TreeMap; import java.util.Map.Entry; import org.apache.commons.io.IOUtils; import org.apache.commons.lang.StringUtils; import org.openanzo.exceptions.AnzoException; import org.openanzo.exceptions.AnzoRuntimeException; import org.openanzo.glitter.query.PatternSolution; import org.openanzo.glitter.query.QueryResults; import org.openanzo.glitter.query.QueryType; import org.openanzo.glitter.query.SolutionSet; import org.openanzo.rdf.Bindable; import org.openanzo.rdf.Constants; import org.openanzo.rdf.Literal; import org.openanzo.rdf.RDFFormat; import org.openanzo.rdf.Statement; import org.openanzo.rdf.URI; import org.openanzo.rdf.Value; import org.openanzo.rdf.adapter.BasicNodeConverter; import org.openanzo.rdf.utils.ReadWriteUtils; import org.openanzo.rdf.utils.SmartEncodingInputStream; import org.openrdf.query.BindingSet; import org.openrdf.query.QueryEvaluationException; import org.openrdf.query.TupleQueryResultHandlerException; import org.openrdf.query.dawg.DAWGTestResultSetParseException; import org.openrdf.query.dawg.DAWGTestResultSetUtil; import org.openrdf.query.impl.MutableTupleQueryResult; import org.openrdf.query.impl.TupleQueryResultBuilder; import org.openrdf.query.resultio.BooleanQueryResultParser; import org.openrdf.query.resultio.QueryResultParseException; import org.openrdf.query.resultio.TupleQueryResultParser; import org.openrdf.query.resultio.sparqlxml.SPARQLBooleanXMLParser; import org.openrdf.query.resultio.sparqlxml.SPARQLResultsXMLParser; import org.openrdf.rio.RDFHandlerException; import org.openrdf.rio.RDFParseException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * Suite of query tests * * @author Lee Feigenbaum ( <a href="mailto:lee@cambridgesemantics.com">lee@cambridgesemantics.com </a>) */ public abstract class QueryTestSuiteBase extends AbstractTest { private static final Logger log = LoggerFactory.getLogger(QueryTestSuiteBase.class); protected static BasicNodeConverter converter = new BasicNodeConverter(); abstract protected QueryResults executeQuery(Set<URI> defaultGraphs, Set<URI> namedGraphs, Set<URI> namedDatasets, String query, URI base) throws AnzoException; static protected HashMap<InputStream, Object> cachedStreamResults = new HashMap<InputStream, Object>(); protected void performQueryTest(QueryTest test) throws RDFHandlerException, QueryResultParseException, TupleQueryResultHandlerException, DAWGTestResultSetParseException, IOException, Exception { String query = readAndCacheStream(test.getQuery()); QueryType type = getQueryType(query); try { switch (type) { case SELECT: performSelectQueryTest(test.getBase(), test.getDefaultGraphs(), test.getNamedGraphs(), test.getNamedDatasets(), query, test.hasExpectedException() ? null : loadTupleQueryResult(test.getResults(), test.getResultRDFFormat(), test.getBase()), test.isForceIgnoreOrder(), test.isAllowAnagrams()); break; case CONSTRUCT: performConstructQueryTest(test.getBase(), test.getDefaultGraphs(), test.getNamedGraphs(), test.getNamedDatasets(), query, test.hasExpectedException() ? null : parseAnyRdf(test.getResults(), test.getResultRDFFormat(), test.getBase())); break; case ASK: performAskQueryTest(test.getBase(), test.getDefaultGraphs(), test.getNamedGraphs(), test.getNamedDatasets(), query, test.hasExpectedException() ? null : loadBooleanResult(test.getResults(), test.getResultRDFFormat(), test.getBase())); break; case DESCRIBE: performDescribeQueryTest(test.getBase(), test.getDefaultGraphs(), test.getNamedGraphs(), test.getNamedDatasets(), query, test.hasExpectedException() ? null : parseAnyRdf(test.getResults(), test.getResultRDFFormat(), test.getBase())); break; default: fail("Unknown query type."); } } catch (Exception e) { verifyExpectedException(test, e); } } protected void verifyExpectedException(QueryTest test, Exception caughtException) throws Exception { Exception expectedException = test.getExpectedException(); if (expectedException == null) { // This test isn't expecting an Exception so simply re-throw it so that the test fails throw caughtException; } // Do some verification of the expected errorCode and errorTags if the // expected exception is either an AnzoException or an AnzoRuntimeException. // We treat AnzoException and AnzoRuntimeException as interchangeable since the system // fires different ones depending on whether we are communicating over the network or to // a local query engine. long expectedErrorCode = -1; long expectedErrorTags = -1; long caughtErrorCode = -1; long caughtErrorTags = -1; if (expectedException instanceof AnzoException) { expectedErrorCode = ((AnzoException) expectedException).getErrorCode(); } if (caughtException instanceof AnzoException) { caughtErrorCode = ((AnzoException) caughtException).getErrorCode(); } if (expectedException instanceof AnzoRuntimeException) { expectedErrorCode = ((AnzoRuntimeException) expectedException).getErrorCode(); } if (caughtException instanceof AnzoRuntimeException) { caughtErrorCode = ((AnzoRuntimeException) caughtException).getErrorCode(); } if (expectedException instanceof AnzoException || expectedException instanceof AnzoRuntimeException) { if (caughtException instanceof AnzoException || caughtException instanceof AnzoRuntimeException) { if (expectedErrorCode != caughtErrorCode) { throw new Exception( "Query tests's expected AnzoException or AnzoRuntimeException with errorCode '" + expectedErrorCode + "' but got errorCode '" + caughtErrorCode + "'.", caughtException); } if (expectedErrorTags != caughtErrorTags) { throw new Exception( "Query tests's expected AnzoException or AnzoRuntimeException with errorTags '" + expectedErrorTags + "' but got errorTags '" + caughtErrorTags + "'.", caughtException); } } else { throw new Exception( "Query test expected an AnzoException or AnzoRuntimeException but thrown exception was not an AnzoException or AnzoRuntimeException.", caughtException); } } else { // For the case where the exception isn't an AnzoException or an AnzoRuntimeException, the // best we can do is verify that as least the caught exception is an "instance of" the excepted exception. if (expectedException.getClass().isInstance(caughtException)) { throw new Exception( "Query test's expected exception was of type " + expectedException.getClass().getName() + " while the thrown exception was of the incompatible type " + caughtException.getClass().getName(), caughtException); } } } protected String readAndCacheStream(InputStream stream) throws IOException { //System.err.println("** readAndCacheStream - start"); if (!cachedStreamResults.containsKey(stream)) { //System.err.println("** readAndCacheStream - reading from stream"); List<?> lines = IOUtils.readLines(stream); String s = ""; for (Object tmp : lines) s += tmp + "\n"; cachedStreamResults.put(stream, s); //if (s.equals("")) // System.err.println("** readAndCacheStream - read empty string from " + lines.size() + " lines"); } //System.err.println("** readAndCacheStream - end (" + ((String)cachedStreamResults.get(stream)).length() + ")"); return (String) cachedStreamResults.get(stream); } @SuppressWarnings("all") protected QueryType getQueryType(String query) { String lc = query.toLowerCase(); TreeMap<Integer, QueryType> m = new TreeMap<Integer, QueryType>(); m.put(Integer.valueOf(lc.indexOf("select")), QueryType.SELECT); m.put(Integer.valueOf(lc.indexOf("construct")), QueryType.CONSTRUCT); m.put(Integer.valueOf(lc.indexOf("ask")), QueryType.ASK); m.put(Integer.valueOf(lc.indexOf("describe")), QueryType.DESCRIBE); for (Entry<Integer, QueryType> e : m.entrySet()) { int index = e.getKey(); if (index > -1) { // determine if this index is inside a BASE or PREFIX clause. We do this by determining if // a colon immediately follows it or it is inside angle brackets int x; for (x = index + 3; Character.isJavaIdentifierPart(lc.charAt(x)); x++) ; //earliest the colon could be, if we're in ask if (lc.charAt(x) != ':') { int lt = lc.lastIndexOf('<', index); int gt = lc.lastIndexOf('>', index); if (lt == -1 || gt > lt) { // no < before us, or else there's a > after the last < return e.getValue(); } } } } fail("Unknown query type for query: " + query); return null; } @SuppressWarnings("unchecked") // ignore cast to Collection<Statement> since only used for testing protected Collection<Statement> parseAnyRdf(InputStream stream, org.openanzo.rdf.RDFFormat format, String base) throws AnzoException { if (!cachedStreamResults.containsKey(stream)) { cachedStreamResults.put(stream, ReadWriteUtils .loadStatements(SmartEncodingInputStream.createSmartReader(stream), format, base)); } return (Collection<Statement>) cachedStreamResults.get(stream); } @SuppressWarnings("unchecked") // ignore cast to Collection<Statement> since only used for testing protected Collection<org.openrdf.model.Statement> parseAnyRdfOpenRdf(InputStream stream, RDFFormat format, String base) throws AnzoException { if (!cachedStreamResults.containsKey(stream)) { cachedStreamResults.put(stream, ReadWriteUtils .loadStatements(SmartEncodingInputStream.createSmartReader(stream), format, base)); } return (Collection<org.openrdf.model.Statement>) cachedStreamResults.get(stream); } protected MutableTupleQueryResult loadTupleQueryResult(InputStream results, org.openanzo.rdf.RDFFormat format, String base) throws AnzoException, RDFHandlerException, IOException, QueryResultParseException, TupleQueryResultHandlerException, DAWGTestResultSetParseException, RDFParseException, QueryEvaluationException { if (!cachedStreamResults.containsKey(results)) { MutableTupleQueryResult tqr = null; if (format.equals(RDFFormat.SPARQL)) { // if it's not RDF, it's probably srx or srj TupleQueryResultParser parser = new SPARQLResultsXMLParser();//.createParser(TupleQueryResultFormat.SPARQL); TupleQueryResultBuilder tqrBuilder = new TupleQueryResultBuilder(); parser.setTupleQueryResultHandler(tqrBuilder); parser.parse(results); tqr = new MutableTupleQueryResult(tqrBuilder.getQueryResult()); } else { Collection<org.openrdf.model.Statement> rdf = parseAnyRdfOpenRdf(results, format, base); log.debug("expected: {}", rdf); tqr = new MutableTupleQueryResult(DAWGTestResultSetUtil.toTupleQueryResult(rdf)); } cachedStreamResults.put(results, tqr); } return (MutableTupleQueryResult) cachedStreamResults.get(results); } protected Boolean loadBooleanResult(InputStream results, RDFFormat format, String base) throws AnzoException, RDFHandlerException, IOException, QueryResultParseException, TupleQueryResultHandlerException, DAWGTestResultSetParseException, RDFParseException { if (!cachedStreamResults.containsKey(results)) { Boolean b = null; if (format.equals(RDFFormat.BOOLEANRESULT)) { // if it's not RDF, it's probably srx or srj BooleanQueryResultParser parser = new SPARQLBooleanXMLParser(); b = parser.parse(results); } else { Collection<org.openrdf.model.Statement> rdf = parseAnyRdfOpenRdf(results, format, base); b = DAWGTestResultSetUtil.toBooleanQueryResult(rdf); } cachedStreamResults.put(results, b); } return (Boolean) cachedStreamResults.get(results); } protected void performSelectQueryTest(String base, Set<URI> defaultGraphs, Set<URI> namedGraphs, Set<URI> namedDatasets, String query, MutableTupleQueryResult expectedResults, boolean forceIgnoreOrder, boolean allowAnagrams) throws Exception { QueryResults actualResults = executeQuery(defaultGraphs, namedGraphs, namedDatasets, query, base != null ? Constants.valueFactory.createURI(base) : null); // Iterator<PatternSolution> iterator = actualResults.getSelectResults().iterator(); // while (iterator.hasNext()) { // PatternSolution patternSolution = (PatternSolution) iterator.next(); // System.err.println(patternSolution); // } assertEquals(QueryType.SELECT, actualResults.getQueryType()); SolutionSet solutionSet = actualResults.getSelectResults(); // ooo this is a bit of a cheat if (!query.matches("(?is:.*SELECT\\s+\\*.*)")) assertEquals(expectedResults.getBindingNames(), solutionSet.getBindingNames()); assertTupleQueryResultEquals(expectedResults, solutionSet, forceIgnoreOrder ? false : query.toUpperCase().contains("ORDER BY"), allowAnagrams); } protected void performConstructQueryTest(String base, Set<URI> defaultGraphs, Set<URI> namedGraphs, Set<URI> namedDatasets, String query, Collection<Statement> expectedResults) throws Exception { QueryResults actualResults = executeQuery(defaultGraphs, namedGraphs, namedDatasets, query, base != null ? Constants.valueFactory.createURI(base) : null); assertTrue(actualResults.getQueryType() == QueryType.CONSTRUCT || actualResults.getQueryType() == QueryType.CONSTRUCT_QUADS); Collection<Statement> actualTriples = actualResults.getConstructResults(); // we want set semantics for comparison HashSet<Statement> expectedTripleSet = new HashSet<Statement>(expectedResults); HashSet<Statement> actualTripleSet = new HashSet<Statement>(actualTriples); assertEquals(expectedTripleSet, actualTripleSet); } protected void performAskQueryTest(String base, Set<URI> defaultGraphs, Set<URI> namedGraphs, Set<URI> namedDatasets, String query, Boolean expectedResults) throws Exception { QueryResults actualResults = executeQuery(defaultGraphs, namedGraphs, namedDatasets, query, base != null ? Constants.valueFactory.createURI(base) : null); assertEquals(QueryType.ASK, actualResults.getQueryType()); assertEquals(expectedResults.booleanValue(), actualResults.getAskResults()); } protected void performDescribeQueryTest(String base, Set<URI> defaultGraphs, Set<URI> namedGraphs, Set<URI> namedDatasets, String query, Collection<Statement> expectedResults) throws Exception { QueryResults actualResults = executeQuery(defaultGraphs, namedGraphs, namedDatasets, query, base != null ? Constants.valueFactory.createURI(base) : null); assertTrue(actualResults.getQueryType() == QueryType.DESCRIBE || actualResults.getQueryType() == QueryType.DESCRIBE_QUADS); Collection<Statement> actualTriples = actualResults.getDescribeResults(); // we want set semantics for comparison HashSet<Statement> expectedTripleSet = new HashSet<Statement>(expectedResults); HashSet<Statement> actualTripleSet = new HashSet<Statement>(actualTriples); assertEquals(expectedTripleSet, actualTripleSet); } private void assertTupleQueryResultEquals(MutableTupleQueryResult expected, SolutionSet actual, boolean ordered, boolean allowAnagrams) throws Exception { // this is laxer than it need be: SELECT * allows names in any order, but SELECT ?x ?y ?z mandates // the order Iterator<PatternSolution> actualIter = actual.iterator(); assertEquals(new HashSet<String>(expected.getBindingNames()), new HashSet<String>(actual.getBindingNames())); if (ordered) { // if it's ordered, we can just walk the lists in parallel expected.beforeFirst(); while (expected.hasNext()) { assertTrue(actualIter.hasNext()); BindingSet expectedPatternSolution = expected.next(); PatternSolution actualPatternSolution = actualIter.next(); assertTrue("Expected solution does not equal actual solution:\n\t" + converter.convert(expectedPatternSolution) + "\n\t\tvs.\n\t" + actualPatternSolution, areSolutionsEqual(converter.convert(expectedPatternSolution), actualPatternSolution, allowAnagrams)); } assertFalse(actualIter.hasNext()); } else { // otherwise, we can just build bags from each solution set and compare them //assertEquals(tqr2bag(expected), tqr2bag(actual)); // this doesn't work because different implementations have different .hashCodes, so // we do this the naive way LinkedList<PatternSolution> actualBindings = new LinkedList<PatternSolution>(); while (actualIter.hasNext()) actualBindings.add(actualIter.next()); int expectedCount = 0; expected.beforeFirst(); while (expected.hasNext()) { expectedCount++; BindingSet e = expected.next(); PatternSolution expect = converter.convert(e); boolean found = false; for (PatternSolution a : actualBindings) { if (areSolutionsEqual(expect, a, allowAnagrams)) { actualBindings.remove(a); found = true; break; } } assertTrue("Did not find expected bindings: \n\t" + expect + "\nActual bindings are:\n\t" + actualBindings, found); } assertEquals("Actual bindings found that were not expected. Expected were: \n\t[" + StringUtils.join(convertResults(expected), ", ") + "]\nActual bindings are:\n\t" + actualBindings, 0, actualBindings.size()); } } private boolean areSolutionsEqual(PatternSolution expected, PatternSolution actual, boolean allowAnagrams) { if (!allowAnagrams) return expected.equals(actual); Bindable[] domain = expected.getBoundDomain(true); boolean sameDomain = Arrays.equals(domain, actual.getBoundDomain(true)); if (!sameDomain) return false; for (Bindable b : domain) { Value expectedVal = expected.getBinding(b); Value actualVal = actual.getBinding(b); if (expectedVal == null && actualVal == null) continue; if (expectedVal == null || actualVal == null) return false; if (expectedVal.equals(actualVal)) continue; // allow anagrams here, but only for literals if (expectedVal instanceof Literal && actualVal instanceof Literal) { String expectedLabel = ((Literal) expectedVal).getLabel(); String actualLabel = ((Literal) actualVal).getLabel(); char[] expectedChars = expectedLabel.toCharArray(); char[] actualChars = actualLabel.toCharArray(); Arrays.sort(expectedChars); Arrays.sort(actualChars); return Arrays.equals(expectedChars, actualChars); } return false; } return true; } static Collection<BindingSet> convertResults(MutableTupleQueryResult results) { Collection<BindingSet> resultCollection = new ArrayList<BindingSet>(); while (results.hasNext()) { resultCollection.add(results.next()); } return resultCollection; } }