public void SparqlParsingNestedGraphPatternFirstItem2() { try { SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromFile("childgraphpattern2.rq"); Console.WriteLine(q.ToString()); Console.WriteLine(); Console.WriteLine(q.ToAlgebra().ToString()); } catch (RdfParseException parseEx) { TestTools.ReportError("Parsing Error", parseEx, true); } }
public void SparqlFunctionsNow() { SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromFile("now01.rq"); Console.WriteLine("ToString Output:"); Console.WriteLine(q.ToString()); Console.WriteLine(); SparqlFormatter formatter = new SparqlFormatter(); Console.WriteLine("SparqlFormatter Output:"); Console.WriteLine(formatter.Format(q)); TripleStore store = new TripleStore(); SparqlResultSet results = q.Evaluate(store) as SparqlResultSet; if (results != null) { Assert.IsTrue(results.Result, "Result should be true"); } else { Assert.Fail("Expected a non-null result"); } }
public static void Main(string[] args) { StreamWriter output = new StreamWriter("RdfATestSuite.txt"); String[] wantTrace = { }; String[] wantOutput = { }; bool outputAll = true; bool traceAll = false; String[] skipTests = { "0002.xhtml", "0003.xhtml", "0004.xhtml", "0005.xhtml", "0016.xhtml", "0022.xhtml", "0024.xhtml", "0028.xhtml", "0043.xhtml", "0044.xhtml", "0045.xhtml", "0095.xhtml", "0096.xhtml", "0097.xhtml", "0098.xhtml", "0122.xhtml", "0123.xhtml", "0124.xhtml", "0125.xhtml", "0126.xhtml" }; String[] skipCheck = { "0011.xhtml", "0092.xhtml", "0094.xhtml", "0100.xhtml", "0101.xhtml", "0102.xhtml", "0103.xhtml", }; String[] falseTests = { "0042.xhtml", "0086.xhtml", "0095.xhtml", "0096.xhtml", "0097.xhtml", "0107.xhtml", "0116.xhtml", "0122.xhtml", "0125.xhtml" }; Console.SetOut(output); try { int testsPassed = 0; int testsFailed = 0; String[] files = Directory.GetFiles("rdfa_tests"); RdfAParser parser = new RdfAParser(RdfASyntax.AutoDetectLegacy); parser.Warning += new RdfReaderWarning(parser_Warning); SparqlQueryParser queryparser = new SparqlQueryParser(); bool passed, passDesired; Graph g = new Graph(); Stopwatch timer = new Stopwatch(); long totalTime = 0; long totalTriples = 0; foreach (String file in files) { timer.Reset(); if (skipTests.Contains(Path.GetFileName(file))) { output.WriteLine("## Skipping Test of File " + Path.GetFileName(file)); output.WriteLine(); continue; } if (Path.GetExtension(file) != ".html" && Path.GetExtension(file) != ".xhtml") { continue; } Debug.WriteLine("Testing File " + Path.GetFileName(file)); output.WriteLine("## Testing File " + Path.GetFileName(file)); output.WriteLine("# Test Started at " + DateTime.Now.ToString(TestSuite.TestSuiteTimeFormat)); passed = false; passDesired = true; try { g = new Graph(); g.BaseUri = new Uri("http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/" + Path.GetFileName(file)); if (Path.GetFileNameWithoutExtension(file).StartsWith("bad")) { passDesired = false; output.WriteLine("# Desired Result = Parsing Failed"); } else { output.WriteLine("# Desired Result = Parses OK"); } //if (traceAll || wantTrace.Contains(Path.GetFileName(file))) //{ // parser.TraceTokeniser = true; //} //else //{ // parser.TraceTokeniser = false; //} timer.Start(); parser.Load(g, file); timer.Stop(); Console.WriteLine("Parsing took " + timer.ElapsedMilliseconds + "ms"); passed = true; output.WriteLine("Parsed OK"); if (outputAll || wantOutput.Contains(Path.GetFileName(file))) { NTriplesWriter writer = new NTriplesWriter(); writer.Save(g, "rdfa_tests\\" + Path.GetFileNameWithoutExtension(file) + ".out"); } } catch (IOException ioEx) { reportError(output, "IO Exception", ioEx); } catch (RdfParseException parseEx) { reportError(output, "Parsing Exception", parseEx); } catch (RdfException rdfEx) { reportError(output, "RDF Exception", rdfEx); } catch (Exception ex) { reportError(output, "Other Exception", ex); } finally { timer.Stop(); //Write the Triples to the Output foreach (Triple t in g.Triples) { Console.WriteLine(t.ToString()); } //Now we run the Test SPARQL (if present) if (File.Exists("rdfa_tests/" + Path.GetFileNameWithoutExtension(file) + ".sparql")) { if (skipCheck.Contains(Path.GetFileName(file))) { output.WriteLine("## Skipping Check of File " + Path.GetFileName(file)); output.WriteLine(); } else { try { SparqlQuery q = queryparser.ParseFromFile("rdfa_tests/" + Path.GetFileNameWithoutExtension(file) + ".sparql"); Object results = g.ExecuteQuery(q); if (results is SparqlResultSet) { //The Result is the result of the ASK Query if (falseTests.Contains(Path.GetFileName(file))) { passed = !((SparqlResultSet)results).Result; } else { passed = ((SparqlResultSet)results).Result; } } } catch { passed = false; } } } if (passed && passDesired) { //Passed and we wanted to Pass testsPassed++; output.WriteLine("# Result = Test Passed"); totalTime += timer.ElapsedMilliseconds; totalTriples += g.Triples.Count; } else if (!passed && passDesired) { //Failed when we should have Passed testsFailed++; output.WriteLine("# Result = Test Failed"); } else if (passed && !passDesired) { //Passed when we should have Failed testsFailed++; output.WriteLine("# Result = Test Failed"); } else { //Failed and we wanted to Fail testsPassed++; output.WriteLine("# Result = Test Passed"); } output.WriteLine("# Triples Generated = " + g.Triples.Count()); output.WriteLine("# Test Ended at " + DateTime.Now.ToString(TestSuite.TestSuiteTimeFormat)); } output.WriteLine(); } output.WriteLine(testsPassed + " Tests Passed"); output.WriteLine(testsFailed + " Tests Failed"); output.WriteLine(); output.Write("Total Parsing Time was " + totalTime + " ms"); if (totalTime > 1000) { output.WriteLine(" (" + totalTime / 1000d + " seconds)"); } output.WriteLine("Average Parsing Speed was " + totalTriples / (totalTime / 1000d) + " triples/second"); } catch (Exception ex) { reportError(output, "Other Exception", ex); } Console.SetOut(Console.Out); Console.WriteLine("Done"); Debug.WriteLine("Finished"); output.Close(); }
static void DoQuery(Dictionary<String, String> arguments) { SparqlRemoteEndpoint endpoint; bool verbose = arguments.ContainsKey("verbose") || arguments.ContainsKey("v"); if (verbose) Options.HttpDebugging = true; //First get the Server to which we are going to connect try { if (arguments.ContainsKey("server") && !arguments["server"].Equals(String.Empty)) { endpoint = new SparqlRemoteEndpoint(new Uri(arguments["server"])); } else if (arguments.ContainsKey("service") && !arguments["service"].Equals(String.Empty)) { endpoint = new SparqlRemoteEndpoint(new Uri(arguments["service"])); } else { Console.Error.WriteLine("soh: Error: Required --server/--service argument not present"); Environment.Exit(-1); return; } } catch (UriFormatException uriEx) { Console.Error.WriteLine("soh: Error: Malformed SPARQL Endpoint URI"); Console.Error.WriteLine(uriEx.Message); Environment.Exit(-1); return; } if (verbose) Console.Error.WriteLine("soh: SPARQL Endpoint for URI " + endpoint.Uri + " created OK"); //Then decide where to get the query to execute from SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery query; try { if (arguments.ContainsKey("query") && !arguments["query"].Equals(String.Empty)) { query = parser.ParseFromFile(arguments["query"]); } else if (arguments.ContainsKey("file") && !arguments["file"].Equals(String.Empty)) { query = parser.ParseFromFile(arguments["file"]); } else if (arguments.ContainsKey("$1") && !arguments["$1"].Equals(String.Empty)) { query = parser.ParseFromString(arguments["$1"]); } else { Console.Error.WriteLine("soh: Error: Required SPARQL Query not found - may be specified as --file/--query FILE or as final argument"); Environment.Exit(-1); return; } } catch (Exception ex) { Console.Error.WriteLine("soh: Error: Error Parsing SPARQL Query"); Console.Error.WriteLine(ex.Message); Environment.Exit(-1); return; } if (verbose) { Console.Error.WriteLine("soh: Parsed Query OK"); Console.Error.WriteLine("soh: dotNetRDF's interpretation of the Query:"); SparqlFormatter formatter = new SparqlFormatter(); Console.Error.WriteLine(formatter.Format(query)); Console.Error.WriteLine("soh: Submitting Query"); } try { using (HttpWebResponse response = endpoint.QueryRaw(query.ToString())) { MimeTypeDefinition definition = MimeTypesHelper.GetDefinitions(response.ContentType).FirstOrDefault(); Encoding enc; if (definition != null) { enc = definition.Encoding; } else if (!response.ContentEncoding.Equals(String.Empty)) { enc = Encoding.GetEncoding(response.ContentEncoding); } else if (response.ContentType.Contains("charset=")) { enc = Encoding.GetEncoding(response.ContentType.Substring(response.ContentType.IndexOf('=') + 1)); } else { enc = Console.OutputEncoding; } if (verbose) { Console.Error.WriteLine("soh: Got Response from SPARQL Endpoint OK"); Console.Error.WriteLine("soh: Content-Type: " + response.ContentType); Console.Error.WriteLine("soh: Content-Encoding: " + enc.WebName); } String requestedType = arguments.ContainsKey("accept") ? arguments["accept"] : null; if (requestedType == null || response.ContentType.StartsWith(requestedType, StringComparison.OrdinalIgnoreCase)) { //If no --accept (OR matches servers content type) then just return whatever the server has given us using (StreamReader reader = new StreamReader(response.GetResponseStream())) { using (StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(), enc)) { while (!reader.EndOfStream) { writer.WriteLine(reader.ReadLine()); } writer.Close(); } reader.Close(); } } else { if (verbose) Console.Error.WriteLine("soh: Warning: Retrieved Content Type '" + response.ContentType + "' does not match your desired Content Type '" + requestedType + "' so dotNetRDF will not attempt to transcode the response into your desired format"); //Requested Type Doesn't match servers returned type so parse then serialize MimeTypeDefinition outputDefinition; try { ISparqlResultsReader sparqlParser = MimeTypesHelper.GetSparqlParser(response.ContentType); SparqlResultSet results = new SparqlResultSet(); using (StreamReader reader = new StreamReader(response.GetResponseStream())) { sparqlParser.Load(results, reader); reader.Close(); } outputDefinition = MimeTypesHelper.GetDefinitions(requestedType).FirstOrDefault(d => d.CanWriteSparqlResults || d.CanWriteRdf); if (outputDefinition == null) throw new RdfWriterSelectionException("No MIME Type Definition for the MIME Type '" + requestedType + "' was found that can write SPARQL Results/RDF"); ISparqlResultsWriter writer = outputDefinition.GetSparqlResultsWriter(); Console.OutputEncoding = outputDefinition.Encoding; writer.Save(results, new StreamWriter(Console.OpenStandardOutput(), outputDefinition.Encoding)); } catch (RdfParserSelectionException) { try { IRdfReader rdfParser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); using (StreamReader reader = new StreamReader(response.GetResponseStream())) { rdfParser.Load(g, reader); reader.Close(); } outputDefinition = MimeTypesHelper.GetDefinitions(requestedType).FirstOrDefault(d => d.CanWriteRdf); if (outputDefinition == null) throw new RdfWriterSelectionException("No MIME Type Definition for the MIME Type '" + requestedType + "' was found that can write RDF"); IRdfWriter writer = outputDefinition.GetRdfWriter(); Console.OutputEncoding = outputDefinition.Encoding; writer.Save(g, new StreamWriter(Console.OpenStandardOutput(), outputDefinition.Encoding)); } catch (Exception ex) { //For any other exception show a warning Console.Error.WriteLine("soh: Warning: You wanted results in the format '" + requestedType + "' but the server returned '" + response.ContentType + "' and dotNetRDF was unable to translate the response into your desired format."); Console.Error.WriteLine(ex.Message); } } catch (Exception ex) { //For any other exception show a warning Console.Error.WriteLine("soh: Warning: You wanted results in the format '" + requestedType + "' but the server returned '" + response.ContentType + "' and dotNetRDF was unable to translate the response into your desired format."); Console.Error.WriteLine(ex.Message); } } response.Close(); } if (verbose) Console.Error.WriteLine("soh: Query Completed OK"); } catch (Exception ex) { Console.Error.WriteLine("soh: Error: Error while making the SPARQL Query"); Console.Error.WriteLine(ex.Message); Environment.Exit(-1); return; } }
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 InMemoryDataset dataset = new InMemoryDataset(store); if (!query.DefaultGraphs.Any()) { query.AddDefaultGraph(defaultGraph.BaseUri); //dataset.SetActiveGraph(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 { results = query.Evaluate(dataset); } 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; } }
private void ProcessSyntaxTest(SparqlQueryParser parser, String queryFile, bool shouldParse) { if (queryFile.StartsWith("file:///")) queryFile = queryFile.Substring(8); bool error = false; try { Console.WriteLine("# Processing Syntax Test " + Path.GetFileName(queryFile)); Console.Write("# Result Expected = "); if (shouldParse) { Console.WriteLine("Parses OK"); } else { Console.WriteLine("Parsing Fails"); } SparqlQuery q = parser.ParseFromFile(queryFile); Console.WriteLine(q.ToString()); Console.WriteLine(); Console.WriteLine("Formatted with SparqlFormatter"); SparqlFormatter formatter = new SparqlFormatter(q.NamespaceMap); Console.WriteLine(formatter.Format(q)); Console.WriteLine(); } catch (RdfParseException parseEx) { this.ReportError("Parser Error", parseEx); error = true; } catch (Exception ex) { this.ReportError("Other Error", ex); error = true; } finally { Console.Write("# Result = "); if (error) { if (shouldParse) { Console.WriteLine(" Parsing Failed when should have parsed (Test Failed)"); testsFailed++; testsSyntaxFailed++; } else { Console.WriteLine(" Parsing Failed as expected (Test Passed)"); testsPassed++; testsSyntaxPassed++; } } else { if (shouldParse) { Console.WriteLine(" Parsed OK as expected (Test Passed)"); testsPassed++; testsSyntaxPassed++; } else { Console.WriteLine(" Parsed OK when should have failed (Test Failed)"); testsFailed++; testsSyntaxFailed++; } } Console.WriteLine(new String('-', 150)); } }
private void ProcessSyntaxTest(SparqlQueryParser queryParser, SparqlUpdateParser updateParser, String inputFile, bool shouldParse) { if (inputFile.StartsWith("file:///")) inputFile = inputFile.Substring(8); bool error = false; bool skipFinally = false; try { Console.WriteLine("# Processing Syntax Test " + Path.GetFileName(inputFile)); Console.Write("# Result Expected = "); if (shouldParse) { Console.WriteLine("Parses OK"); } else { Console.WriteLine("Parsing Fails"); } if (evaluationTestOverride.Any(x => inputFile.EndsWith(x))) { Console.WriteLine(); Console.WriteLine("# Test Result = Manually overridden to Pass (Test Passed)"); skipFinally = true; testsPassed++; testsSyntaxPassed++; return; } if (inputFile.EndsWith(".rq")) { SparqlQuery q = queryParser.ParseFromFile(inputFile); Console.WriteLine("Formatted with SparqlFormatter"); SparqlFormatter formatter = new SparqlFormatter(q.NamespaceMap); Console.WriteLine(formatter.Format(q)); Console.WriteLine(); } else if (inputFile.EndsWith(".ru")) { SparqlUpdateCommandSet cmds = updateParser.ParseFromFile(inputFile); Console.WriteLine(cmds.ToString()); Console.WriteLine(); } else { Console.WriteLine("# Test Result - Unknown Input File for Syntax Test (Test Indeterminate)"); skipFinally = true; testsIndeterminate++; testsSyntaxIndeterminate++; return; } } catch (RdfParseException parseEx) { this.ReportError("Parser Error", parseEx); error = true; } catch (Exception ex) { this.ReportError("Other Error", ex); error = true; } finally { if (!skipFinally) { Console.Write("# Test Result = "); if (error) { if (shouldParse) { Console.WriteLine(" Parsing Failed when should have parsed (Test Failed)"); testsFailed++; testsSyntaxFailed++; } else { Console.WriteLine(" Parsing Failed as expected (Test Passed)"); testsPassed++; testsSyntaxPassed++; } } else { if (shouldParse) { Console.WriteLine(" Parsed OK as expected (Test Passed)"); testsPassed++; testsSyntaxPassed++; } else { Console.WriteLine(" Parsed OK when should have failed (Test Failed)"); testsFailed++; testsSyntaxFailed++; } } } Console.WriteLine(new String('-', 150)); } }
public void SparqlEvaluationMultipleOptionals2() { TripleStore store = new TripleStore(); store.LoadFromFile("multiple-options.trig"); SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery query = parser.ParseFromFile("multiple-optionals-alternate.rq"); Object results = query.Evaluate(store); if (results is SparqlResultSet) { TestTools.ShowResults(results); } else { Assert.Fail("Expected a SPARQL Result Set"); } }
public void SparqlEvaluationGraphUnion() { SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromFile("graph-11.rq"); q.BaseUri = new Uri("file:///" + Environment.CurrentDirectory.Replace('\\', '/') + "/"); TripleStore store = new TripleStore(); Graph g = new Graph(); FileLoader.Load(g, "data-g1.ttl"); store.Add(g); Graph h = new Graph(); FileLoader.Load(h, "data-g2.ttl"); store.Add(h); Graph i = new Graph(); FileLoader.Load(i, "data-g3.ttl"); store.Add(i); Graph j = new Graph(); FileLoader.Load(j, "data-g4.ttl"); store.Add(j); InMemoryDataset dataset = new InMemoryDataset(store); q.AddDefaultGraph(g.BaseUri); q.AddNamedGraph(g.BaseUri); q.AddNamedGraph(h.BaseUri); q.AddNamedGraph(i.BaseUri); q.AddNamedGraph(j.BaseUri); SparqlFormatter formatter = new SparqlFormatter(q.NamespaceMap); Object results; //Try the full Query Console.WriteLine("Full Query"); Console.WriteLine(formatter.Format(q)); results = q.Evaluate(dataset); if (results is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)results; TestTools.ShowResults(rset); //SparqlRdfParser resultsParser = new SparqlRdfParser(new TurtleParser()); //SparqlResultSet expected = new SparqlResultSet(); //resultsParser.Load(expected, "graph-11.ttl"); //Console.WriteLine(); //Console.WriteLine("Expected Results"); //TestTools.ShowResults(expected); //Assert.AreEqual(rset, expected, "Result Sets should be equal"); } else { Assert.Fail("Didn't get a Result Set as expected"); } }
public void SparqlEvaluationComplexOptionalGraphUnion() { SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromFile("q-opt-complex-4.rq"); TripleStore store = new TripleStore(); Graph g = new Graph(); FileLoader.Load(g, "complex-data-2.ttl"); store.Add(g); Graph h = new Graph(); FileLoader.Load(h, "complex-data-1.ttl"); store.Add(h); InMemoryDataset dataset = new InMemoryDataset(store); q.AddDefaultGraph(g.BaseUri); q.AddNamedGraph(h.BaseUri); SparqlFormatter formatter = new SparqlFormatter(q.NamespaceMap); Object results; //Examine limited parts of the Query to see why it doesn't work properly SparqlParameterizedString unionClause = new SparqlParameterizedString(); unionClause.Namespaces = q.NamespaceMap; unionClause.QueryText = "SELECT * WHERE { ?person foaf:name ?name . { ?person ex:healthplan ?plan . } UNION { ?person ex:department ?dept . } }"; SparqlQuery unionQuery = parser.ParseFromString(unionClause); Console.WriteLine("UNION Clause Only"); Console.WriteLine(formatter.Format(unionQuery)); results = unionQuery.Evaluate(dataset); if (results is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)results; TestTools.ShowResults(rset); } else { Assert.Fail("Didn't get a Result Set as expected"); } Console.WriteLine(); //Try the Optional Clause SparqlParameterizedString optionalClause = new SparqlParameterizedString(); optionalClause.Namespaces = q.NamespaceMap; optionalClause.QueryText = "SELECT * WHERE { OPTIONAL { ?person a foaf:Person . GRAPH ?g { [] foaf:depiction ?img ; foaf:name ?name } } }"; SparqlQuery optionalQuery = parser.ParseFromString(optionalClause); Console.WriteLine("OPTIONAL Clause Only"); Console.WriteLine(formatter.Format(optionalQuery)); results = optionalQuery.Evaluate(dataset); if (results is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)results; TestTools.ShowResults(rset); } else { Assert.Fail("Didn't get a Result Set as expected"); } Console.WriteLine(); //Try the full Query with a SELECT * to examine all the values SparqlParameterizedString fullQuery = new SparqlParameterizedString(); fullQuery.Namespaces = q.NamespaceMap; fullQuery.QueryText = "SELECT * WHERE { ?person foaf:name ?name . { ?person ex:healthplan ?plan . } UNION { ?person ex:department ?dept . } OPTIONAL { ?person a foaf:Person . GRAPH ?g { [] foaf:depiction ?img ; foaf:name ?name } } }"; SparqlQuery q2 = parser.ParseFromString(fullQuery); Console.WriteLine("Full Query as a SELECT *"); Console.WriteLine(formatter.Format(q2)); results = q2.Evaluate(dataset); if (results is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)results; TestTools.ShowResults(rset); } else { Assert.Fail("Didn't get a Result Set as expected"); } Console.WriteLine(); //Try the full Query Console.WriteLine("Full Query"); Console.WriteLine(formatter.Format(q)); results = q.Evaluate(dataset); if (results is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)results; TestTools.ShowResults(rset); SparqlRdfParser resultsParser = new SparqlRdfParser(new TurtleParser()); SparqlResultSet expected = new SparqlResultSet(); resultsParser.Load(expected, "result-opt-complex-4.ttl"); Console.WriteLine(); Console.WriteLine("Expected Results"); TestTools.ShowResults(expected); Assert.AreEqual(rset, expected, "Result Sets should be equal"); } else { Assert.Fail("Didn't get a Result Set as expected"); } }
public void SparqlAnton() { Graph g = new Graph(); FileLoader.Load(g, "anton.rdf"); SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery query = parser.ParseFromFile("anton.rq"); Object results = g.ExecuteQuery(query); if (results is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)results; foreach (SparqlResult r in rset) { Console.WriteLine(r); } Assert.AreEqual(1, rset.Count, "Should be exactly 1 result"); } else { Assert.Fail("Query should have returned a Result Set"); } }
public static void Main(string[] args) { StreamWriter output = new StreamWriter("SPARQLTestSuite.txt"); Console.SetOut(output); try { int testsPassed = 0; int testsFailed = 0; bool passed, passDesired; SparqlQueryParser parser = new SparqlQueryParser(); parser.TraceTokeniser = true; parser.DefaultBaseUri = TestSuiteURI; output.WriteLine("## SPARQL Test Suite"); output.WriteLine(); String[] dirs = Directory.GetDirectories("sparqlparser_tests"); foreach (String dir in dirs) { if (dir.Contains(".svn")) { continue; } String[] files = Directory.GetFiles(dir); foreach (String file in files) { if (!Path.GetExtension(file).Equals(".rq")) { continue; } passed = false; passDesired = true; output.WriteLine("## Testing " + file); output.WriteLine("# Test Started at " + DateTime.Now.ToString(TestSuite.TestSuiteTimeFormat)); if (Path.GetFileNameWithoutExtension(file).Contains("bad")) { passDesired = false; output.WriteLine("# Desired Result = Parsing Failed"); } else { output.WriteLine("# Desired Result = Parses OK"); } try { Debug.WriteLine("Testing file " + file); SparqlQuery q = parser.ParseFromFile(file); passed = true; } catch (IOException ioEx) { reportError(output, "IO Exception", ioEx); } catch (RdfParseException parseEx) { reportError(output, "Parsing Exception", parseEx); } catch (RdfException rdfEx) { reportError(output, "RDF Exception", rdfEx); } catch (Exception ex) { reportError(output, "Other Exception", ex); } finally { if (passed && passDesired) { //Passed and we wanted to Pass testsPassed++; output.WriteLine("# Result = Test Passed"); } else if (!passed && passDesired) { //Failed when we should have Passed testsFailed++; output.WriteLine("# Result = Test Failed"); } else if (passed && !passDesired) { //Passed when we should have Failed testsFailed++; output.WriteLine("# Result = Test Failed"); } else { //Failed and we wanted to Fail testsPassed++; output.WriteLine("# Result = Test Passed"); } output.WriteLine("# Test Ended at " + DateTime.Now.ToString(TestSuite.TestSuiteTimeFormat)); } output.WriteLine(); } } output.WriteLine(testsPassed + " Tests Passed"); output.WriteLine(testsFailed + " Tests Failed"); } catch (IOException ioEx) { reportError(output, "IO Exception", ioEx); } catch (RdfParseException parseEx) { reportError(output, "Parsing Exception", parseEx); } catch (RdfException rdfEx) { reportError(output, "RDF Exception", rdfEx); } catch (Exception ex) { reportError(output, "Other Exception", ex); } output.Close(); }