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; } }