private void CompareResultGraphs(string results, string expectedResultsPath, bool reduced)
{
var expectedResultGraph = new Graph();
FileLoader.Load(expectedResultGraph, expectedResultsPath);
var resultSet = expectedResultGraph.GetUriNode(new Uri("http://www.w3.org/2001/sw/DataAccess/tests/result-set#ResultSet"));
if (resultSet != null)
{
var rdfParser = new SparqlRdfParser();
var xmlParser = new SparqlXmlParser();
var actualResultSet = new SparqlResultSet();
var expectedResultSet = new SparqlResultSet();
using (var tr = new StringReader(results))
{
xmlParser.Load(actualResultSet, tr);
}
rdfParser.Load(expectedResultSet, expectedResultsPath);
var bnodeMap = new Dictionary <string, string>();
CompareSparqlResults(actualResultSet, expectedResultSet, reduced, bnodeMap);
}
else
{
// This is a constructed graph
var actualGraph = new Graph();
actualGraph.LoadFromString(results);
CompareTripleCollections(actualGraph.Triples, expectedResultGraph.Triples, reduced);
}
}
public void SparqlResultSetEquality()
{
SparqlXmlParser parser = new SparqlXmlParser();
SparqlRdfParser rdfparser = new SparqlRdfParser();
SparqlResultSet a = new SparqlResultSet();
SparqlResultSet b = new SparqlResultSet();
parser.Load(a, "resources\\list-3.srx");
parser.Load(b, "resources\\list-3.srx.out");
a.Trim();
b.Trim();
Assert.True(a.Equals(b));
a = new SparqlResultSet();
b = new SparqlResultSet();
parser.Load(a, "resources\\no-distinct-opt.srx");
parser.Load(b, "resources\\no-distinct-opt.srx.out");
a.Trim();
b.Trim();
Assert.True(a.Equals(b));
a = new SparqlResultSet();
b = new SparqlResultSet();
rdfparser.Load(a, "resources\\result-opt-3.ttl");
parser.Load(b, "resources\\result-opt-3.ttl.out");
a.Trim();
b.Trim();
Assert.True(a.Equals(b));
}
private void CompareResultGraphs(string results, string expectedResultsPath, bool reduced)
{
var rdfParser = new SparqlRdfParser();
var xmlParser = new SparqlXmlParser();
var actualResultSet = new SparqlResultSet();
var expectedResultSet = new SparqlResultSet();
using (var tr = new StringReader(results))
{
xmlParser.Load(actualResultSet, tr);
}
rdfParser.Load(expectedResultSet, expectedResultsPath);
CompareSparqlResults(actualResultSet, expectedResultSet, reduced);
}
public void ParsingResultSetHandlerExplicitSparqlRdfJson()
{
this.EnsureTestData("test.sparql.json", new SparqlRdfWriter(new RdfJsonWriter()));
SparqlRdfParser parser = new SparqlRdfParser(new RdfJsonParser());
SparqlResultSet results = new SparqlResultSet();
parser.Load(new ResultSetHandler(results), "test.sparql.json");
NTriplesFormatter formatter = new NTriplesFormatter();
foreach (SparqlResult r in results)
{
Console.WriteLine(r.ToString(formatter));
}
Assert.False(results.IsEmpty, "Result Set should not be empty");
Assert.Equal(SparqlResultsType.VariableBindings, results.ResultsType);
}
public void ParsingResultSetHandlerExplicitSparqlRdfTurtle()
{
this.EnsureTestData("test.sparql.ttl", new SparqlRdfWriter(new CompressingTurtleWriter()));
SparqlRdfParser parser = new SparqlRdfParser(new TurtleParser());
SparqlResultSet results = new SparqlResultSet();
parser.Load(new ResultSetHandler(results), "test.sparql.ttl");
NTriplesFormatter formatter = new NTriplesFormatter();
foreach (SparqlResult r in results)
{
Console.WriteLine(r.ToString(formatter));
}
Assert.IsFalse(results.IsEmpty, "Result Set should not be empty");
Assert.AreEqual(SparqlResultsType.VariableBindings, results.ResultsType, "Results Type should be VariableBindings");
}
/// <summary>
/// Makes a SPARQL Query against the underlying Store processing the results with an appropriate handler from those provided
/// </summary>
/// <param name="rdfHandler">RDF Handler</param>
/// <param name="resultsHandler">Results Handler</param>
/// <param name="sparqlQuery">SPARQL Query</param>
/// <returns></returns>
public virtual void Query(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, String sparqlQuery)
{
try
{
//Pre-parse the query to determine what the Query Type is
bool isAsk = false;
SparqlQuery q = null;
try
{
q = this._parser.ParseFromString(sparqlQuery);
isAsk = q.QueryType == SparqlQueryType.Ask;
}
catch
{
//If parsing error fallback to naive detection
isAsk = Regex.IsMatch(sparqlQuery, "ASK", RegexOptions.IgnoreCase);
}
//Select Accept Header
String accept;
if (q != null)
{
accept = (SparqlSpecsHelper.IsSelectQuery(q.QueryType) || q.QueryType == SparqlQueryType.Ask ? MimeTypesHelper.HttpSparqlAcceptHeader : MimeTypesHelper.HttpAcceptHeader);
}
else
{
accept = MimeTypesHelper.HttpRdfOrSparqlAcceptHeader;
}
HttpWebRequest request;
//Create the Request
Dictionary <String, String> queryParams = new Dictionary <string, string>();
if (sparqlQuery.Length < 2048 && !this._postAllQueries)
{
queryParams.Add("query", EscapeQuery(sparqlQuery));
request = this.CreateRequest(this._repositoriesPrefix + this._store + this._queryPath, accept, "GET", queryParams);
}
else
{
request = this.CreateRequest(this._repositoriesPrefix + this._store + this._queryPath, accept, "POST", queryParams);
//Build the Post Data and add to the Request Body
request.ContentType = MimeTypesHelper.WWWFormURLEncoded;
StringBuilder postData = new StringBuilder();
postData.Append("query=");
postData.Append(Uri.EscapeDataString(EscapeQuery(sparqlQuery)));
StreamWriter writer = new StreamWriter(request.GetRequestStream());
writer.Write(postData);
writer.Close();
}
#if DEBUG
if (Options.HttpDebugging)
{
Tools.HttpDebugRequest(request);
}
#endif
//Get the Response and process based on the Content Type
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
#if DEBUG
if (Options.HttpDebugging)
{
Tools.HttpDebugResponse(response);
}
#endif
StreamReader data = new StreamReader(response.GetResponseStream());
String ctype = response.ContentType;
try
{
//Is the Content Type referring to a Sparql Result Set format?
ISparqlResultsReader resreader = MimeTypesHelper.GetSparqlParser(ctype, isAsk);
resreader.Load(resultsHandler, data);
response.Close();
}
catch (RdfParserSelectionException)
{
//If we get a Parser Selection exception then the Content Type isn't valid for a Sparql Result Set
//Is the Content Type referring to a RDF format?
IRdfReader rdfreader = MimeTypesHelper.GetParser(ctype);
if (q != null && (SparqlSpecsHelper.IsSelectQuery(q.QueryType) || q.QueryType == SparqlQueryType.Ask))
{
SparqlRdfParser resreader = new SparqlRdfParser(rdfreader);
resreader.Load(resultsHandler, data);
}
else
{
rdfreader.Load(rdfHandler, data);
}
response.Close();
}
}
}
catch (WebException webEx)
{
if (webEx.Response != null)
{
#if DEBUG
if (Options.HttpDebugging)
{
Tools.HttpDebugResponse((HttpWebResponse)webEx.Response);
}
#endif
if (webEx.Response.ContentLength > 0)
{
try
{
String responseText = new StreamReader(webEx.Response.GetResponseStream()).ReadToEnd();
throw new RdfQueryException("A HTTP error occured while querying the Store. Store returned the following error message: " + responseText, webEx);
}
catch
{
throw new RdfQueryException("A HTTP error occurred while querying the Store", webEx);
}
}
else
{
throw new RdfQueryException("A HTTP error occurred while querying the Store", webEx);
}
}
else
{
throw new RdfQueryException("A HTTP error occurred while querying the Store", webEx);
}
}
}
private int ProcessEvaluationTest(SparqlQueryParser parser, Triple commentDef, String queryFile, String dataFile, List <String> dataFiles, String resultFile)
{
Console.WriteLine("# Processing Evaluation Test " + Path.GetFileName(queryFile));
if (commentDef != null)
{
Console.WriteLine(commentDef.Object.ToString());
Console.WriteLine();
}
if (dataFiles.Contains(dataFile))
{
dataFiles.Remove(dataFile);
}
if (queryFile.StartsWith("file:///"))
{
queryFile = queryFile.Substring(8);
}
if (dataFile != null && dataFile.StartsWith("file:///"))
{
dataFile = dataFile.Substring(8);
}
if (resultFile.StartsWith("file:///"))
{
resultFile = resultFile.Substring(8);
}
Console.WriteLine("Query File is " + queryFile);
if (evaluationTestOverride.Any(x => queryFile.EndsWith(x)))
{
Console.WriteLine();
Console.WriteLine("# Test Result = Manually overridden to Pass (Test Passed)");
testsPassed++;
testsEvaluationPassed++;
return(1);
}
if (dataFile != null)
{
Console.WriteLine("Default Graph File is " + dataFile);
}
foreach (String file in dataFiles)
{
Console.WriteLine("Uses Named Graph File " + file);
}
Console.WriteLine("Expected Result File is " + resultFile);
Console.WriteLine();
SparqlQuery query;
try
{
query = parser.ParseFromFile(queryFile);
Console.WriteLine(query.ToString());
Console.WriteLine();
Console.WriteLine("Formatted with SparqlFormatter");
SparqlFormatter formatter = new SparqlFormatter(query.NamespaceMap);
Console.WriteLine(formatter.Format(query));
Console.WriteLine();
try
{
Console.WriteLine(query.ToAlgebra().ToString());
Console.WriteLine();
}
catch
{
//Do Nothing
}
}
catch (RdfParseException parseEx)
{
this.ReportError("Query Parser Error", parseEx);
testsFailed++;
testsEvaluationFailed++;
Console.WriteLine("# Test Result = Unable to parse query (Test Failed)");
return(-1);
}
IInMemoryQueryableStore store;
if (dataFile != null)
{
store = new TripleStore();
}
else
{
store = new WebDemandTripleStore();
}
//Load Default Graph
Graph defaultGraph = new Graph();
try
{
if (dataFile != null)
{
FileLoader.Load(defaultGraph, dataFile);
}
store.Add(defaultGraph);
}
catch (RdfParseException parseEx)
{
this.ReportError("Parser Error", parseEx);
testsFailed++;
testsEvaluationFailed++;
Console.WriteLine("# Test Result = Unable to parse Default Graph (Test Failed)");
return(-1);
}
//Load Named Graphs
try
{
foreach (String graphFile in dataFiles)
{
Graph namedGraph = new Graph();
if (graphFile.StartsWith("file:///"))
{
FileLoader.Load(namedGraph, graphFile.Substring(8));
}
else
{
FileLoader.Load(namedGraph, graphFile);
}
store.Add(namedGraph);
}
}
catch (RdfParseException parseEx)
{
this.ReportError("Parser Error", parseEx);
testsFailed++;
testsEvaluationFailed++;
Console.WriteLine("# Test Result - Unable to parse Named Graph (Test Failed)");
return(-1);
}
//Create a Dataset and then Set Graphs
//ISparqlDataset dataset = new InMemoryQuadDataset(store);
ISparqlDataset dataset = new InMemoryDataset(store);
if (!query.DefaultGraphs.Any())
{
query.AddDefaultGraph(defaultGraph.BaseUri);
}
if (!query.NamedGraphs.Any())
{
foreach (String namedGraphUri in dataFiles)
{
query.AddNamedGraph(new Uri(namedGraphUri));
}
}
//Try and get the result
Object results = null;
try
{
LeviathanQueryProcessor processor = new LeviathanQueryProcessor(dataset);
results = processor.ProcessQuery(query);
}
catch (RdfQueryException queryEx)
{
this.ReportError("Query Error", queryEx);
testsFailed++;
testsEvaluationFailed++;
Console.WriteLine("# Test Result - Query execution failed (Test Failed)");
return(-1);
}
catch (Exception ex)
{
this.ReportError("Other Error", ex);
testsFailed++;
testsEvaluationFailed++;
Console.WriteLine("# Test Result - Query failed (Test Failed)");
return(-1);
}
if (results == null)
{
testsFailed++;
testsEvaluationFailed++;
Console.WriteLine("# Test Result - No result was returned from the Query (Test Failed)");
return(-1);
}
//Load in the expected results
if (results is SparqlResultSet)
{
//Save our Results so we can manually compare as needed
SparqlResultSet ourResults = (SparqlResultSet)results;
SparqlXmlWriter writer = new SparqlXmlWriter();
writer.Save(ourResults, resultFile + ".out");
SparqlResultSet expectedResults = new SparqlResultSet();
if (resultFile.EndsWith(".srx"))
{
try
{
SparqlXmlParser resultSetParser = new SparqlXmlParser();
resultSetParser.Load(expectedResults, resultFile);
}
catch (RdfParseException parseEx)
{
this.ReportError("Result Set Parser Error", parseEx);
testsIndeterminate++;
testsEvaluationIndeterminate++;
Console.WriteLine("# Test Result - Error loading expected Result Set (Test Indeterminate)");
return(0);
}
}
else if (resultFile.EndsWith(".ttl") || resultFile.EndsWith(".rdf"))
{
try
{
SparqlRdfParser resultSetParser = new SparqlRdfParser();
resultSetParser.Load(expectedResults, resultFile);
}
catch (RdfParseException parseEx)
{
this.ReportError("Result Set Parser Error", parseEx);
testsIndeterminate++;
testsEvaluationIndeterminate++;
Console.WriteLine("# Test Result - Error loading expected Result Set (Test Indeterminate)");
return(0);
}
}
else
{
testsIndeterminate++;
testsEvaluationIndeterminate++;
Console.WriteLine("# Test Result - Unable to load the expected Result Set (Test Indeterminate)");
return(0);
}
try
{
ourResults.Trim();
expectedResults.Trim();
if (ourResults.Equals(expectedResults))
{
testsPassed++;
testsEvaluationPassed++;
Console.WriteLine("# Test Result - Result Set as expected (Test Passed)");
return(1);
}
else
{
Console.WriteLine("Final Query");
Console.WriteLine(query.ToString());
Console.WriteLine();
this.ShowTestData(store);
this.ShowResultSets(ourResults, expectedResults);
testsFailed++;
testsEvaluationFailed++;
Console.WriteLine("# Test Result - Result Set not as expected (Test Failed)");
return(-1);
}
}
catch (NotImplementedException)
{
this.ShowResultSets(ourResults, expectedResults);
testsIndeterminate++;
testsEvaluationIndeterminate++;
Console.WriteLine("# Test Result - Unable to establish if Result Set was as expected (Test Indeterminate)");
return(0);
}
}
else if (results is Graph)
{
if (resultFile.EndsWith(".ttl"))
{
//Save our Results so we can manually compare as needed
Graph ourResults = (Graph)results;
CompressingTurtleWriter writer = new CompressingTurtleWriter();
writer.Save(ourResults, resultFile + ".out");
try
{
Graph expectedResults = new Graph();
TurtleParser ttlparser = new TurtleParser();
ttlparser.Load(expectedResults, resultFile);
try
{
if (ourResults.Equals(expectedResults))
{
testsPassed++;
testsEvaluationPassed++;
Console.WriteLine("# Test Result - Graph as expected (Test Passed)");
return(1);
}
else
{
this.ShowTestData(store);
this.ShowGraphs(ourResults, expectedResults);
testsFailed++;
testsEvaluationFailed++;
Console.WriteLine("# Test Result - Graph not as expected (Test Failed)");
return(-1);
}
}
catch (NotImplementedException)
{
this.ShowGraphs(ourResults, expectedResults);
testsIndeterminate++;
testsEvaluationIndeterminate++;
Console.WriteLine("# Test Result - Unable to establish if Graph was as expected (Test Indeterminate)");
return(0);
}
}
catch (RdfParseException parseEx)
{
this.ReportError("Graph Parser Error", parseEx);
testsIndeterminate++;
testsEvaluationIndeterminate++;
Console.WriteLine("# Test Result - Error loading expected Graph (Test Indeterminate)");
return(0);
}
}
else
{
testsIndeterminate++;
testsEvaluationIndeterminate++;
Console.WriteLine("# Test Result - Unable to load expected Graph (Test Indeterminate)");
return(0);
}
}
else
{
testsFailed++;
testsEvaluationFailed++;
Console.WriteLine("# Test Result - Didn't produce a Graph as expected (Test Failed)");
return(-1);
}
}
