private void load()
{
var config = new TestConfigManager();
var osd = new TestOnScreenDisplay();
osd.BeginTracking(this, config);
Add(osd);
AddRepeatStep("Change toggle (no bind)", () => config.ToggleSetting(TestConfigSetting.ToggleSettingNoKeybind), 2);
AddRepeatStep("Change toggle (with bind)", () => config.ToggleSetting(TestConfigSetting.ToggleSettingWithKeybind), 2);
AddRepeatStep("Change enum (no bind)", () => config.IncrementEnumSetting(TestConfigSetting.EnumSettingNoKeybind), 3);
AddRepeatStep("Change enum (with bind)", () => config.IncrementEnumSetting(TestConfigSetting.EnumSettingWithKeybind), 3);
}
public void SparqlSimpleQuery1()
{
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing),
"Test Config marks Remote Parsing as unavailable, test cannot be run");
TripleStore store = new TripleStore();
store.AddFromUri(new Uri("http://dbpedia.org/resource/Barack_Obama"));
const string sparqlQuery = "SELECT * WHERE {?s ?p ?o}";
SparqlQueryParser sparqlParser = new SparqlQueryParser();
SparqlQuery query = sparqlParser.ParseFromString(sparqlQuery);
var processor = new LeviathanQueryProcessor(store);
Object results = processor.ProcessQuery(query);
}
public void SparqlSimpleQuery1()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing))
{
throw new SkipTestException("Test Config marks Remote Parsing as unavailable, test cannot be run");
}
TripleStore store = new TripleStore();
store.AddFromUri(new Uri("http://dbpedia.org/resource/Barack_Obama"));
const string sparqlQuery = "SELECT * WHERE {?s ?p ?o}";
SparqlQueryParser sparqlParser = new SparqlQueryParser();
SparqlQuery query = sparqlParser.ParseFromString(sparqlQuery);
Object results = store.ExecuteQuery(query);
}
public void WritingGraphViz3()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseGraphViz))
{
Assert.Inconclusive("Test Config marks GraphViz as unavailable, test cannot be run");
}
Graph g = new Graph();
g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl");
GraphVizGenerator generator = new GraphVizGenerator("png");
generator.Generate(g, "WritingGraphViz3.png", false);
}
public void WritingGraphViz1()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseGraphViz))
{
Assert.Inconclusive("Test Config marks GraphViz as unavailable, test cannot be run");
}
Graph g = new Graph();
g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl");
GraphVizWriter writer = new GraphVizWriter();
writer.Save(g, "WritingGraphViz1.dot");
}
public void WritingGraphViz2()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseGraphViz))
{
throw new SkipTestException("Test Config marks GraphViz as unavailable, test cannot be run");
}
Graph g = new Graph();
g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl");
GraphVizGenerator generator = new GraphVizGenerator("svg");
generator.Generate(g, "WritingGraphViz2.svg", false);
}
public void StorageSparqlUniformHttpProtocolPostCreate()
{
SparqlHttpProtocolConnector connector = SparqlGraphStoreProtocolTest.GetConnection();
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(TestConfigManager.GetSetting(TestConfigManager.LocalGraphStoreUri));
request.Method = "POST";
request.ContentType = "application/rdf+xml";
Graph g = new Graph();
FileLoader.Load(g, "resources\\InferenceTest.ttl");
using (StreamWriter writer = new StreamWriter(request.GetRequestStream()))
{
RdfXmlWriter rdfxmlwriter = new RdfXmlWriter();
rdfxmlwriter.Save(g, writer);
writer.Close();
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
//Should get a 201 Created response
if (response.StatusCode == HttpStatusCode.Created)
{
if (response.Headers["Location"] == null)
{
Assert.Fail("A Location: Header containing the URI of the newly created Graph should have been returned");
}
Uri graphUri = new Uri(response.Headers["Location"]);
Console.WriteLine("New Graph URI is " + graphUri.ToString());
Console.WriteLine("Now attempting to retrieve this Graph from the Store");
Graph h = new Graph();
connector.LoadGraph(h, graphUri);
TestTools.ShowGraph(h);
Assert.AreEqual(g, h, "Graphs should have been equal");
}
else
{
Assert.Fail("A 201 Created response should have been received but got a " + (int)response.StatusCode + " response");
}
response.Close();
}
}
public void SparqlRemoteVirtuosoWithSponging()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseVirtuoso))
{
throw new SkipTestException("Test Config marks Virtuoso as unavailable, cannot run test");
}
SparqlRemoteEndpoint endpoint = new SparqlRemoteEndpoint(new Uri(TestConfigManager.GetSetting(TestConfigManager.VirtuosoEndpoint) + "?should-sponge=soft"));
endpoint.HttpMode = "POST";
String query = "CONSTRUCT { ?s ?p ?o } FROM <http://www.dotnetrdf.org/configuration#> WHERE { ?s ?p ?o }";
IGraph g = endpoint.QueryWithResultGraph(query);
TestTools.ShowGraph(g);
Assert.False(g.IsEmpty, "Graph should not be empty");
}
public void ServiceDescriptionDescriptionUriSparqlServer()
{
EnsureIIS();
String path = TestConfigManager.GetSetting(TestConfigManager.LocalGraphStoreUri) + "description";
Console.WriteLine("Making an request for the Service Description from the web demos SPARQL Server at " + path);
Console.WriteLine();
NTriplesFormatter formatter = new NTriplesFormatter();
Graph g = new Graph();
UriLoader.Load(g, new Uri(path));
TestTools.ShowGraph(g);
Assert.IsFalse(g.IsEmpty, "A non-empty Service Description Graph should have been returned");
}
public void ParsingUriLoaderDBPedia2()
{
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing), "Test Config marks Remote Parsing as unavailable, test cannot be run");
IGraph g = new Graph();
UriLoader.Load(g, new Uri("http://de.dbpedia.org/resource/Disillusion"));
INodeFormatter formatter = new TurtleW3CFormatter();
foreach (INode p in g.Triples.Select(t => t.Predicate).Distinct())
{
Console.WriteLine("ToString() = " + p.ToString());
Console.WriteLine("Formatted = " + p.ToString(formatter));
Console.WriteLine("URI ToString() = " + ((IUriNode)p).Uri.ToString());
}
}
public void SparqlServiceUsingDBPediaAndBindings()
{
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing), "Test Config marks Remote Parsing as unavailable, test cannot be run");
String query = "SELECT * WHERE { SERVICE <http://dbpedia.org/sparql> { ?s a ?type } } VALUES ?s { <http://dbpedia.org/resource/Southampton> <http://dbpedia.org/resource/Ilkeston> }";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
LeviathanQueryProcessor processor = new LeviathanQueryProcessor(new TripleStore());
Object results = processor.ProcessQuery(q);
if (results is SparqlResultSet)
{
TestTools.ShowResults(results);
}
else
{
Assert.True(false, "Should have returned a SPARQL Result Set");
}
}
private void load()
{
var config = new TestConfigManager();
var osd = new TestOnScreenDisplay();
osd.BeginTracking(this, config);
Add(osd);
AddStep("Display empty osd toast", () => osd.Display(new EmptyToast()));
AddAssert("Toast width is 240", () => osd.Child.Width == 240);
AddStep("Display toast with lengthy text", () => osd.Display(new LengthyToast()));
AddAssert("Toast width is greater than 240", () => osd.Child.Width > 240);
AddRepeatStep("Change toggle (no bind)", () => config.ToggleSetting(TestConfigSetting.ToggleSettingNoKeybind), 2);
AddRepeatStep("Change toggle (with bind)", () => config.ToggleSetting(TestConfigSetting.ToggleSettingWithKeybind), 2);
AddRepeatStep("Change enum (no bind)", () => config.IncrementEnumSetting(TestConfigSetting.EnumSettingNoKeybind), 3);
AddRepeatStep("Change enum (with bind)", () => config.IncrementEnumSetting(TestConfigSetting.EnumSettingWithKeybind), 3);
}
public void ParsingBaseUriAssignmentUriLoader()
{
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing), "Test Config marks Remote Parsing as unavailable, test cannot be run");
int defaultTimeout = Options.UriLoaderTimeout;
try
{
//DBPedia can be slow so up the timeout for this test
Options.UriLoaderTimeout = 45000;
Graph g = new Graph();
UriLoader.Load(g, new Uri("http://dbpedia.org/resource/Ilkeston"));
Console.WriteLine("Base URI: " + ShowBaseUri(g.BaseUri));
Assert.NotNull(g.BaseUri);
}
finally
{
//Remember to reset timeout afterwards
Options.UriLoaderTimeout = defaultTimeout;
}
}
public void SparqlRemoteEndpointLongUpdate()
{
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing),
"Test Config marks Remote Parsing as unavailable, test cannot be run");
try
{
Options.HttpDebugging = true;
StringBuilder input = new StringBuilder();
input.AppendLine("LOAD <http://dbpedia.org/resource/Ilkeston>");
input.AppendLine(new String('#', 2048));
SparqlRemoteUpdateEndpoint endpoint = RemoteEndpoints.GetUpdateEndpoint();
endpoint.Update(input.ToString());
}
finally
{
Options.HttpDebugging = false;
}
}
private void TestUpdateUnsynced(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing),
"Test Config marks Remote Parsing as unavailable, test cannot be run");
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
store.Remove(new Uri(TestGraphUri1));
store.ExecuteUpdate("LOAD <http://dbpedia.org/resource/Ilkeston>");
}
finally
{
store.Discard();
store.Dispose();
}
}
public void ParsingRdfXmlNamespaceAttributes()
{
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing),
"Test Config marks Remote Parsing as unavailable, test cannot be run");
Graph g = new Graph();
HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://dbpedia.org/resource/Southampton");
request.Method = "GET";
request.Accept = MimeTypesHelper.HttpAcceptHeader;
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType);
parser.Load(g, new StreamReader(response.GetResponseStream()));
foreach (Triple t in g.Triples)
{
Console.WriteLine(t.ToString());
}
}
public void SparqlEndpointWithExtensions()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteSparql))
{
Assert.Inconclusive("Test Config marks Remote SPARQL as unavailable, test cannot be run");
}
SparqlConnector endpoint = new SparqlConnector(new Uri(TestConfigManager.GetSetting(TestConfigManager.RemoteSparqlQuery)));
String testQuery = @"PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
SELECT * WHERE {?s rdfs:label ?label . ?label bif:contains " + "\"London\" } LIMIT 1";
Console.WriteLine("Testing Sparql Connector with vendor specific extensions in query");
Console.WriteLine();
Console.WriteLine(testQuery);
try
{
Object results = endpoint.Query(testQuery);
Assert.Fail("Parser should reject bif:contains QName");
}
catch (RdfException)
{
//This is OK
}
endpoint.SkipLocalParsing = true;
try
{
Object results = endpoint.Query(testQuery);
TestTools.ShowResults(results);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
Assert.Fail("Query should run fine when local parsing is skipped");
}
}
public void StorageReadWriteSparqlUpdate()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing))
{
throw new SkipTestException("Test Config marks Remote Parsing as unavailable, test cannot be run");
}
try
{
Options.HttpDebugging = true;
ReadWriteSparqlConnector readWrite = ReadWriteSparqlTests.GetConnection();
//Try doing a SPARQL Update LOAD command
String command = "LOAD <http://dbpedia.org/resource/Ilkeston> INTO GRAPH <http://example.org/Ilson>";
readWrite.Update(command);
//Then see if we can retrieve the newly loaded graph
IGraph g = new Graph();
readWrite.LoadGraph(g, "http://example.org/Ilson");
Assert.False(g.IsEmpty, "Graph should be non-empty");
foreach (Triple t in g.Triples)
{
Console.WriteLine(t.ToString(this._formatter));
}
Console.WriteLine();
//Try a DROP Graph to see if that works
command = "DROP GRAPH <http://example.org/Ilson>";
readWrite.Update(command);
g = new Graph();
readWrite.LoadGraph(g, "http://example.org/Ilson");
Assert.True(g.IsEmpty, "Graph should be empty as it should have been DROPped by ReadWriteSparql");
}
finally
{
Options.HttpDebugging = false;
}
}
public void SparqlRemoteEndpointAsyncApiUpdate()
{
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing),
"Test Config marks Remote Parsing as unavailable, test cannot be run");
SparqlRemoteUpdateEndpoint endpoint = RemoteEndpoints.GetUpdateEndpoint();
ManualResetEvent signal = new ManualResetEvent(false);
endpoint.Update("LOAD <http://dbpedia.org/resource/Ilkeston> INTO GRAPH <http://example.org/async/graph>", s =>
{
signal.Set();
signal.Close();
}, null);
Thread.Sleep(AsyncTimeout);
Assert.True(signal.SafeWaitHandle.IsClosed, "Wait Handle should be closed");
//Check that the Graph was really loaded
SparqlRemoteEndpoint queryEndpoint = RemoteEndpoints.GetQueryEndpoint();
IGraph g = queryEndpoint.QueryWithResultGraph("CONSTRUCT FROM <http://example.org/async/graph> WHERE { ?s ?p ?o }");
Assert.False(g.IsEmpty, "Graph should not be empty");
}
public void SparqlServiceUsingDBPedia()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing))
{
throw new SkipTestException("Test Config marks Remote Parsing as unavailable, test cannot be run");
}
String query = "SELECT * WHERE { SERVICE <http://dbpedia.org/sparql> { ?s a ?type } } LIMIT 10";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
LeviathanQueryProcessor processor = new LeviathanQueryProcessor(new TripleStore());
Object results = processor.ProcessQuery(q);
if (results is SparqlResultSet)
{
TestTools.ShowResults(results);
}
else
{
Assert.True(false, "Should have returned a SPARQL Result Set");
}
}
public void SparqlEndpointWithExtensions()
{
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteSparql), "Test Config marks Remote SPARQL as unavailable, test cannot be run");
SparqlConnector endpoint = new SparqlConnector(new Uri(TestConfigManager.GetSetting(TestConfigManager.RemoteSparqlQuery)));
String testQuery = @"PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
SELECT * WHERE {?s rdfs:label ?label . ?label bif:contains " + "\"London\" } LIMIT 1";
Console.WriteLine("Testing Sparql Connector with vendor specific extensions in query");
Console.WriteLine();
Console.WriteLine(testQuery);
Assert.Throws <RdfException>(() =>
{
var r = endpoint.Query(testQuery);
});
endpoint.SkipLocalParsing = true;
Object results = endpoint.Query(testQuery);
TestTools.ShowResults(results);
}
public void StorageSesameSparqlUpdate1()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing))
{
Assert.Inconclusive("Test Config marks Remote Parsing as unavailable, test cannot be run");
}
SesameHttpProtocolConnector sesame = SesameTests.GetConnection();
sesame.Update(@"DROP GRAPH <http://example.org/sparqlUpdateLoad>;
LOAD <http://dbpedia.org/resource/Ilkeston> INTO GRAPH <http://example.org/sparqlUpdateLoad>;
DELETE WHERE
{
GRAPH <http://example.org/sparqlUpdateLoad>
{ ?s <http://www.w3.org/2003/01/geo/wgs84_pos#long> ?long ; <http://www.w3.org/2003/01/geo/wgs84_pos#lat> ?lat }
}");
Graph orig = new Graph();
orig.LoadFromUri(new Uri("http://dbpedia.org/resource/Ilkeston"));
orig.Retract(orig.GetTriplesWithPredicate(new Uri("http://www.w3.org/2003/01/geo/wgs84_pos#long")).ToList());
orig.Retract(orig.GetTriplesWithPredicate(new Uri("http://www.w3.org/2003/01/geo/wgs84_pos#lat")).ToList());
Graph actual = new Graph();
sesame.LoadGraph(actual, "http://example.org/sparqlUpdateLoad");
GraphDiffReport diff = orig.Difference(actual);
if (!diff.AreEqual)
{
TestTools.ShowDifferences(diff);
}
Assert.AreEqual(orig, actual, "Graphs should be equal");
}
public void ParsingUriLoaderDBPedia3()
{
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing), "Test Config marks Remote Parsing as unavailable, test cannot be run");
int defaultTimeout = Options.UriLoaderTimeout;
try
{
Options.HttpDebugging = true;
SetUriLoaderCaching(false);
Options.UriLoaderTimeout = 45000;
Graph g = new Graph();
UriLoader.Load(g, new Uri("http://dbpedia.org/ontology/wikiPageRedirects"), new RdfXmlParser());
Assert.False(g.IsEmpty, "Graph should not be empty");
TestTools.ShowGraph(g);
}
finally
{
Options.HttpDebugging = false;
SetUriLoaderCaching(true);
Options.UriLoaderTimeout = defaultTimeout;
}
}
public static SesameHttpProtocolConnector GetConnection()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseSesame))
{
Assert.Inconclusive("Test Config marks Sesame as unavailable, cannot run test");
}
return(new SesameHttpProtocolConnector(TestConfigManager.GetSetting(TestConfigManager.SesameServer), TestConfigManager.GetSetting(TestConfigManager.SesameRepository)));
}
public static SparqlRemoteUpdateEndpoint GetUpdateEndpoint()
{
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseIIS), "Test Config marks IIS as unavailable, cannot run test");
return(new SparqlRemoteUpdateEndpoint(new Uri(TestConfigManager.GetSetting(TestConfigManager.LocalGraphStoreUpdateUri))));
}
public void ParsingDBPedia()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing))
{
throw new SkipTestException("Test Config marks Remote Parsing as unavailable, test cannot be run");
}
HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://dbpedia.org/resource/London");
request.Accept = "application/rdf+xml";
request.Method = "GET";
#if NET40
request.Timeout = 45000;
#endif
try
{
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
Console.WriteLine("OK");
Console.WriteLine("Content Length: " + response.ContentLength);
Console.WriteLine("Content Type: " + response.ContentType);
Tools.HttpDebugRequest(request);
Tools.HttpDebugResponse(response);
}
}
catch (WebException webEx)
{
Console.WriteLine("ERROR");
Console.WriteLine(webEx.Message);
Console.WriteLine(webEx.StackTrace);
Assert.True(false);
}
request = (HttpWebRequest)WebRequest.Create("http://dbpedia.org/data/London");
request.Accept = "application/rdf+xml";
request.Method = "GET";
#if NET40
request.Timeout = 45000;
#endif
try
{
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
Console.WriteLine("OK");
Console.WriteLine("Content Length: " + response.ContentLength);
Console.WriteLine("Content Type: " + response.ContentType);
Tools.HttpDebugRequest(request);
Tools.HttpDebugResponse(response);
}
}
catch (WebException webEx)
{
Console.WriteLine("ERROR");
Console.WriteLine(webEx.Message);
Console.WriteLine(webEx.StackTrace);
Assert.True(false);
}
try
{
Graph g = new Graph();
Options.HttpDebugging = true;
UriLoader.Load(g, new Uri("http://dbpedia.org/resource/London"));
Console.WriteLine("OK");
Console.WriteLine(g.Triples.Count + " Triples retrieved");
}
catch (Exception ex)
{
Console.WriteLine("ERROR");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
Assert.True(false);
}
finally
{
Options.HttpDebugging = false;
}
}
public static VirtuosoManager GetConnection()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseVirtuoso))
{
Assert.Inconclusive("Test Config marks Virtuoso as unavailable, test cannot be run");
}
return(new VirtuosoManager(TestConfigManager.GetSetting(TestConfigManager.VirtuosoServer), TestConfigManager.GetSettingAsInt(TestConfigManager.VirtuosoPort), TestConfigManager.GetSetting(TestConfigManager.VirtuosoDatabase), TestConfigManager.GetSetting(TestConfigManager.VirtuosoUser), TestConfigManager.GetSetting(TestConfigManager.VirtuosoPassword)));
}
public static SesameHttpProtocolConnector GetConnection()
{
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseSesame), "Test Config marks Sesame as unavailable, cannot run test");
return(new SesameHttpProtocolConnector(TestConfigManager.GetSetting(TestConfigManager.SesameServer), TestConfigManager.GetSetting(TestConfigManager.SesameRepository)));
}
public void SparqlRemoteEndpointSyncVsAsyncTimeLocalVirtuoso()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseVirtuoso))
{
throw new SkipTestException("Test Config marks Virtuoso as unavailable, test cannot be run");
}
String query;
using (StreamReader reader = File.OpenText("dbpedia-query-time.rq"))
{
query = reader.ReadToEnd();
reader.Close();
}
SparqlRemoteEndpoint endpoint = new SparqlRemoteEndpoint(new Uri(TestConfigManager.GetSetting(TestConfigManager.VirtuosoEndpoint)));
endpoint.Timeout = AsyncTimeout;
Stopwatch timer = new Stopwatch();
timer.Start();
SparqlResultSet syncGetResults = endpoint.QueryWithResultSet(query) as SparqlResultSet;
timer.Stop();
Console.WriteLine("Sync Query (GET): " + timer.Elapsed);
TestTools.ShowResults(syncGetResults);
Console.WriteLine();
timer.Reset();
timer.Start();
endpoint.HttpMode = "POST";
SparqlResultSet syncPostResults = endpoint.QueryWithResultSet(query) as SparqlResultSet;
timer.Stop();
Console.WriteLine("Sync Query (POST): " + timer.Elapsed);
TestTools.ShowResults(syncPostResults);
Console.WriteLine();
timer.Reset();
ManualResetEvent signal = new ManualResetEvent(false);
SparqlResultSet asyncResults = null;
//DateTime start = DateTime.Now;
//DateTime end = start;
timer.Start();
endpoint.QueryWithResultSet(query, (r, s) =>
{
//end = DateTime.Now;
timer.Stop();
asyncResults = r;
signal.Set();
signal.Close();
}, null);
Thread.Sleep(AsyncTimeout);
Assert.True(signal.SafeWaitHandle.IsClosed, "Wait Handle should be closed");
Console.WriteLine("Async Query: " + timer.Elapsed);//(end - start));
TestTools.ShowResults(asyncResults);
Assert.Equal(syncGetResults, asyncResults);
}
public static SparqlHttpProtocolConnector GetConnection()
{
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseIIS), "Test Config marks IIS as unavailable, cannot run test");
return(new SparqlHttpProtocolConnector(TestConfigManager.GetSetting(TestConfigManager.LocalGraphStoreUri)));
}
