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));
}
public void SparqlXmlWriter()
{
Graph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
Object results = g.ExecuteQuery("SELECT * WHERE {?s ?p ?o}");
if (results is SparqlResultSet)
{
TestTools.ShowResults(results);
}
StringBuilder output = new StringBuilder();
System.IO.StringWriter writer = new System.IO.StringWriter(output);
SparqlXmlWriter sparqlWriter = new SparqlXmlWriter();
sparqlWriter.Save((SparqlResultSet)results, writer);
Console.WriteLine();
Console.WriteLine(output.ToString());
Console.WriteLine();
SparqlXmlParser parser = new SparqlXmlParser();
SparqlResultSet results2 = new SparqlResultSet();
StringParser.ParseResultSet(results2, output.ToString());
Assert.AreEqual(((SparqlResultSet)results).Count, results2.Count, "Result Sets should have contained same number of Results");
Assert.IsTrue(((SparqlResultSet)results).Equals(results2), "Result Sets should have been equal");
}
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 ParsingResultsWriteThroughHandlerSparqlXml()
{
Graph g = new Graph();
g.LoadFromEmbeddedResource("VDS.RDF.Query.Optimisation.OptimiserStats.ttl");
SparqlResultSet original = g.ExecuteQuery("SELECT * WHERE { ?s ?p ?o }") as SparqlResultSet;
SparqlXmlWriter sparqlWriter = new SparqlXmlWriter();
sparqlWriter.Save(original, "test.custom.srx");
SparqlXmlParser parser = new SparqlXmlParser();
System.IO.StringWriter writer = new System.IO.StringWriter();
ResultWriteThroughHandler handler = new ResultWriteThroughHandler(new SparqlXmlFormatter(), writer, false);
parser.Load(handler, "test.custom.srx");
Console.WriteLine(writer.ToString());
SparqlResultSet results = new SparqlResultSet();
parser.Load(results, new StringReader(writer.ToString()));
Console.WriteLine("Original Result Count: " + original.Count);
Console.WriteLine("Round Trip Result Count: " + results.Count);
Assert.Equal(original, results);
}
public void SparqlJsonResultSet()
{
Console.WriteLine("Tests that JSON Parser parses language specifiers correctly");
String query = "PREFIX rdfs: <" + NamespaceMapper.RDFS + ">\nSELECT DISTINCT ?comment WHERE {?s rdfs:comment ?comment}";
TripleStore store = new TripleStore();
Graph g = new Graph();
FileLoader.Load(g, "json.owl");
store.Add(g);
Object results = store.ExecuteQuery(query);
if (results is SparqlResultSet)
{
SparqlResultSet rset = (SparqlResultSet)results;
//Serialize to both XML and JSON Results format
SparqlXmlWriter xmlwriter = new SparqlXmlWriter();
xmlwriter.Save(rset, "results.xml");
SparqlJsonWriter jsonwriter = new SparqlJsonWriter();
jsonwriter.Save(rset, "results.json");
//Read both back in
SparqlXmlParser xmlparser = new SparqlXmlParser();
SparqlResultSet r1 = new SparqlResultSet();
xmlparser.Load(r1, "results.xml");
Console.WriteLine("Result Set after XML serialization and reparsing contains:");
foreach (SparqlResult r in r1)
{
Console.WriteLine(r.ToString());
}
Console.WriteLine();
SparqlJsonParser jsonparser = new SparqlJsonParser();
SparqlResultSet r2 = new SparqlResultSet();
jsonparser.Load(r2, "results.json");
Console.WriteLine("Result Set after JSON serialization and reparsing contains:");
foreach (SparqlResult r in r2)
{
Console.WriteLine(r.ToString());
}
Console.WriteLine();
Assert.AreEqual(r1, r2, "Results Sets should be equal");
Console.WriteLine("Result Sets were equal as expected");
}
else
{
Assert.Fail("Query did not return a Result Set");
}
}
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);
}
private void CompareSparqlResults(string results, string expectedResultsPath, bool reduced)
{
var p = new SparqlXmlParser();
var actualResultSet = new SparqlResultSet();
using (var tr = new StringReader(results))
{
p.Load(actualResultSet, tr);
}
var expectedResultSet = new SparqlResultSet();
p.Load(expectedResultSet, expectedResultsPath);
var bnodeMap = new Dictionary <string, string>();
CompareSparqlResults(actualResultSet, expectedResultSet, reduced, bnodeMap);
}
public void WritingSparqlXmlWithSpecialCharacters()
{
TripleStore store = new TripleStore();
store.Add(new Graph());
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/graph");
INode subj = g.CreateBlankNode();
INode pred = g.CreateUriNode(new Uri("http://example.org/predicate"));
INode obj1 = g.CreateLiteralNode("with & ampersand");
INode obj2 = g.CreateLiteralNode("with < tags > ");
g.Assert(subj, pred, obj1);
g.Assert(subj, pred, obj2);
store.Add(g);
Object results = store.ExecuteQuery("SELECT * WHERE { ?s ?p ?o }");
if (results is SparqlResultSet)
{
SparqlResultSet rset = (SparqlResultSet)results;
SparqlXmlWriter writer = new SparqlXmlWriter();
writer.Save(rset, "temp.srx");
SparqlXmlParser parser = new SparqlXmlParser();
SparqlResultSet rset2 = new SparqlResultSet();
parser.Load(rset2, "temp.srx");
rset.Trim();
Console.WriteLine("Original Results");
TestTools.ShowResults(rset);
Console.WriteLine();
rset2.Trim();
Console.WriteLine("Serializes and Parsed Results");
TestTools.ShowResults(rset2);
Console.WriteLine();
Assert.AreEqual(rset, rset2, "Result Sets should be equal");
}
else
{
Assert.Fail("Query did not return a Result Set as expected");
}
}
public void SparqlBNodeIDsInResults()
{
SparqlXmlParser xmlparser = new SparqlXmlParser();
SparqlResultSet results = new SparqlResultSet();
xmlparser.Load(results, "resources\\bnodes.srx");
TestTools.ShowResults(results);
Assert.Equal(results.Results.Distinct().Count(), 1);
SparqlJsonParser jsonparser = new SparqlJsonParser();
results = new SparqlResultSet();
jsonparser.Load(results, "resources\\bnodes.json");
TestTools.ShowResults(results);
Assert.Equal(results.Results.Distinct().Count(), 1);
}
public void SparqlBNodeIDsInResults()
{
SparqlXmlParser xmlparser = new SparqlXmlParser();
SparqlResultSet results = new SparqlResultSet();
xmlparser.Load(results, "bnodes.srx");
TestTools.ShowResults(results);
Assert.AreEqual(results.Results.Distinct().Count(), 1, "All Results should be the same as they should all generate same BNode");
SparqlJsonParser jsonparser = new SparqlJsonParser();
results = new SparqlResultSet();
jsonparser.Load(results, "bnodes.json");
TestTools.ShowResults(results);
Assert.AreEqual(results.Results.Distinct().Count(), 1, "All Results should be the same as they should all generate same BNode");
}
public void ParsingResultSetHandlerImplicitSparqlXml()
{
this.EnsureTestData("test.srx");
SparqlXmlParser parser = new SparqlXmlParser();
SparqlResultSet results = new SparqlResultSet();
parser.Load(results, "test.srx");
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);
}
private void CompareSparqlResults(string results, string expectedResultsPath, bool reduced, ISparqlResultsReader resultsReader = null)
{
if (resultsReader == null)
{
resultsReader = new SparqlXmlParser();
}
var actualResultSet = new SparqlResultSet();
using (var tr = new StringReader(results))
{
resultsReader.Load(actualResultSet, tr);
}
var expectedResultSet = new SparqlResultSet();
resultsReader.Load(expectedResultSet, new StreamReader(expectedResultsPath));
var bnodeMap = new Dictionary <string, string>();
CompareSparqlResults(actualResultSet, expectedResultSet, reduced, bnodeMap);
}
public void ParsingMergingResultSetHandler()
{
this.EnsureTestData("test.srx", new SparqlXmlWriter());
SparqlXmlParser parser = new SparqlXmlParser();
SparqlResultSet results = new SparqlResultSet();
MergingResultSetHandler handler = new MergingResultSetHandler(results);
parser.Load(handler, "test.srx");
Assert.False(results.IsEmpty, "Result Set should not be empty");
Assert.Equal(SparqlResultsType.VariableBindings, results.ResultsType);
int count = results.Count;
//Load again
parser.Load(handler, "test.srx");
Assert.Equal(count * 2, results.Count);
}
public void SparqlNegationFullMinued()
{
SparqlQuery lhsQuery = this._parser.ParseFromFile("full-minuend-lhs.rq");
SparqlQuery rhsQuery = this._parser.ParseFromFile("full-minuend-rhs.rq");
SparqlQuery query = this._parser.ParseFromFile("full-minuend.rq");
Graph g = new Graph();
g.LoadFromFile("full-minuend.ttl");
LeviathanQueryProcessor processor = new LeviathanQueryProcessor(new InMemoryQuadDataset(g));
SparqlResultSet lhs = processor.ProcessQuery(lhsQuery) as SparqlResultSet;
Console.WriteLine("LHS Intermediate Results");
TestTools.ShowResults(lhs);
Console.WriteLine();
SparqlResultSet rhs = processor.ProcessQuery(rhsQuery) as SparqlResultSet;
Console.WriteLine("RHS Intermediate Results");
TestTools.ShowResults(rhs);
Console.WriteLine();
SparqlResultSet actual = processor.ProcessQuery(query) as SparqlResultSet;
if (actual == null)
{
Assert.Fail("Null results");
}
SparqlResultSet expected = new SparqlResultSet();
SparqlXmlParser parser = new SparqlXmlParser();
parser.Load(expected, "full-minuend.srx");
Console.WriteLine("Actual Results:");
TestTools.ShowResults(actual);
Console.WriteLine();
Console.WriteLine("Expected Results:");
TestTools.ShowResults(expected);
Assert.AreEqual(expected, actual, "Result Sets should be equal");
}
/// <summary>
/// Gets the list of available stores.
/// </summary>
/// <returns></returns>
public virtual IEnumerable <String> ListStores()
{
try
{
HttpWebRequest request = CreateRequest("repositories", MimeTypesHelper.SparqlResultsXml[0], "GET", new Dictionary <string, string>());
Tools.HttpDebugRequest(request);
ListStringsHandler handler = new ListStringsHandler("id");
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
SparqlXmlParser parser = new SparqlXmlParser();
parser.Load(handler, new StreamReader(response.GetResponseStream()));
response.Close();
}
return(handler.Strings);
}
catch (WebException webEx)
{
throw StorageHelper.HandleHttpError(webEx, "listing Stores from");
}
}
public void WritingSparqlXmlWithNulls()
{
TripleStore store = new TripleStore();
store.Add(new Graph());
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/graph");
store.Add(g);
Object results = store.ExecuteQuery("SELECT DISTINCT ?g WHERE { GRAPH ?g { ?s ?p ?o } }");
if (results is SparqlResultSet)
{
SparqlResultSet rset = (SparqlResultSet)results;
SparqlXmlWriter writer = new SparqlXmlWriter();
writer.Save(rset, "temp.srx");
SparqlXmlParser parser = new SparqlXmlParser();
SparqlResultSet rset2 = new SparqlResultSet();
parser.Load(rset2, "temp.srx");
rset.Trim();
Console.WriteLine("Original Results");
TestTools.ShowResults(rset);
Console.WriteLine();
rset2.Trim();
Console.WriteLine("Serializes and Parsed Results");
TestTools.ShowResults(rset2);
Console.WriteLine();
Assert.AreEqual(rset, rset2, "Result Sets should be equal");
}
else
{
Assert.Fail("Query did not return a Result Set as expected");
}
}
/// <summary>
/// Lists the available stores asynchronously.
/// </summary>
/// <param name="callback">Callback.</param>
/// <param name="state">State to pass to the callback.</param>
public virtual void ListStores(AsyncStorageCallback callback, Object state)
{
HttpWebRequest request = CreateRequest("repositories", MimeTypesHelper.SparqlResultsXml[0], "GET", new Dictionary <string, string>());
ListStringsHandler handler = new ListStringsHandler("id");
try
{
request.BeginGetResponse(r =>
{
try
{
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(r);
SparqlXmlParser parser = new SparqlXmlParser();
parser.Load(handler, new StreamReader(response.GetResponseStream()));
response.Close();
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListStores, handler.Strings), state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListStores, StorageHelper.HandleHttpError(webEx, "listing Stores from")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListStores, StorageHelper.HandleError(ex, "listing Stores from")), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListStores, StorageHelper.HandleHttpError(webEx, "listing Stores from")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListStores, StorageHelper.HandleError(ex, "listing Stores from")), state);
}
}
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);
}
}
