public void QueryIncludesOtherGraphs()
{
var rdf = new RdfData(new NodeFactory());
var g1 = rdf.GetGraph(rdf.BlankSelf());
g1.Assert(rdf.Uri("app:test"), rdf.Uri("app:name"),
rdf.New("baseName"));
var g2 = rdf.GetGraph(rdf.BlankSelf());
g2.Assert(rdf.Uri("app:test"), rdf.Uri("app:name"),
rdf.New("mainName"));
var target = rdf.GetGraph(g2.Id, g1.Id);
var names = target.Query.With(rdf, "app:name").ToArray();
Assert.AreEqual(2, names.Length, "Finds both entries");
//Get the name value.
var name = names
.Get <string>()
.FirstOrNull();
Assert.AreEqual("mainName", name, "Main graph is first in the query");
}
public void HasCrossGraphBlank()
{
var rdf = new RdfData(new NodeFactory());
var g1 = rdf.GetGraph(rdf.BlankSelf());
var g2 = rdf.GetFullGraph("app:test");
var who = rdf.Uri("app:who");
var b1 = g1.Blank("b1");
//b1 in g1 points to blank in g2 for details.
g1.Assert(b1, who, g2.Id);
//b1 has name fred.
var name = rdf.Uri("app:name");
g2.Assert(b1, name, rdf.New("Fred"));
//Now find via cross graph query.
var otherG = g1.Query.Single(x =>
x.Predicate == who &&
x.Object is Node <UriOrBlank>)
.Object.Cast <UriOrBlank>();
var myName = rdf.GetGraph(otherG).Query.Where(x =>
x.Subject == b1 &&
x.Predicate == name)
.Get <string>()
.Single();
Assert.AreEqual("Fred", myName);
}
public void Negative()
{
var f = new NodeFactory();
var rdf = new RdfData(f);
var fileRoot = Files.TestDataDir.GetFolder("w3c");
var files = fileRoot.EnumerateFiles("*.nt")
.Where(x => x.Name.Contains("-bad-"));
var idx = 18;
foreach (var item in files.Skip(idx))
{
Exception?error = null;
try
{
new NTripleFile(item)
.Read(rdf.GetBlankGraph($"BadTest-{idx}")).Wait();
}
catch (Exception ex)
{
error = ex;
}
Assert.IsNotNull(error, $"Negative test : {item.Name} failed");
idx++;
}
}
public void BuildFileSystemInfo()
{
//data store
var rdf = new RdfData(new NodeFactory());
//read info
var g = rdf.GetBlankGraph(nameof(BuildFileSystemInfo));
g.Update.For(g.Uri(_rootFolder.AsUri()))
.With("app:root", out _)
.Add(true)
.Add(g.Uri(_rootFolder.AsUri()));
var q = new Queue <DirectoryInfo>();
q.Enqueue(_rootFolder);
//limit depth so not too long.
BreadthFirstReadInfo(q, g.Update, rdf, 2);
//save data
_dataFile.EnsureDelete();
var rdfFile = new NTripleFile(_dataFile);
rdfFile.Write(g).Wait();
Assert.IsTrue(_dataFile.Exists());
}
public void QueryData()
{
var rdf = new RdfData(new NodeFactory());
//load data.
if (!_dataFile.Exists())
{
throw new Exception("Data file needs to be pre-built");
}
var graph = rdf.GetGraph(rdf.BlankSelf("g1"));
new NTripleFile(_dataFile).Read(graph).Wait();
//predicates.
var root = rdf.Uri("app:root");
var rootFolder = graph.Query
.With(root)
.GetUri()
.Single();
var expected = Uri.EscapeUriString(_rootFolder.AsUri().ToString());
Assert.AreEqual(expected, rootFolder);
}
public void LoadSameData()
{
var f = new NodeFactory();
var rdf = new RdfData(new NodeFactoryThreadSafe(f));
var data = Files.TestDataDir.GetFile("brazil.nt");
var f1 = data.CopyTo(
Files.AppDataDir.GetFile(
nameof(NodeFactoryTests), "f1.nt"), true);
var g1 = rdf.GetBlankGraph("g1");
var f2 = data.CopyTo(
Files.AppDataDir.GetFile(
nameof(NodeFactoryTests), "f2.nt"), true);
var g2 = rdf.GetBlankGraph("g2");
new NTripleFile(f1).Read(g1).Wait();
var blankCount = rdf.Query.Where(x => x.Subject is BlankNode)
.Select(x => x.Subject)
.Union(rdf.Query.Where(x => x.Object is BlankNode)
.Select(x => x.Object))
.Distinct().Count();
var count1 = f.Stats().TotalNodes - blankCount;
new NTripleFile(f2).Read(g2).Wait();
var count2 = f.Stats().TotalNodes - blankCount * 2;
Assert.AreEqual(count1, count2, "No extra nodes, except blanks.");
}
public async Task WriteRead()
{
var file = new FileInfo(
Path.Combine(Files.AppData.NqFileTests.FullName,
nameof(WriteRead) + ".nt"));
var rdf = new RdfData(new NodeFactory());
var g = rdf.GetFullGraph("graph:1")
.Assert(rdf.Uri("sub1:/"), rdf.Uri("pred1:/"), rdf.New("basic text"));
file.Directory.EnsureDelete();
var t = new NTripleFile(file);
await t.Write(g);
file.Refresh();
Assert.IsTrue(file.Exists);
Assert.IsTrue(file.Length > 0, "wrote some data");
//copy current so it doesn't delete.
var gCopy = g.Query.ToList();
g.Clear();
await t.Read(g);
IEqualityComparer <Quad> eq = new SameQuad();
var gDiffs = g.Query.Except(gCopy, eq).ToList();
Assert.IsFalse(gDiffs.Any(), "No difference");
}
public void BuildingAChain()
{
var rdf = new RdfData(new NodeFactory());
var g = rdf.GetBlankGraph().Update
.Let(out var graphId);
// x:joe x:phone _:auto1
// _:auto1 x:home "a"
// _:auto1 x:home "123"^^int
g.For(rdf.Uri("x:joe"))
.With(rdf.Uri("x:phone"))
.To(rdf.Blank(graphId))
.With(rdf.Uri("x:home"))
.Add(rdf.New("123"), rdf.New(123));
Assert.AreEqual(3, rdf.Query.Count);
//now query data.
var graph = rdf.Query.From(graphId).ToList();
var linkToData = graph.LinksFor(rdf.Uri("x:joe")).Single();
Assert.AreEqual(rdf.Uri("x:phone"), linkToData.Predicate, "Got Joe's phone entries");
var properties = graph.PropertiesFor((Node <UriOrBlank>)linkToData.Object).ToList();
Assert.AreEqual(2, properties.Count, "Expected 2 entries");
var thePhoneNumber = properties.Select(x => x.Object.As <int>())
.Single(x => !(x is null))
?? throw new Exception("Didn't find phone number");
Assert.AreEqual(123, thePhoneNumber.Value);
}
public void ReplaceValue()
{
var rdf = new RdfData(new NodeFactory());
var g = rdf.GetBlankGraph("test");
g.Update
.For("app:test", out var test)
.With("app:name", out var aName).Add("fred");
g.Update
.For(test).With(aName).Remove <string>();
var nameNode = g.Query.For(test).With(aName)
.FirstOrNull();
Assert.IsNull(nameNode);
g.Update
.For(test).With(aName).Set("bob");
var name = g.Query.For(g, "app:test")
.With(g, "app:name")
.First().Object.Value <string>();
Assert.AreEqual("bob", name);
}
public void AddListAndKeepingReferenceToStart()
{
var rdf = new RdfData(new NodeFactory());
var g = rdf.GetGraph(rdf.Uri("graph:/g1"))
.Update
.Let(out var graphId);
//(http://www.snee.com/bobdc.blog/2014/04/rdf-lists-and-sparql.html)
// x:sub rdfs:first "one"
// x.sub rdfs:rest _:1
// _:1 rdfs:first "two"
// _:1 rdfs:rest _:2
// _:2 rdfs:first "three"
// _:2 rdfs:rest rsf:nil
g.For(rdf.Uri("x:sub"))
.Let(out var listStart)
.List(rdf.New("one"), rdf.New("two"), rdf.New("three"))
.With(rdf.Uri("x:p")).Add(rdf.New("Extra data on last item"))
//And jump back to starting subject.
.ThenFor(listStart);
var listModel = new RdfsList(rdf, rdf.GetGraph(graphId));
var items = listModel.GetList(listStart)
.ToList();
Assert.AreEqual(3, items.Count, "Got 3 items from list");
Assert.AreEqual("two", items[1].Value <string>(), "2nd is as expected");
}
public void RdfUpdate_AvailableInGraph()
{
var f = new NodeFactory();
var rdf = new RdfData(f);
var g1 = f.BlankSelf();
var g2 = f.BlankSelf();
var graphPreUpdates = rdf.GetGraph(g1, g2);
//add directly via rdf data.
var sub = rdf.Uri("x:/s1");
var pred = rdf.Uri("x:/p1");
var val = rdf.New("text");
rdf.Assert(g1, sub, pred, val);
rdf.Assert(g2, sub, pred, val);
//immediately have the owned quad,
//but not the data from other graph.
Assert.AreEqual(1, graphPreUpdates.Query.Count, "Got the new entry");
var graphReInit = rdf.GetGraph(g1, g2);
Assert.AreEqual(2, graphReInit.Query.Count, "Re-access graph gets latest");
}
public void FindForValue()
{
var rdf = new RdfData(new NodeFactory());
var g = rdf.GetBlankGraph();
var sub = rdf.Uri("app:me");
var name = rdf.Uri("app:name");
g.Update
.For(sub)
.With(name).Add("fred", "en", out _)
.Add("fred-literal", out _)
.Then()
.With("app:age", out _).Add(23, out _)
.Then().Then()
.For("app:other", out _)
.With("app:friend", out _).Add(sub);
//look for name as text.
var found = rdf.Query.From(g.Id)
.For(sub).With(name)
.IsType <Text>()
.Get <Text>()
.Single();
Assert.AreEqual("fred", found.Value);
}
public void GraphIds_Ordered()
{
var rdf = new RdfData(new NodeFactory());
var g1 = rdf.BlankSelf("test");
rdf.Assert(g1, rdf.Blank(g1), rdf.Uri("a:pred"), rdf.New(123));
var graphs = rdf.GraphIds;
Assert.AreEqual(3, graphs.Length);
Assert.AreEqual(rdf.System, graphs.ElementAt(0));
Assert.AreEqual(rdf.Default, graphs.ElementAt(1));
}
public void ReadBlanks()
{
var f = new NodeFactory();
var rdf = new RdfData(f);
var g = rdf.GetBlankGraph();
var target = new NTripleParse(g);
target.Load("<s:1> <p:1> _:blank . ");
var label = g.Query.Single().ValueBlank();
Assert.AreEqual("blank", label);
}
public void WriteTripleData()
{
var rdf = new RdfData(new NodeFactory());
var target = new NTripleFile(Files.AppDataDir.GetFile(
nameof(NTripleFileTests), nameof(WriteTripleData) + ".nt"));
var g = rdf.BlankSelf("g1");
rdf.Assert(g,
rdf.Uri("x:sub1"),
rdf.Uri("x:age"),
rdf.New(23));
target.Write(rdf.GetGraph(g)).Wait();
}
public void FindWithOr()
{
var rdf = new RdfData(new NodeFactory());
var g = rdf.GetBlankGraph();
g.Update
.For("app:test", out var test)
.With("app:name", out var aName)
.Add("fred")
.Add("fred", "en");
g.Query.For(test)
.With(aName)
.IsType(n => n is Node <Text> || n is Node <string>);
}
public void ReadMultiLine()
{
var data = "Multi \\n Line text \\\" with spaces\\u0021.";
var expected = "Multi \n Line text \" with spaces!.";
var f = new NodeFactory();
var rdf = new RdfData(f);
var target = new NTripleParse(rdf.GetBlankGraph());
var quad = "<a:s> <a:p> \"" + data + "\" .";
target.Load(quad);
var result = rdf.Query.Single().Value <string>();
Assert.AreEqual(expected, result);
}
public void Parse_LiteralWithDifferentEncoding()
{
var rdf = new RdfData(new NodeFactory());
var g = rdf.GetBlankGraph("test");
var aHex = "\\u" + ((int)'a').ToString("X4");
var data = "<a:s1> <a:p> \"a literal\"." +
$"\r\n <a:s2> <a:p> \"a liter{aHex}l\".";
var target = new NTripleParse(g);
target.Load(data);
var q1 = rdf.Query.ElementAt(0);
var q2 = rdf.Query.ElementAt(1);
Assert.AreEqual(q1.Object, q2.Object, "Same literal node");
}
public void Parse()
{
var data = "<x:/s1> <x:/p1> \"Blurb\" .";
var rdf = new RdfData(new NodeFactory());
var g = rdf.GetFullGraph("x:g1");
var token = NTripleTokenizer.NextToken(data);
var parse = new NTripleParse(rdf.GetFullGraph("x:g1"));
while (!token.IsEnd)
{
parse.Next(token);
token = NTripleTokenizer.NextToken(token.Rest);
}
Assert.AreEqual(1, g.Query.Count, "Loaded a triple");
}
public void ClearGraph()
{
var data = new RdfData(new NodeFactory());
data.Update.From("sys:/data/", out _)
.For("sub:s1", out _)
.With("x:/p1", out _).Add(123);
var g = data.GetGraph(data.BlankSelf())
.Assert(data.Uri("x:/s1"),
data.Uri("p:/1"),
data.New("text"));
Assert.AreEqual(2, data.Query.Count, "have the nodes");
g.Clear();
Assert.AreEqual(0, g.Query.Count, "no graph nodes");
Assert.AreEqual(1, data.Query.Count, "still have other data");
}
public void Positive()
{
var f = new NodeFactory();
var rdf = new RdfData(f);
var fileRoot = Files.TestDataDir.GetFolder("w3c");
var files = fileRoot.EnumerateFiles("*.nt")
.Where(x => !x.Name.Contains("-bad-"));
var idx = 0;
foreach (var item in files.Skip(idx))
{
new NTripleFile(item)
.Read(rdf.GetBlankGraph($"Test-{idx}")).Wait();
idx++;
}
}
public void ReadData()
{
var rdf = new RdfData(new NodeFactory());
var target = new NTripleFile(Files.TestData.Sample1);
var defaultGraph = rdf.GetBlankGraph("default");
target.Read(defaultGraph).Wait();
var quad = rdf.Query.With(rdf, "app:blank")
.Single();
Assert.AreEqual(quad.Subject, quad.Object);
Assert.AreEqual("b1", quad.ValueBlank());
var txt = rdf.Query.With(rdf, "app:literal")
.Single().Value <string>();
Assert.AreEqual("x", txt);
var uriNode = rdf.Query.With(rdf, "app:uri")
.Select(x => x.Object)
.OfType <UriNode>().Single();
txt = uriNode.Uri;
Assert.AreEqual("http://a.example/s", txt);
txt = rdf.Query.With(rdf, "app:text")
.Select(x => x.Object)
.OfType <Node <Text> >()
.Single(x => x.Value.Language == "fr")
.Value.Value;
Assert.AreEqual("fredo", txt);
var intValue = rdf.Query.With(rdf, "app:number")
.Single().Value <int>();
Assert.AreEqual(123, intValue);
}
public void AddWithUpDownAndLet()
{
var f = new NodeFactory();
var rdf = new RdfData(f);
var gId = f.BlankSelf("g1");
var g = rdf.GetGraph(gId).Update;
// _:1 x:p1 "1".
g.ForBlank("1", out _)
.With(f.Uri("x:p1"))
.Add(f.New("1"))
// _:1 x:p2 "123"
.Then().With(f.Uri("x:p2")).Add(f.New("123"))
// _:1 x:p3 _:2
// _:2 x:p3 "fred"
.Then().With(f.Uri("x:p3")).To(f.Blank(gId))
.With(f.Uri("x:p3")).Add(f.New("fred"))
//get ref to _:2
.Then().Let(out _);
}
public async Task WriteWithCrossGraphBlank()
{
var rdf = new RdfData(new NodeFactory());
var g1 = rdf.GetBlankGraph();
g1.Assert(rdf.Uri("bad:link"), rdf.Uri("app:test"), rdf.BlankSelf("other"));
var file = Files.AppDataDir.GetFile(nameof(NodeWriterTests),
nameof(WriteWithCrossGraphBlank) + ".nt")
.EnsureDelete();
var target = new NTripleFile(file);
try
{
await target.Write(g1);
Assert.Fail("Cannot write if blank is scoped to other graph");
}catch (BlankNodeScopedToInvalidGraph) {}
}
public void PrintLiteral()
{
var rdf = new RdfData(new NodeFactory());
var g = rdf.GetBlankGraph();
var expected = "_:g <app:test> \"Literal\\rMultiline\\\\\" .";
g.Assert(g.Blank("g"),
rdf.Uri("app:test"),
rdf.New("Literal\rMultiline\\"));
var target = new NodeWriter(g);
using var wr = new StringWriter();
target.Print(wr);
wr.Flush();
var result = wr.GetStringBuilder().ToString().Trim();
Assert.AreEqual(expected, result);
}
