public void ImportRdfFromUrl(string url)
{
int statementCount = mRdfStore.StatementCount;
mRdfStore.Import(RdfXmlReader.LoadFromUri(new Uri(url)));
mLogger.Info("ImportRdfFromUri", "Imported {0} statements.", mRdfStore.StatementCount - statementCount);
}
public void Load(System.IO.Stream stream)
{
try {
RdfXmlReader reader = new RdfXmlReader(stream);
reader.BaseUri = MetadataStore.FSpotXMPBase;
store.Import(reader);
//Dump ();
} catch (System.Exception e) {
Beagle.Util.Log.Error(e, "Error loading TIFF file");
}
}
public void Load(System.IO.Stream stream)
{
try {
RdfXmlReader reader = new RdfXmlReader(stream);
reader.BaseUri = MetadataStore.FSpotXMPBase;
store.Import(reader);
//Dump ();
} catch (System.Exception e) {
System.Console.WriteLine(e.ToString());
}
}
private static MemoryStore LoadResults(Path file)
{
var store = new MemoryStore();
using (var reader = new RdfXmlReader(file.FullPath))
reader.Select(store);
Console.WriteLine("Loaded {0} statements.", store.StatementCount);
return(store);
}
public void Load(System.IO.Stream stream)
{
try {
RdfXmlReader reader = new RdfXmlReader(stream);
reader.BaseUri = MetadataStore.FSpotXMPBase;
store.Import(reader);
//Dump ();
} catch (System.Exception e) {
Log.DebugFormat("Caught an exception :{0}", e.ToString());
}
}
public static void Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine("runtests.exe basepath manifestfile");
return;
}
basepath = args[0];
string manifestfile = Path.Combine(basepath, args[1]);
RdfReader reader = new RdfXmlReader(manifestfile);
if (!manifestfile.EndsWith(".rdf"))
{
reader = new N3Reader(manifestfile);
}
reader.BaseUri = "http://www.example.org/";
MemoryStore testlist = new MemoryStore(reader);
// RDF/XML TESTS
foreach (Entity test in testlist.GetEntitiesOfType("http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#PositiveParserTest"))
{
RunTest(testlist, test, true, 0);
}
foreach (Entity test in testlist.GetEntitiesOfType("http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#NegativeParserTest"))
{
RunTest(testlist, test, false, 0);
}
// N3 TESTS
foreach (Entity test in testlist.GetEntitiesOfType("http://www.w3.org/2004/11/n3test#PositiveParserTest"))
{
RunTest(testlist, test, true, 1);
}
foreach (Entity test in testlist.GetEntitiesOfType("http://www.w3.org/2004/11/n3test#NegativeParserTest"))
{
RunTest(testlist, test, false, 1);
}
Console.WriteLine("Total Tests:\t{0}", total);
Console.WriteLine("Total Failures:\t{0} ({1}%)", badfail + badpass, (int)(100 * (float)(badpass + badfail) / total));
Console.WriteLine("Positive Fails:\t{0}", badfail);
Console.WriteLine("Negative Fails:\t{0}", badpass);
Console.WriteLine("Test Errors:\t{0}", error);
}
private void resolveAsynchronousData(MemoryStore output, string uri)
{
while (uri != null)
{
//SADIHelper.debug("SADIService", "fetching asynchronous data", uri);
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
request.Method = "GET";
request.AllowAutoRedirect = false;
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
if (response.StatusCode == HttpStatusCode.Redirect)
{
String newURL = response.Headers["Location"];
if (newURL != null)
{
uri = newURL;
}
int toSleep = 5;
String retry = response.Headers["Retry-After"];
try
{
if (retry != null)
{
toSleep = Int16.Parse(retry);
}
}
catch (Exception e)
{
SADIHelper.error("SADIService", "failed to parse Retry-After header", retry, e);
}
//SADIHelper.debug("SADIService", "sleeping " + toSleep + "s before asynchronous request", null);
System.Threading.Thread.Sleep(toSleep * 1000);
}
else
{
Stream stream = response.GetResponseStream();
StreamReader reader = new StreamReader(stream);
using (RdfReader rdfReader = new RdfXmlReader(reader))
{
output.Import(rdfReader);
}
reader.Close();
stream.Close();
uri = null;
}
response.Close();
}
}
public MemoryStore invokeService(Store input)
{
//SADIHelper.debug("SADIService", "sending data to " + uri, input);
WebRequest request = WebRequest.Create(this.uri);
request.ContentType = "text/rdf+n3";
request.Method = "POST";
Stream stream = request.GetRequestStream();
StreamWriter writer = new StreamWriter(stream);
/// using (RdfWriter rdfWriter = new RdfXmlWriter("C:\\Users\\Luke\\Desktop\\input.rdf"))
/// {
/// rdfWriter.Write(input);
/// }
/// using (RdfWriter rdfWriter = new RdfXmlWriter(writer))
using (N3Writer rdfWriter = new N3Writer(writer))
{
rdfWriter.Write(input);
}
writer.Close();
stream.Close();
MemoryStore output = new MemoryStore();
WebResponse response = request.GetResponse();
stream = response.GetResponseStream();
StreamReader reader = new StreamReader(stream);
using (RdfReader rdfReader = new RdfXmlReader(reader))
{
output.Import(rdfReader);
}
reader.Close();
stream.Close();
response.Close();
//SADIHelper.debug("SADIService", "read data from " + uri, output);
if (((HttpWebResponse)response).StatusCode == HttpStatusCode.Accepted)
{
resolveAsynchronousData(output);
}
return(output);
}
static void RunTest(Entity test, Store manifest)
{
Entity rdf_type = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
Entity mf_PositiveSyntaxTest = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#PositiveSyntaxTest";
Entity mf_NegativeSyntaxTest = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#NegativeSyntaxTest";
Entity mf_QueryTest = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#QueryEvaluationTest";
Entity mf_action = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#action";
Entity mf_result = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#result";
Entity qt_data = "http://www.w3.org/2001/sw/DataAccess/tests/test-query#data";
Entity qt_query = "http://www.w3.org/2001/sw/DataAccess/tests/test-query#query";
Entity test_type = (Entity)manifest.SelectObjects(test, rdf_type)[0];
Entity action = (Entity)manifest.SelectObjects(test, mf_action)[0];
if (test_type == mf_PositiveSyntaxTest || test_type == mf_NegativeSyntaxTest)
{
// The action is a query.
// Load the action as a string.
string q = ReadFile(action.Uri);
// Run the action.
try {
new SparqlEngine(q);
} catch (SemWeb.Query.QueryFormatException qfe) {
// On a negative test: Good!
if (test_type == mf_NegativeSyntaxTest)
{
pass++;
return;
}
Console.WriteLine("Test Failed: " + action);
Console.WriteLine(qfe.Message);
Console.WriteLine(q);
Console.WriteLine();
fail++;
return;
}
// On a positive test: Good!
if (test_type == mf_PositiveSyntaxTest)
{
pass++;
return;
}
Console.WriteLine("Test Failed: " + action);
Console.WriteLine("Query is syntactically incorrect.");
Console.WriteLine(q);
Console.WriteLine();
fail++;
}
else if (test_type == mf_QueryTest)
{
Entity data = (Entity)manifest.SelectObjects(action, qt_data)[0];
Entity query = (Entity)manifest.SelectObjects(action, qt_query)[0];
Entity result = (Entity)manifest.SelectObjects(test, mf_result)[0];
MemoryStore data_store = new MemoryStore(new N3Reader(data.Uri));
string q = ReadFile(query.Uri);
if (q.IndexOf("ASK") >= 0)
{
Console.WriteLine("ASK Test Skipped: " + test);
skip++;
return;
}
string run_individual_test = "mono ../../bin/rdfquery.exe -type sparql n3:" + data.Uri + " < " + query.Uri;
SparqlEngine sp;
try {
sp = new SparqlEngine(q);
} catch (SemWeb.Query.QueryFormatException qfe) {
Console.WriteLine("Test Failed: " + test);
Console.WriteLine(run_individual_test);
Console.WriteLine(q);
Console.WriteLine(qfe.Message);
Console.WriteLine();
fail++;
return;
}
QueryResultBuffer results = new QueryResultBuffer();
bool results_bool = false;
try {
if (sp.Type != SparqlEngine.QueryType.Ask)
{
sp.Run(data_store, results);
}
else
{
results_bool = sp.Ask(data_store);
}
} catch (Exception e) {
Console.WriteLine("Test Failed: " + test);
Console.WriteLine(run_individual_test);
Console.WriteLine(q);
Console.WriteLine(e);
Console.WriteLine();
fail++;
return;
}
bool failed = false;
StringBuilder info = new StringBuilder();
if (result.Uri.EndsWith(".ttl") || result.Uri.EndsWith(".srx") || result.Uri.EndsWith(".rdf"))
{
bool sorted = false;
QueryResultBuffer results2 = new QueryResultBuffer();
if (result.Uri.EndsWith(".srx"))
{
using (FileStream fs = new FileStream(result.Uri, FileMode.Open))
SemWeb.Remote.SparqlHttpSource.ParseSparqlResponse(fs, results2);
}
else if (result.Uri.EndsWith(".rdf") || result.Uri.EndsWith(".ttl"))
{
RdfReader reader = null;
if (result.Uri.EndsWith(".rdf"))
{
reader = new RdfXmlReader(result.Uri);
}
else if (result.Uri.EndsWith(".ttl"))
{
reader = new N3Reader(result.Uri);
}
MemoryStore result_store = new MemoryStore(reader);
string rs = "http://www.w3.org/2001/sw/DataAccess/tests/result-set#";
Entity rsResultSet = rs + "ResultSet";
Entity rsresultVariable = rs + "resultVariable";
Entity rssolution = rs + "solution";
Entity rsindex = rs + "index";
Entity rsbinding = rs + "binding";
Entity rsvariable = rs + "variable";
Entity rsvalue = rs + "value";
// get a list of variables in the query output
Entity resultset = result_store.GetEntitiesOfType(rsResultSet)[0];
ArrayList vars = new ArrayList();
foreach (Literal var in result_store.SelectObjects(resultset, rsresultVariable))
{
vars.Add(new Variable(var.Value));
}
Variable[] varsarray = (Variable[])vars.ToArray(typeof(Variable));
// try to order as best we can to our own output, so we sort the results the same way
for (int i = 0; i < results.Variables.Length; i++)
{
if (i >= varsarray.Length)
{
break;
}
for (int j = i; j < varsarray.Length; j++)
{
if (varsarray[j].LocalName == results.Variables[i].LocalName)
{
Variable temp = varsarray[i];
varsarray[i] = varsarray[j];
varsarray[j] = temp;
break;
}
}
}
Hashtable varmap = new Hashtable();
foreach (Variable v in varsarray)
{
varmap[v.LocalName] = varmap.Count;
}
results2.Init(varsarray);
Resource[] resultbindings = result_store.SelectObjects(resultset, rssolution);
// Try sorting by index
int[] indexes = new int[resultbindings.Length];
for (int i = 0; i < resultbindings.Length; i++)
{
Entity binding = (Entity)resultbindings[i];
Literal index = (Literal)result_store.SelectObjects(binding, rsindex)[0];
indexes[i] = (int)(Decimal)index.ParseValue();
sorted = true;
}
Array.Sort(indexes, resultbindings);
// Add bindings into results2.
for (int i = 0; i < resultbindings.Length; i++)
{
Resource[] row = new Resource[vars.Count];
Entity binding = (Entity)resultbindings[i];
foreach (Entity var in result_store.SelectObjects(binding, rsbinding))
{
string name = ((Literal)result_store.SelectObjects(var, rsvariable)[0]).Value;
Resource val = result_store.SelectObjects(var, rsvalue)[0];
row[(int)varmap[name]] = val;
}
results2.Add(new VariableBindings(varsarray, row));
}
}
// Check variable list
ArrayList vars1 = new ArrayList();
foreach (Variable v in results.Variables)
{
vars1.Add(v.LocalName);
}
ArrayList vars2 = new ArrayList();
foreach (Variable v in results2.Variables)
{
vars2.Add(v.LocalName);
}
failed |= !SetsSame(vars1, vars2, "Result Set Variables", info);
// Checking bindings
if (results.Bindings.Count != results2.Bindings.Count)
{
info.Append("Solutions have different number of bindings.\n");
failed = true;
}
else
{
// Now actually run comparison.
if (!sorted)
{
((ArrayList)results.Bindings).Sort();
((ArrayList)results2.Bindings).Sort();
}
for (int i = 0; i < results.Bindings.Count; i++)
{
VariableBindings b1 = (VariableBindings)results.Bindings[i];
VariableBindings b2 = (VariableBindings)results2.Bindings[i];
foreach (Variable var in results.Variables)
{
Resource val1 = b1[var.LocalName];
Resource val2 = b2[var.LocalName];
if (val1 != val2 && !(val1 is BNode) && !(val2 is BNode)) // TODO: Test bnodes are returned correctly
{
info.Append("Binding row " + i + " differ in value of " + var.LocalName + " variable: " + val2 + ", should be: " + val1 + "\n");
failed = true;
}
}
}
}
}
else
{
skip++;
Console.WriteLine(test + ": Unknown result type " + result.Uri);
}
if (failed)
{
Console.WriteLine("Test Failed: " + test);
Console.WriteLine(run_individual_test);
Console.WriteLine(q);
Console.WriteLine(info.ToString());
Console.WriteLine();
fail++;
}
else
{
pass++;
}
}
else
{
skip++;
Console.WriteLine(test + ": Unknown test type " + test_type);
Console.WriteLine();
}
}
public Hashtable Validate()
{
string content = HttpContext.Current.Request.Form["content"];
string format = HttpContext.Current.Request.Form["format"];
if (content == null || content.Trim() == "" || format == null)
{
HttpContext.Current.Response.Redirect("index.xpd");
throw new InvalidOperationException();
}
StringWriter output = new StringWriter();
RdfReader reader;
RdfWriter writer;
Hashtable response = new Hashtable();
response["InDocument"] = AddLineNumbers(content);
if (format == "xml")
{
reader = new RdfXmlReader(new StringReader(content));
writer = new N3Writer(output);
response["InFormat"] = "RDF/XML";
response["OutFormat"] = "Notation 3";
}
else if (format == "n3")
{
reader = new N3Reader(new StringReader(content));
writer = new RdfXmlWriter(output);
response["OutFormat"] = "RDF/XML";
response["InFormat"] = "Notation 3";
}
else
{
throw new Exception("Invalid format.");
}
response["Validation"] = "Syntax validated OK.";
response["OutDocument"] = "";
response["Triples"] = "";
MemoryStore data = new MemoryStore();
try {
data.Import(reader);
} catch (Exception e) {
response["Validation"] = "Validation failed: " + e.Message + ".";
return(response);
} finally {
if (reader.Warnings.Count > 0)
{
response["Validation"] += " There were warnings: ";
foreach (string warning in reader.Warnings)
{
response["Validation"] += " " + warning + ".";
}
}
}
writer.Namespaces.AddFrom(reader.Namespaces);
try {
writer.Write(data);
writer.Close();
response["OutDocument"] = output.ToString();
} catch (Exception e) {
response["OutDocument"] = e.Message;
}
StringWriter triplesoutput = new StringWriter();
using (NTriplesWriter tripleswriter = new NTriplesWriter(triplesoutput)) {
tripleswriter.Write(data);
}
response["Triples"] = triplesoutput.ToString();
return(response);
}
