static void Main(string[] args)
{
ParserFactory parserFactory = new XsltParserFactory();
TripleStoreFactory tripleStoreFactory = new MemoryTripleStoreFactory();
TripleStore model = tripleStoreFactory.MakeTripleStore();
// Parse the bloggers RDF file
FileStream fileStream = new FileStream("./bloggers.rdf", FileMode.Open);
Parser parser = parserFactory.MakeParser(tripleStoreFactory.MakeResourceFactory(), new StatementFactory());
parser.NewStatement += model.GetStatementHandler();
parser.Parse(fileStream, "");
parser.NewStatement -= model.GetStatementHandler();
/* Define the query. Equivalent to:
* ?blogger rdf:type foaf:Agent .
* ?blogger foaf:name ?name .
*/
Query queryListOfBloggers = new Query();
queryListOfBloggers.AddPattern(new Pattern(new Variable("blogger"), new UriRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), new UriRef("http://xmlns.com/foaf/0.1/Agent")));
queryListOfBloggers.AddPattern(new Pattern(new Variable("blogger"), new UriRef("http://xmlns.com/foaf/0.1/name"), new Variable("name")));
IEnumerator solutions = model.Solve(queryListOfBloggers);
while (solutions.MoveNext())
{
QuerySolution solution = (QuerySolution)solutions.Current;
Console.WriteLine(solution["name"]);
}
}
public void parserUsesResourceFactoryToCreateBlankSubject()
{
StringReader reader = new StringReader("<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"><rdf:Description><rdf:type rdf:resource=\"http://example.org/type\"/></rdf:Description></rdf:RDF>");
ResourceFactoryStore resourceFactory = new ResourceFactoryStore();
XsltParserFactory parserFactory = new XsltParserFactory();
Parser parser = parserFactory.MakeParser(resourceFactory, new StatementFactoryStub());
parser.Parse(reader, "");
Assert.IsTrue(resourceFactory.WasMakeBlankNodeCalledWithANodeId());
}
public void parserUsesStatementFactoryToCreateBUTStatement()
{
StringReader reader = new StringReader("<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"><rdf:Description><rdf:type rdf:datatype=\"http://example.com/type\">foo</rdf:type></rdf:Description></rdf:RDF>");
StatementFactoryCounter statementFactory = new StatementFactoryCounter();
XsltParserFactory parserFactory = new XsltParserFactory();
Parser parser = parserFactory.MakeParser(new ResourceFactoryStub(), statementFactory);
parser.Parse(reader, "");
Assert.AreEqual(1, statementFactory.MakeStatementBUTCalled);
}
public void parserUsesResourceFactoryToCreateTypedLiteralObject()
{
StringReader reader = new StringReader("<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"><rdf:Description rdf:about=\"http://example.org/node\"><rdf:type rdf:datatype=\"http://example.com/type\">foo</rdf:type></rdf:Description></rdf:RDF>");
ResourceFactoryStore resourceFactory = new ResourceFactoryStore();
XsltParserFactory parserFactory = new XsltParserFactory();
Parser parser = parserFactory.MakeParser(resourceFactory, new StatementFactoryStub());
parser.Parse(reader, "");
Assert.IsTrue(resourceFactory.WasMakeTypedLiteralCalledWith("foo", "http://example.com/type"));
}
public void parseStreamWithEntitiesInNamespaceDeclarationOfRootElementNamespace()
{
string rdf = @"<?xml version=""1.0"" encoding=""UTF-8""?>
<!DOCTYPE rdf:RDF [
<!ENTITY ex 'http://example.com/ns/'>
<!ENTITY rdf 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'>
]>
<rdf:RDF xmlns:rdf=""&rdf;"" xmlns:ex=""&ex;"">
<rdf:Description rdf:about=""http://example.com"">
<ex:value>Test</ex:value>
</rdf:Description>
</rdf:RDF>";
SimpleModel model = new SimpleModel(new XsltParserFactory());
XsltParserFactory parserFactory = new XsltParserFactory();
Parser parser = parserFactory.MakeParser(new ResourceFactory(), new StatementFactory());
parser.NewStatement += new StatementHandler(model.Add);
MemoryStream stream = new MemoryStream();
StreamWriter writer = new StreamWriter(stream);
writer.Write(rdf);
writer.Flush();
stream.Position = 0;
try {
parser.Parse(stream, "");
}
catch (Exception) { }
NTripleListVerifier verifier = new NTripleListVerifier();
verifier.Expect(@"<http://example.com> <http://example.com/ns/value> ""Test"" .");
foreach (string ntriple in model)
{
verifier.Receive(ntriple);
}
bool testPassed = verifier.Verify();
string failureDescription = verifier.GetLastFailureDescription() + "\r\nTriples received:\r\n" + model.ToString();
if (testPassed)
{
Console.WriteLine("XsltParserTest.parseWithEntities UNEXPECTEDLY PASSED - entity in namespace declaration problem might have been fixed ");
}
Assert.IsTrue(!testPassed); // We exoect this to fail
}
public void makeParserReturnsParserThatUsesSuppliedResourceFactory()
{
string rdfContent = @"<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'><rdf:Description><rdf:value>bar</rdf:value></rdf:Description></rdf:RDF>";
XsltParserFactory parserFactory = new XsltParserFactory();
ResourceFactoryCounter resourceFactoryToBeIgnored = new ResourceFactoryCounter();
Parser parser1 = parserFactory.MakeParser(resourceFactoryToBeIgnored, new StatementFactoryStub());
Parser parser2 = parserFactory.MakeParser(new ResourceFactoryStub(), new StatementFactoryStub());
parser2.Parse(new StringReader(rdfContent), "");
Assert.AreEqual(0, resourceFactoryToBeIgnored.MakeBlankNodeWithNodeIdCalled, "First resource factory should not be used");
}
public void parserPassesResourceFactoryObjectsToStatementFactory()
{
StringReader reader = new StringReader("<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"><rdf:Description rdf:about=\"http://example.org/node\"><rdf:type rdf:resource=\"http://example.org/type\"/></rdf:Description></rdf:RDF>");
StatementFactoryStore statementFactory = new StatementFactoryStore();
ResourceFactoryResponder resourceFactory = new ResourceFactoryResponder();
XsltParserFactory parserFactory = new XsltParserFactory();
Parser parser = parserFactory.MakeParser(resourceFactory, statementFactory);
parser.Parse(reader, "");
Assert.IsTrue(statementFactory.WasMakeStatementCalledWith(resourceFactory.itsUriRefResponse, resourceFactory.itsUriRefResponse, resourceFactory.itsUriRefResponse));
}
public void parseReaderWithoutEntities()
{
string rdf = @"<?xml version=""1.0"" encoding=""UTF-8""?>
<rdf:RDF xmlns:rdf=""http://www.w3.org/1999/02/22-rdf-syntax-ns#"">
<rdf:Description rdf:about=""http://example.com"">
<rdf:value>Test</rdf:value>
</rdf:Description>
</rdf:RDF>";
SimpleModel model = new SimpleModel(new XsltParserFactory());
XsltParserFactory parserFactory = new XsltParserFactory();
Parser parser = parserFactory.MakeParser(new ResourceFactory(), new StatementFactory());
parser.NewStatement += new StatementHandler(model.Add);
parser.Parse(new StringReader(rdf), "");
NTripleListVerifier verifier = new NTripleListVerifier();
verifier.Expect(@"<http://example.com> <http://www.w3.org/1999/02/22-rdf-syntax-ns#value> ""Test"" .");
foreach (string ntriple in model)
{
verifier.Receive(ntriple);
}
bool testPassed = verifier.Verify();
string failureDescription = verifier.GetLastFailureDescription() + "\r\nTriples received:\r\n" + model.ToString();
if (!testPassed)
{
Console.WriteLine("XsltParserTest.parseWithEntities FAILED because ");
Console.WriteLine(failureDescription);
}
Assert.IsTrue(testPassed);
}
public void entitiesInNamespaceDeclarationResultInZeroTriples()
{
string rdf = @"<?xml version=""1.0"" encoding=""UTF-8""?>
<!DOCTYPE rdf:RDF [
<!ENTITY ex 'http://example.com/ns/'>
<!ENTITY rdf 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'>
]>
<rdf:RDF xmlns:rdf=""&rdf;"" xmlns:ex=""&ex;"">
<rdf:Description rdf:about=""http://example.com"">
<ex:value>Test</ex:value>
</rdf:Description>
</rdf:RDF>";
SimpleModel model = new SimpleModel(new XsltParserFactory());
XsltParserFactory parserFactory = new XsltParserFactory();
Parser parser = parserFactory.MakeParser(new ResourceFactory(), new StatementFactory());
parser.NewStatement += new StatementHandler(model.Add);
MemoryStream stream = new MemoryStream();
StreamWriter writer = new StreamWriter(stream);
writer.Write(rdf);
writer.Flush();
stream.Position = 0;
try {
parser.Parse(stream, "");
} catch (SemPlan.Spiral.Core.ParserException) {
// swallow error output from validation stylesheet
//Console.WriteLine(e);
}
Assert.AreEqual(0, model.Count);
}
static void Main(string[] args)
{
ParserFactory parserFactory = new XsltParserFactory();
SimpleModel model = new SimpleModel(parserFactory);
string rdfUri = "http://iandavis.com/foaf.rdf";
if (args.Length > 0)
{
rdfUri = args[0];
}
model.Parse(new Uri(rdfUri), rdfUri);
XmlTextWriter xmlWriter = new XmlTextWriter(Console.Out);
xmlWriter.Formatting = Formatting.Indented;
RdfXmlWriter writer = new RdfXmlWriter(xmlWriter);
model.Write(writer);
}
public ICalParserFactory()
{
itsXsltParserFactory = new XsltParserFactory();
itsDereferencer = new SimpleDereferencer();
}
public ICalParserFactory(string xsltStylesheetName, string validatorXsltStylesheetName, Dereferencer dereferencer)
{
itsXsltParserFactory = new XsltParserFactory(xsltStylesheetName, validatorXsltStylesheetName, dereferencer);
itsDereferencer = dereferencer;
}
public void testPaoloMassa()
{
string rdf = @"<?xml version=""1.0"" encoding=""iso-8859-1"" ?>
<!DOCTYPE rdf:RDF [
<!ENTITY rdf 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'>
<!ENTITY rdfs 'http://www.w3.org/2000/01/rdf-schema#'>
<!ENTITY cc 'http://web.resource.org/cc/'>
<!ENTITY foaf 'http://xmlns.com/foaf/0.1/'>
<!ENTITY dc 'http://purl.org/dc/elements/1.1/'>
<!ENTITY dcterms 'http://purl.org/dc/terms/'>
]>
<rdf:RDF
xmlns=""http://xmlns.com/foaf/0.1/""
xmlns:quaff=""http://purl.org/net/schemas/quaffing/""
xmlns:bio=""http://purl.org/vocab/bio/0.1/""
xmlns:wot=""http://xmlns.com/wot/0.1/""
xmlns:k=""http://opencyc.sourceforge.net/daml/cyc.daml#""
xmlns:rss=""http://purl.org/rss/1.0/""
xmlns:lang=""http://purl.org/net/inkel/rdf/schemas/lang/1.1#""
xmlns:zodiac=""http://www.ideaspace.net/users/wkearney/schema/astrology/0.1#""
xmlns:airport=""http://www.daml.org/2001/10/html/airport-ont#""
xmlns:contact=""http://www.w3.org/2000/10/swap/pim/contact#""
xmlns:geo=""http://www.w3.org/2003/01/geo/wgs84_pos#""
xmlns:bt=""http://jibbering.com/vocabs/bluetooth#""
xmlns:dcterms=""&dcterms;""
xmlns:dc=""&dc;""
xmlns:cc=""&cc;""
xmlns:foaf=""http://xmlns.com/foaf/0.1/""
xmlns:owl=""http://www.w3.org/2002/07/owl#""
xmlns:rdf=""http://www.w3.org/1999/02/22-rdf-syntax-ns#""
xmlns:rdfs=""http://www.w3.org/2000/01/rdf-schema#""
xmlns:trust=""http://trust.mindswap.org/ont/trust.owl#"">
<PersonalProfileDocument rdf:about="""">
<dc:title>FoaF Document for Paolo Massa</dc:title>
<dc:description>Friend-of-a-Friend description of Paolo Massa</dc:description>
<topic rdf:nodeID=""paolomassa""/>
<Maker rdf:nodeID=""paolomassa""/>
<dcterms:created>2004-09-21T13:45:21Z</dcterms:created>
<cc:license rdf:resource=""http://creativecommons.org/licenses/nc/1.0""/>
</PersonalProfileDocument>
</rdf:RDF>";
SimpleModel model = new SimpleModel(new XsltParserFactory());
XsltParserFactory parserFactory = new XsltParserFactory();
Parser parser = parserFactory.MakeParser(new ResourceFactory(), new StatementFactory());
parser.NewStatement += new StatementHandler(model.Add);
MemoryStream stream = new MemoryStream();
StreamWriter writer = new StreamWriter(stream);
writer.Write(rdf);
writer.Flush();
stream.Position = 0;
Console.WriteLine(model.ToString());
try {
parser.Parse(stream, "");
} catch (SemPlan.Spiral.Core.ParserException e) {
// swallow error output from validation stylesheet
Console.WriteLine(e);
}
Assert.AreEqual(0, model.Count);
}
private void RunTestCase(string queryFile, string dataFile, string resultsFile, bool explain)
{
if (explain)
{
Console.WriteLine("-------------- TEST ---------------------");
Console.WriteLine("queryFile=" + queryFile + ", dataFile=" + dataFile + ", resultsFile=" + resultsFile);
}
try {
StreamReader queryReader = File.OpenText("d:\\data\\semplan\\2005\\spiral\\src\\SemPlan.Spiral.Tests.Sparql\\dawg-test-cases\\data-xml\\" + queryFile);
string query = queryReader.ReadToEnd();
if (explain)
{
Console.WriteLine(">---- Contents of " + queryFile);
Console.WriteLine("query=" + query);
Console.WriteLine(">----");
}
StreamReader dataReader = File.OpenText("d:\\data\\semplan\\2005\\spiral\\src\\SemPlan.Spiral.Tests.Sparql\\dawg-test-cases\\data-xml\\" + dataFile);
StreamReader resultsReader = File.OpenText("d:\\data\\semplan\\2005\\spiral\\src\\SemPlan.Spiral.Tests.Sparql\\dawg-test-cases\\data-xml\\" + resultsFile);
Query queryToRun = ParseQuery(query);
if (explain)
{
Console.WriteLine(">---- Parsed query");
Console.WriteLine(queryToRun);
Console.WriteLine(">----");
}
MemoryTripleStore dataStore = new MemoryTripleStore();
XsltParserFactory parserFactory = new XsltParserFactory();
Parser dataParser = parserFactory.MakeParser(new ResourceFactory(), new StatementFactory());
dataParser.NewStatement += new StatementHandler(dataStore.Add);
try {
dataParser.Parse(dataReader, "");
}
catch (Exception) { }
if (explain)
{
Console.WriteLine(">---- Contents of " + dataFile);
dataStore.Dump();
Console.WriteLine(">----");
}
MemoryTripleStore resultsStore = new MemoryTripleStore();
Parser resultsParser = parserFactory.MakeParser(new ResourceFactory(), new StatementFactory());
resultsParser.NewStatement += new StatementHandler(resultsStore.Add);
try {
resultsParser.Parse(resultsReader, "");
}
catch (Exception) { }
if (explain)
{
Console.WriteLine(">---- Contents of " + resultsFile);
Console.WriteLine(resultsStore.ToString());
Console.WriteLine(">----");
}
//~ Query resultsQuery = ParseQuery( @"
//~ PREFIX rs: <http://www.w3.org/2001/sw/DataAccess/tests/result-set#>
//~ SELECT * {
//~ ?solution rs:binding ?binding .
//~ ?binding rs:variable ?variable .
//~ ?binding rs:value ?value .
//~ }
//~ ");
//~ ?set a rs:ResultSet .
//~ ?set rs:solution ?solution .
//~ ?solution rs:binding ?binding .
//~ ?binding rs:variable ?variable .
//~ ?binding rs:value ?value .
Query resultsQuery = new Query();
resultsQuery.AddPattern(new Pattern(new Variable("solution"), new UriRef("http://www.w3.org/2001/sw/DataAccess/tests/result-set#binding"), new Variable("binding")));
resultsQuery.AddPattern(new Pattern(new Variable("binding"), new UriRef("http://www.w3.org/2001/sw/DataAccess/tests/result-set#variable"), new Variable("variable")));
resultsQuery.AddPattern(new Pattern(new Variable("binding"), new UriRef("http://www.w3.org/2001/sw/DataAccess/tests/result-set#value"), new Variable("value")));
Hashtable expectedSolutions = new Hashtable();
Resource currentSolutionResource = null;
QuerySolution newExpectedSolution = null;
if (explain)
{
Console.WriteLine(">---- Parsing expected results");
}
IEnumerator solutions = resultsStore.Solve(resultsQuery);
while (solutions.MoveNext())
{
QuerySolution solution = (QuerySolution)solutions.Current;
if (explain)
{
Console.WriteLine("x" + solution);
}
if (!expectedSolutions.Contains(solution["solution"]))
{
expectedSolutions[solution["solution"]] = new QuerySolution();
}
if (explain)
{
Console.WriteLine("Variable=" + resultsStore.GetBestDenotingNode(solution["variable"]) + "; value=" + resultsStore.GetBestDenotingNode(solution["value"]) + "(" + dataStore.GetResourceDenotedBy(resultsStore.GetBestDenotingNode(solution["value"])) + ")");
}
((QuerySolution)expectedSolutions[solution["solution"]])[resultsStore.GetBestDenotingNode(solution["variable"]).GetLabel()] = dataStore.GetResourceDenotedBy(resultsStore.GetBestDenotingNode(solution["value"]));
}
if (explain)
{
Console.WriteLine(">----");
}
if (explain)
{
Console.WriteLine(">---- Expecting " + expectedSolutions.Keys.Count + " solutions");
foreach (QuerySolution expected in expectedSolutions.Values)
{
//~ Console.WriteLine( expected.ToString(dataStore) );
}
Console.WriteLine(">----");
}
int expectedSolutionCount = expectedSolutions.Keys.Count;
int actualSolutionCount = 0;
IEnumerator actualSolutions = dataStore.Solve(queryToRun);
ArrayList expectedSolutionsReceived = new ArrayList();
if (explain)
{
Console.WriteLine(">---- Got solutions:");
}
while (actualSolutions.MoveNext())
{
QuerySolution actualSolution = (QuerySolution)actualSolutions.Current;
++actualSolutionCount;
//~ if (explain) Console.WriteLine(actualSolution.ToString(dataStore) );
bool foundMatch = false;
foreach (QuerySolution expectedSolution in expectedSolutions.Values)
{
if (expectedSolution.Equals(actualSolution))
{
expectedSolutionsReceived.Add(expectedSolution);
foundMatch = true;
break;
}
}
if (!foundMatch)
{
//~ Assert.Fail( "Got unexpected solution:" + actualSolution.ToString( dataStore ) );
}
}
Assert.AreEqual(expectedSolutionCount, actualSolutionCount, "Got same number of solutions");
Assert.AreEqual(expectedSolutionsReceived.Count, expectedSolutionCount, "All expected solutions were received");
}
catch (Exception e) {
Assert.Fail(e.ToString());
}
}
