001: /*
002: * Copyright Aduna (http://www.aduna-software.com/) (c) 1997-2006.
003: *
004: * Licensed under the Aduna BSD-style license.
005: */
006: package org.openrdf.query.parser.serql;
007:
008: import java.io.IOException;
009: import java.io.InputStream;
010: import java.io.InputStreamReader;
011: import java.net.URL;
012: import java.util.ArrayList;
013: import java.util.Collection;
014: import java.util.List;
015:
016: import junit.framework.Test;
017: import junit.framework.TestCase;
018: import junit.framework.TestSuite;
019:
020: import org.slf4j.Logger;
021: import org.slf4j.LoggerFactory;
022:
023: import info.aduna.io.IOUtil;
024: import info.aduna.iteration.Iterations;
025:
026: import org.openrdf.model.Literal;
027: import org.openrdf.model.Statement;
028: import org.openrdf.model.impl.URIImpl;
029: import org.openrdf.model.util.ModelUtil;
030: import org.openrdf.query.BindingSet;
031: import org.openrdf.query.GraphQueryResult;
032: import org.openrdf.query.QueryLanguage;
033: import org.openrdf.query.TupleQueryResult;
034: import org.openrdf.repository.Repository;
035: import org.openrdf.repository.RepositoryConnection;
036: import org.openrdf.repository.sail.SailRepository;
037: import org.openrdf.repository.util.RepositoryUtil;
038: import org.openrdf.rio.RDFFormat;
039: import org.openrdf.sail.Sail;
040: import org.openrdf.sail.inferencer.fc.DirectTypeHierarchyInferencer;
041: import org.openrdf.sail.inferencer.fc.ForwardChainingRDFSInferencer;
042: import org.openrdf.sail.memory.MemoryStore;
043:
044: public class SeRQLQueryTest extends TestCase {
045:
046: static final Logger logger = LoggerFactory
047: .getLogger(SeRQLQueryTest.class);
048:
049: /*-----------*
050: * Constants *
051: *-----------*/
052:
053: private static final String MANIFEST_FILE = "/testcases/SeRQL/construct/manifest.ttl";
054:
055: /*-----------*
056: * Variables *
057: *-----------*/
058:
059: private String dataFile;
060:
061: private String queryFile;
062:
063: private String resultFile;
064:
065: private List<String> graphNames;
066:
067: private String entailment;
068:
069: /*--------------*
070: * Constructors *
071: *--------------*/
072:
073: /**
074: * Creates a new SeRQL Query test.
075: */
076: public SeRQLQueryTest(String name, String dataFile,
077: List<String> graphNames, String queryFile,
078: String resultFile, String entailment) {
079: super (name);
080:
081: this .dataFile = dataFile;
082: this .queryFile = queryFile;
083: this .resultFile = resultFile;
084: this .graphNames = graphNames;
085: this .entailment = entailment;
086: }
087:
088: /*---------*
089: * Methods *
090: *---------*/
091:
092: @Override
093: protected void runTest() throws Exception {
094: String query = readQuery();
095:
096: // Create a repository with the query data
097:
098: Sail sail = new MemoryStore();
099:
100: if ("RDF".equals(entailment)) {
101: // do not add inferencers
102: } else if ("RDFS".equals(entailment)) {
103: sail = new ForwardChainingRDFSInferencer(sail);
104: } else if ("RDFS-VP".equals(entailment)) {
105: sail = new ForwardChainingRDFSInferencer(sail);
106: sail = new DirectTypeHierarchyInferencer(sail);
107: } else {
108: sail.shutDown();
109: fail("Invalid value for entailment level:" + entailment);
110: }
111:
112: Repository dataRep = new SailRepository(sail);
113: dataRep.initialize();
114:
115: RepositoryConnection dataCon = dataRep.getConnection();
116:
117: // Add unnamed gaph
118: dataCon.add(new URL(dataFile), null, RDFFormat
119: .forFileName(dataFile));
120:
121: // add named graphs
122: for (String graphName : graphNames) {
123: dataCon.add(new URL(graphName), null, RDFFormat
124: .forFileName(graphName), new URIImpl(graphName));
125: }
126:
127: // Evaluate the query on the query data
128: GraphQueryResult result = dataCon.prepareGraphQuery(
129: QueryLanguage.SERQL, query).evaluate();
130: Collection<Statement> actualStatements = Iterations.addAll(
131: result, new ArrayList<Statement>(1));
132: result.close();
133:
134: dataCon.close();
135: dataRep.shutDown();
136:
137: // Create a repository with the expected result data
138: Repository expectedResultRep = new SailRepository(
139: new MemoryStore());
140: expectedResultRep.initialize();
141:
142: RepositoryConnection erCon = expectedResultRep.getConnection();
143:
144: erCon.add(new URL(resultFile), null, RDFFormat
145: .forFileName(resultFile));
146:
147: Collection<Statement> expectedStatements = Iterations.addAll(
148: erCon.getStatements(null, null, null, false),
149: new ArrayList<Statement>(1));
150:
151: erCon.close();
152: expectedResultRep.shutDown();
153:
154: // Compare query result to expected data
155: if (!ModelUtil.equals(actualStatements, expectedStatements)) {
156: // Found differences between expected and actual results
157: StringBuilder message = new StringBuilder(128);
158:
159: Collection<? extends Statement> diff = RepositoryUtil
160: .difference(actualStatements, expectedStatements);
161:
162: message.append("\n=======Diff: ");
163: message.append(getName());
164: message.append("========================\n");
165: if (diff.size() != 0) {
166: message.append("Unexpected statements in result: \n");
167: for (Statement st : diff) {
168: message.append(st.toString());
169: message.append("\n");
170: }
171: message.append("=============");
172: for (int i = 0; i < getName().length(); i++) {
173: message.append("=");
174: }
175: message.append("========================\n");
176: }
177:
178: diff = RepositoryUtil.difference(expectedStatements,
179: actualStatements);
180: if (diff.size() != 0) {
181: message.append("Statements missing in result: \n");
182: for (Statement st : diff) {
183: message.append(st.toString());
184: message.append("\n");
185: }
186: message.append("=============");
187: for (int i = 0; i < getName().length(); i++) {
188: message.append("=");
189: }
190: message.append("========================\n");
191: }
192:
193: logger.error(message.toString());
194: fail(message.toString());
195: }
196:
197: }
198:
199: private String readQuery() throws IOException {
200: InputStream stream = new URL(queryFile).openStream();
201: try {
202: return IOUtil.readString(new InputStreamReader(stream,
203: "UTF-8"));
204: } finally {
205: stream.close();
206: }
207: }
208:
209: /*--------------*
210: * Test methods *
211: *--------------*/
212:
213: public static Test suite() throws Exception {
214: TestSuite suite = new TestSuite();
215:
216: // Read manifest and create declared test cases
217: Repository manifestRep = new SailRepository(new MemoryStore());
218: manifestRep.initialize();
219:
220: RepositoryConnection con = manifestRep.getConnection();
221:
222: URL manifestURL = SeRQLQueryTest.class
223: .getResource(MANIFEST_FILE);
224: con
225: .add(manifestURL, null, RDFFormat
226: .forFileName(MANIFEST_FILE));
227:
228: String query = "SELECT testName, entailment, input, query, result "
229: + "FROM {} mf:name {testName};"
230: + " mf:result {result}; "
231: + " tck:entailment {entailment}; "
232: + " mf:action {} qt:query {query}; "
233: + " qt:data {input} "
234: + "USING NAMESPACE "
235: + " mf = <http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#>, "
236: + " qt = <http://www.w3.org/2001/sw/DataAccess/tests/test-query#>, "
237: + " tck = <urn:openrdf.org:sesame:tests#> ";
238:
239: TupleQueryResult tests = con.prepareTupleQuery(
240: QueryLanguage.SERQL, query).evaluate();
241: while (tests.hasNext()) {
242: BindingSet testBindings = tests.next();
243: String testName = ((Literal) testBindings
244: .getValue("testName")).getLabel();
245: String inputFile = testBindings.getValue("input")
246: .toString();
247: String queryFile = testBindings.getValue("query")
248: .toString();
249: String resultFile = testBindings.getValue("result")
250: .toString();
251: String entailment = ((Literal) testBindings
252: .getValue("entailment")).getLabel();
253:
254: query = "SELECT graph "
255: + "FROM {} mf:name {testName}; "
256: + " mf:action {} qt:graphData {graph} "
257: + "WHERE testName = \""
258: + SeRQLUtil.encodeString(testName)
259: + "\" "
260: + "USING NAMESPACE"
261: + " mf = <http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#>,"
262: + " qt = <http://www.w3.org/2001/sw/DataAccess/tests/test-query#>";
263:
264: List<String> graphNames = new ArrayList<String>();
265:
266: TupleQueryResult graphs = con.prepareTupleQuery(
267: QueryLanguage.SERQL, query).evaluate();
268: while (graphs.hasNext()) {
269: BindingSet graphBindings = graphs.next();
270: graphNames.add(graphBindings.getValue("graph")
271: .toString());
272: }
273: graphs.close();
274:
275: suite.addTest(new SeRQLQueryTest(testName, inputFile,
276: graphNames, queryFile, resultFile, entailment));
277: }
278:
279: tests.close();
280: con.close();
281: manifestRep.shutDown();
282:
283: return suite;
284: }
285: }
|