public void SparqlRemoteEndpointAsyncApiUpdate()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing))
{
throw new SkipTestException("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 SparqlRemoteEndpointWriteThroughHandler()
{
SparqlRemoteEndpoint endpoint = RemoteEndpoints.GetQueryEndpoint();
WriteThroughHandler handler = new WriteThroughHandler(typeof(NTriplesFormatter), Console.Out, false);
endpoint.QueryWithResultGraph(handler, "CONSTRUCT WHERE { ?s ?p ?o }");
}
public void SparqlRemoteEndpointLongQuery()
{
try
{
Options.HttpDebugging = true;
StringBuilder input = new StringBuilder();
input.AppendLine("SELECT * WHERE {?s ?p ?o}");
input.AppendLine(new String('#', 2048));
SparqlRemoteEndpoint endpoint = RemoteEndpoints.GetQueryEndpoint();
Object results = endpoint.QueryWithResultSet(input.ToString());
if (results is SparqlResultSet)
{
TestTools.ShowResults(results);
}
else
{
Assert.Fail("Should have returned a SPARQL Result Set");
}
}
finally
{
Options.HttpDebugging = false;
}
}
public void SparqlRemoteEndpointMemoryLeak2()
{
//Do a GC before attempting the test
GC.GetTotalMemory(true);
//First off make sure to load some data into the some
SparqlRemoteUpdateEndpoint updateEndpoint = RemoteEndpoints.GetUpdateEndpoint();
updateEndpoint.Update("DROP ALL");
int totalRuns = 10000;
int subjects = 1000;
int predicates = 10;
//Loop over making queries to try and reproduce the memory leak
for (int i = 1; i <= totalRuns; i++)
{
//Add new data each time around
updateEndpoint.Update("INSERT DATA { <http://subject/" + (i % subjects) + "> <http://predicate/" + (i % predicates) + "> <http://object/" + i + "> . }");
SparqlRemoteEndpoint endpoint = RemoteEndpoints.GetQueryEndpoint();
SparqlParameterizedString queryString = new SparqlParameterizedString();
queryString.CommandText = "SELECT * WHERE { <http://subject/" + (i % 1000) + "> ?p ?o }";
ResultCountHandler handler = new ResultCountHandler();
endpoint.QueryWithResultSet(handler, queryString.ToString());
Assert.True(handler.Count >= 1 && handler.Count <= subjects, "Result Count " + handler.Count + " is not in expected range 1 <= x < " + (i % 1000));
if (i % 500 == 0)
{
Debug.WriteLine("Memory Usage after " + i + " Iterations: " + Process.GetCurrentProcess().PrivateMemorySize64);
}
}
Debug.WriteLine("Memory Usage after " + totalRuns + " Iterations: " + Process.GetCurrentProcess().PrivateMemorySize64);
}
public void SparqlRemoteEndpointResultCountHandler()
{
SparqlRemoteEndpoint endpoint = RemoteEndpoints.GetQueryEndpoint();
ResultCountHandler handler = new ResultCountHandler();
endpoint.QueryWithResultSet(handler, "SELECT * WHERE { { ?s ?p ?o } UNION { GRAPH ?g { ?s ?p ?o } } }");
Console.WriteLine("Result Count: " + handler.Count);
Assert.NotEqual(0, handler.Count);
}
public void SparqlRemoteEndpointCountHandler()
{
SparqlRemoteEndpoint endpoint = RemoteEndpoints.GetQueryEndpoint();
CountHandler handler = new CountHandler();
endpoint.QueryWithResultGraph(handler, "CONSTRUCT { ?s ?p ?o } WHERE { { ?s ?p ?o } UNION { GRAPH ?g { ?s ?p ?o } } }");
Console.WriteLine("Triple Count: " + handler.Count);
Assert.NotEqual(0, handler.Count);
}
public void SparqlRemoteEndpointSyncVsAsyncTimeLocal()
{
String query;
using (StreamReader reader = File.OpenText("resources\\dbpedia-query-time.rq"))
{
query = reader.ReadToEnd();
reader.Close();
}
SparqlRemoteEndpoint endpoint = RemoteEndpoints.GetQueryEndpoint();
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 void SparqlRemoteEndpointAsyncApiQueryWithResultGraph()
{
SparqlRemoteEndpoint endpoint = RemoteEndpoints.GetQueryEndpoint();
ManualResetEvent signal = new ManualResetEvent(false);
endpoint.QueryWithResultGraph("CONSTRUCT WHERE { ?s ?p ?o }", (r, s) =>
{
TestTools.ShowResults(r);
signal.Set();
signal.Close();
}, null);
Thread.Sleep(AsyncTimeout);
Assert.True(signal.SafeWaitHandle.IsClosed, "Wait Handle should be closed");
}
public void SparqlRemoteEndpointMemoryLeak1()
{
/*
* Dim endpoint = New SparqlRemoteEndpoint(New Uri("http://localhost:8080/sesame/repositories/my_repo"))
* Dim queryString As SparqlParameterizedString = New SparqlParameterizedString()
* queryString.Namespaces.AddNamespace("annot", New Uri(oAppSettingsReader.GetValue("BaseUriSite", GetType(System.String)) & "/annotations.owl#"))
* queryString.CommandText = "SELECT DISTINCT ?text WHERE {?annotation annot:onContent <" & _uriDocument & "> ; annot:onContentPart """ & ContentPart & """ ; annot:text ?text ; annot:isValid ""false""^^xsd:boolean . }"
* Dim results As SparqlResultSet = endpoint.QueryWithResultSet(queryString.ToString)
* For Each result As SparqlResult In results
* Console.WriteLine(DirectCast(result.Value("text"), LiteralNode).Value)
* Next
* results.Dispose()
*/
//Do a GC before attempting the test
GC.GetTotalMemory(true);
//First off make sure to load some data into the some
SparqlRemoteUpdateEndpoint updateEndpoint = RemoteEndpoints.GetUpdateEndpoint();
updateEndpoint.Update("DROP ALL; INSERT DATA { <http://subject> <http://predicate> <http://object> . }");
int totalRuns = 10000;
//Loop over making queries to try and reproduce the memory leak
for (int i = 1; i <= totalRuns; i++)
{
SparqlRemoteEndpoint endpoint = RemoteEndpoints.GetQueryEndpoint();
SparqlParameterizedString queryString = new SparqlParameterizedString();
queryString.CommandText = "SELECT * WHERE { ?s ?p ?o }";
SparqlResultSet results = endpoint.QueryWithResultSet(queryString.ToString());
Assert.Equal(1, results.Count);
foreach (SparqlResult result in results)
{
//We're just iterating to make sure we touch the whole of the results
}
results.Dispose();
if (i % 500 == 0)
{
Debug.WriteLine("Memory Usage after " + i + " Iterations: " + Process.GetCurrentProcess().PrivateMemorySize64);
}
}
Debug.WriteLine("Memory Usage after " + totalRuns + " Iterations: " + Process.GetCurrentProcess().PrivateMemorySize64);
}
public void SparqlRemoteEndpointLongUpdate()
{
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;
}
}
public void SparqlRemoteEndpointAsyncApiUpdate()
{
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.IsTrue(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.IsFalse(g.IsEmpty, "Graph should not be empty");
}
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;
}
}
