public void WritingBlankNodeOutput()
{
//Create a Graph and add a couple of Triples which when serialized have
//potentially colliding IDs
Graph g = new Graph();
g.NamespaceMap.AddNamespace("ex", new Uri("http://example.org"));
IUriNode subj = g.CreateUriNode("ex:subject");
IUriNode pred = g.CreateUriNode("ex:predicate");
IUriNode name = g.CreateUriNode("ex:name");
IBlankNode b1 = g.CreateBlankNode("autos1");
IBlankNode b2 = g.CreateBlankNode("1");
g.Assert(subj, pred, b1);
g.Assert(b1, name, g.CreateLiteralNode("First Triple"));
g.Assert(subj, pred, b2);
g.Assert(b2, name, g.CreateLiteralNode("Second Triple"));
TurtleWriter ttlwriter = new TurtleWriter();
ttlwriter.Save(g, "bnode-output-test.ttl");
TestTools.ShowGraph(g);
TurtleParser ttlparser = new TurtleParser();
Graph h = new Graph();
ttlparser.Load(h, "bnode-output-test.ttl");
TestTools.ShowGraph(h);
Assert.AreEqual(g.Triples.Count, h.Triples.Count, "Expected same number of Triples after serialization and reparsing");
}
public void NodesDistinct()
{
Graph g = new Graph();
List <INode> test = new List <INode>()
{
g.CreateUriNode("rdf:type"),
g.CreateUriNode(new Uri("http://example.org")),
g.CreateBlankNode(),
g.CreateBlankNode(),
null,
g.CreateBlankNode("test"),
g.CreateLiteralNode("Test text"),
g.CreateLiteralNode("Test text", "en"),
g.CreateLiteralNode("Test text", new Uri(XmlSpecsHelper.XmlSchemaDataTypeString)),
g.CreateUriNode("rdf:type"),
null,
g.CreateUriNode(new Uri("http://example.org#test")),
g.CreateUriNode(new Uri("http://example.org"))
};
foreach (INode n in test.Distinct())
{
if (n != null)
{
Console.WriteLine(n.ToString());
}
else
{
Console.WriteLine("null");
}
}
}
public void NodesEqualityOperator()
{
Console.WriteLine("Testing that the overridden operators for Nodes work as expected");
try
{
Graph g = new Graph();
IBlankNode a = g.CreateBlankNode();
IBlankNode b = g.CreateBlankNode();
Console.WriteLine("Testing using Equals() method");
Assert.IsFalse(a.Equals(b), "Two different Blank Nodes should be non-equal");
Assert.IsTrue(a.Equals(a), "A Blank Node should be equal to itself");
Assert.IsTrue(b.Equals(b), "A Blank Node should be equal to itself");
Console.WriteLine("OK");
Console.WriteLine();
Console.WriteLine("Testing using == operator");
Assert.IsFalse(a == b, "Two different Blank Nodes should be non-equal");
Assert.IsTrue(a == a, "A Blank Node should be equal to itself");
Assert.IsTrue(b == b, "A Blank Node should be equal to itself");
Console.WriteLine("OK");
Console.WriteLine();
//Test typed as INode
INode c = g.CreateBlankNode();
INode d = g.CreateBlankNode();
Console.WriteLine("Now testing with typed as INode using Equals()");
Assert.IsFalse(c.Equals(d), "Two different Nodes should be non-equal");
Assert.IsTrue(c.Equals(c), "A Node should be equal to itself");
Assert.IsTrue(d.Equals(d), "A Node should be equal to itself");
Console.WriteLine("OK");
Console.WriteLine();
Console.WriteLine("Now testing with typed as INode using == operator");
Assert.IsFalse(c == d, "Two different Nodes should be non-equal");
Assert.IsTrue(c == c, "A Node should be equal to itself");
Assert.IsTrue(d == d, "A Node should be equal to itself");
Console.WriteLine("OK");
}
catch (RdfException rdfEx)
{
throw;
}
catch (Exception ex)
{
throw;
}
}
private IGraph GenerateStarGraph(int nodes)
{
Graph g = new Graph();
IUriNode rdfValue = g.CreateUriNode("rdf:value");
List <IBlankNode> bnodes = new List <IBlankNode>();
for (int i = 0; i < nodes; i++)
{
bnodes.Add(g.CreateBlankNode());
}
for (int i = 0; i < bnodes.Count; i++)
{
for (int j = 0; j < bnodes.Count; j++)
{
if (i == j)
{
continue;
}
g.Assert(bnodes[i], rdfValue, bnodes[j]);
}
}
return(g);
}
public void NodesBlankNodeEquality()
{
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/BlankNodeEquality");
Graph h = new Graph();
h.BaseUri = new Uri("http://example.org/BlankNodeEqualityTwo");
Graph i = new Graph();
i.BaseUri = new Uri("http://example.org/BlankNodeEquality");
Console.WriteLine("Doing some Blank Node Equality Testing");
Console.WriteLine("Blank Nodes are equal if they have the same ID and come from the same Graph which is established by Reference Equality between the two Graphs");
IBlankNode b = g.CreateBlankNode();
IBlankNode c = g.CreateBlankNode();
IBlankNode d = h.CreateBlankNode();
IBlankNode e = i.CreateBlankNode();
//Shouldn't be equal
Assert.NotEqual(b, c);
Assert.NotEqual(c, d);
Assert.NotEqual(b, d);
Assert.NotEqual(d, e);
Assert.NotEqual(b, e);
//Should be equal
Assert.Equal(b, b);
Assert.Equal(c, c);
Assert.Equal(d, d);
Assert.Equal(e, e);
//Named Nodes
IBlankNode one = g.CreateBlankNode("one");
IBlankNode two = h.CreateBlankNode("one");
IBlankNode three = i.CreateBlankNode("one");
Assert.NotEqual(one, three);
Assert.NotEqual(one, two);
Assert.NotEqual(two, three);
}
public void NodesNullNodeEquality()
{
UriNode nullUri = null;
LiteralNode nullLiteral = null;
BlankNode nullBNode = null;
Graph g = new Graph();
IUriNode someUri = g.CreateUriNode(new Uri("http://example.org"));
ILiteralNode someLiteral = g.CreateLiteralNode("A Literal");
IBlankNode someBNode = g.CreateBlankNode();
Assert.Equal(nullUri, nullUri);
Assert.Equal(nullUri, null);
Assert.Equal(null, nullUri);
Assert.True(nullUri == nullUri, "Null URI Node should be equal to self");
Assert.True(nullUri == null, "Null URI Node should be equal to a null");
Assert.True(null == nullUri, "Null should be equal to a Null URI Node");
Assert.False(nullUri != nullUri, "Null URI Node should be equal to self");
Assert.False(nullUri != null, "Null URI Node should be equal to a null");
Assert.False(null != nullUri, "Null should be equal to a Null URI Node");
Assert.NotEqual(nullUri, someUri);
Assert.NotEqual(someUri, nullUri);
Assert.False(nullUri == someUri, "Null URI Node should not be equal to an actual URI Node");
Assert.False(someUri == nullUri, "Null URI Node should not be equal to an actual URI Node");
Assert.Equal(nullLiteral, nullLiteral);
Assert.Equal(nullLiteral, null);
Assert.Equal(null, nullLiteral);
Assert.True(nullLiteral == nullLiteral, "Null Literal Node should be equal to self");
Assert.True(nullLiteral == null, "Null Literal Node should be equal to a null");
Assert.True(null == nullLiteral, "Null should be equal to a Null Literal Node");
Assert.False(nullLiteral != nullLiteral, "Null Literal Node should be equal to self");
Assert.False(nullLiteral != null, "Null Literal Node should be equal to a null");
Assert.False(null != nullLiteral, "Null should be equal to a Null Literal Node");
Assert.NotEqual(nullLiteral, someLiteral);
Assert.NotEqual(someLiteral, nullLiteral);
Assert.False(nullLiteral == someLiteral, "Null Literal Node should not be equal to an actual Literal Node");
Assert.False(someLiteral == nullLiteral, "Null Literal Node should not be equal to an actual Literal Node");
Assert.Equal(nullBNode, nullBNode);
Assert.Equal(nullBNode, null);
Assert.Equal(null, nullBNode);
Assert.True(nullBNode == nullBNode, "Null BNode Node should be equal to self");
Assert.True(nullBNode == null, "Null BNode Node should be equal to a null");
Assert.True(null == nullBNode, "Null should be equal to a Null BNode Node");
Assert.False(nullBNode != nullBNode, "Null BNode Node should be equal to self");
Assert.False(nullBNode != null, "Null BNode Node should be equal to a null");
Assert.False(null != nullBNode, "Null should be equal to a Null BNode Node");
Assert.NotEqual(nullBNode, someBNode);
Assert.NotEqual(someBNode, nullBNode);
Assert.False(nullBNode == someBNode, "Null BNode Node should not be equal to an actual BNode Node");
Assert.False(someBNode == nullBNode, "Null BNode Node should not be equal to an actual BNode Node");
}
public void NodeCompareToMixedNodes()
{
Graph g = new Graph();
Graph h = new Graph();
IBlankNode b = g.CreateBlankNode();
ILiteralNode plain = g.CreateLiteralNode("plain");
IUriNode u = g.CreateUriNode("rdf:type");
List <INode> nodes = new List <INode>()
{
b,
g.CreateBlankNode(),
g.CreateBlankNode("id"),
h.CreateBlankNode(),
h.CreateBlankNode("id"),
b,
plain,
g.CreateLiteralNode("plain english", "en"),
g.CreateLiteralNode("plain french", "fr"),
g.CreateLiteralNode("typed", new Uri(XmlSpecsHelper.XmlSchemaDataTypeString)),
(1234).ToLiteral(g),
(12.34m).ToLiteral(g),
(12.34d).ToLiteral(g),
(false).ToLiteral(g),
(true).ToLiteral(g),
plain,
u,
g.CreateUriNode(new Uri("http://example.org")),
g.CreateUriNode(new Uri("http://example.org:8080")),
g.CreateUriNode(new Uri("http://www.dotnetrdf.org")),
g.CreateUriNode(new Uri("http://www.dotnetrdf.org/configuration#")),
g.CreateUriNode(new Uri("http://www.dotnetrdf.org/Configuration#")),
g.CreateUriNode(new Uri("mailto:[email protected]")),
u
};
this.ShowOrdering(nodes);
this.CheckCombinations(nodes);
}
public void NodeCompareToBlankNodes()
{
Graph g = new Graph();
Graph h = new Graph();
IBlankNode b = g.CreateBlankNode();
List <INode> nodes = new List <INode>()
{
b,
g.CreateBlankNode(),
g.CreateBlankNode("id"),
h.CreateBlankNode(),
h.CreateBlankNode("id"),
b
};
this.ShowOrdering(nodes);
this.CheckCombinations(nodes);
this.CheckCombinations <IBlankNode>(nodes.OfType <IBlankNode>().ToList());
this.CheckCombinations <BlankNode>(nodes.OfType <BlankNode>().ToList());
}
private IGraph GenerateCyclicGraph(int nodes, int seed, int toDrop)
{
Console.WriteLine("Generating Cyclic Graph - Nodes " + nodes + " - Seed " + seed + " - Drop " + toDrop);
Graph g = new Graph();
IUriNode rdfValue = g.CreateUriNode("rdf:value");
if (seed >= nodes - toDrop - 1)
{
seed = nodes - toDrop - 2;
}
List <IBlankNode> bnodes = new List <IBlankNode>(nodes);
for (int i = 0; i < nodes; i++)
{
bnodes.Add(g.CreateBlankNode());
}
Random rnd = new Random();
for (int i = 0; i < toDrop; i++)
{
bnodes.RemoveAt(rnd.Next(bnodes.Count));
}
if (seed >= bnodes.Count - 1)
{
seed = bnodes.Count - 2;
}
Console.WriteLine("Seed value is " + seed);
//Generate a cycle of Triples starting from the seed
int counter = 0;
while (counter <= bnodes.Count)
{
g.Assert(bnodes[seed], rdfValue, bnodes[seed + 1]);
counter++;
seed++;
if (seed == bnodes.Count - 1)
{
g.Assert(bnodes[seed], rdfValue, bnodes[0]);
seed = 0;
}
}
return(g);
}
public void NodeLiteralLanguageSpecifierCase3()
{
IGraph g = new Graph();
ILiteralNode lcase = g.CreateLiteralNode("example", "en-gb");
ILiteralNode ucase = g.CreateLiteralNode("example", "en-GB");
INode s = g.CreateBlankNode();
INode p = g.CreateUriNode(UriFactory.Create("http://predicate"));
g.Assert(s, p, lcase);
g.Assert(s, p, ucase);
Assert.Equal(1, g.Triples.Count);
Assert.Single(g.GetTriplesWithObject(lcase));
Assert.Single(g.GetTriplesWithObject(ucase));
}
public void GraphMatchTrivial2()
{
Graph g = new Graph();
IBlankNode a = g.CreateBlankNode("b1");
IBlankNode b = g.CreateBlankNode("b2");
IBlankNode c = g.CreateBlankNode("b3");
INode pred = g.CreateUriNode(UriFactory.Create("http://predicate"));
g.Assert(a, pred, g.CreateLiteralNode("A"));
g.Assert(a, pred, b);
g.Assert(b, pred, g.CreateLiteralNode("B"));
g.Assert(b, pred, c);
g.Assert(c, pred, g.CreateLiteralNode("C"));
g.Assert(c, pred, a);
Graph h = new Graph();
IBlankNode a2 = h.CreateBlankNode("b4");
IBlankNode b2 = h.CreateBlankNode("b5");
IBlankNode c2 = h.CreateBlankNode("b3");
INode pred2 = h.CreateUriNode(UriFactory.Create("http://predicate"));
h.Assert(a2, pred2, h.CreateLiteralNode("A"));
h.Assert(a2, pred2, b2);
h.Assert(b2, pred2, h.CreateLiteralNode("B"));
h.Assert(b2, pred2, c2);
h.Assert(c2, pred2, h.CreateLiteralNode("C"));
h.Assert(c2, pred2, a2);
GraphDiffReport report = g.Difference(h);
if (!report.AreEqual)
{
TestTools.ShowDifferences(report);
}
Assert.IsTrue(report.AreEqual);
}
public void NodeLiteralLanguageSpecifierCase3()
{
IGraph g = new Graph();
ILiteralNode lcase = g.CreateLiteralNode("example", "en-gb");
ILiteralNode ucase = g.CreateLiteralNode("example", "en-GB");
INode s = g.CreateBlankNode();
INode p = g.CreateUriNode(UriFactory.Create("http://predicate"));
g.Assert(s, p, lcase);
g.Assert(s, p, ucase);
Assert.AreEqual(1, g.Triples.Count, "Triples should be treated as equivalent");
Assert.AreEqual(1, g.GetTriplesWithObject(lcase).Count(), "Lower case search failed");
Assert.AreEqual(1, g.GetTriplesWithObject(ucase).Count(), "Upper case search failed");
}
public void GraphTripleCreation()
{
//Create two Graphs
Graph g = new Graph();
Graph h = new Graph();
g.NamespaceMap.AddNamespace("ex", new Uri("http://example.org/"));
h.NamespaceMap.AddNamespace("ex", new Uri("http://example.org/"));
//Create a Triple in First Graph
g.Assert(g.CreateBlankNode(), g.CreateUriNode("rdf:type"), g.CreateUriNode("ex:Triple"));
Assert.Equal(1, g.Triples.Count);
//Create a Triple in Second Graph
h.Assert(h.CreateBlankNode(), h.CreateUriNode("rdf:type"), h.CreateUriNode("ex:Triple"));
Assert.Equal(1, h.Triples.Count);
}
public void GraphEventBubbling()
{
try
{
this._graphAdded = false;
this._graphRemoved = false;
this._graphChanged = false;
//Create Store and Graph add attach handlers to Store
TripleStore store = new TripleStore();
Graph g = new Graph();
store.GraphAdded += this.HandleGraphAdded;
store.GraphRemoved += this.HandleGraphRemoved;
store.GraphChanged += this.HandleGraphChanged;
//Add the Graph to the Store which should fire the GraphAdded event
store.Add(g);
Assert.IsTrue(this._graphAdded, "GraphAdded event of the Triple Store should have fired");
//Assert a Triple
INode s = g.CreateBlankNode();
INode p = g.CreateUriNode("rdf:type");
INode o = g.CreateUriNode("rdfs:Class");
Triple t = new Triple(s, p, o);
g.Assert(t);
Assert.IsTrue(this._graphChanged, "GraphChanged event of the Triple Store should have fired");
//Retract the Triple
this._graphChanged = false;
g.Retract(t);
Assert.IsTrue(this._graphChanged, "GraphChanged event of the Triple Store should have fired");
//Remove the Graph from the Store which should fire the GraphRemoved event
store.Remove(g.BaseUri);
Assert.IsTrue(this._graphRemoved, "GraphRemoved event of the Triple Store should have fired");
}
catch (Exception ex)
{
throw;
}
}
public void GraphDiffAddedMSG()
{
Graph g = new Graph();
Graph h = new Graph();
g.LoadFromFile("resources\\InferenceTest.ttl");
h.LoadFromFile("resources\\InferenceTest.ttl");
//Add additional Triple to 2nd Graph
INode blank = h.CreateBlankNode();
IUriNode subClass = h.CreateUriNode("rdfs:subClassOf");
IUriNode vehicle = h.CreateUriNode("eg:Vehicle");
h.Assert(new Triple(blank, subClass, vehicle));
GraphDiffReport report = g.Difference(h);
TestTools.ShowDifferences(report);
Assert.False(report.AreEqual, "Graphs should not have been reported as equal");
Assert.True(report.AddedMSGs.Any(), "Difference should have reported some Added MSGs");
}
public void NodeCompareToMixedNodes2()
{
Graph g = new Graph();
IBlankNode b = g.CreateBlankNode();
ILiteralNode l = g.CreateLiteralNode("literal", "en");
IUriNode u = g.CreateUriNode(new Uri("http://example.org"));
IVariableNode v = g.CreateVariableNode("var");
int c = b.CompareTo(l);
Assert.Equal(c * -1, l.CompareTo(b));
c = b.CompareTo(u);
Assert.Equal(c * -1, u.CompareTo(b));
c = b.CompareTo(v);
Assert.Equal(c * -1, v.CompareTo(b));
c = l.CompareTo(b);
Assert.Equal(c * -1, b.CompareTo(l));
c = l.CompareTo(u);
Assert.Equal(c * -1, u.CompareTo(l));
c = l.CompareTo(v);
Assert.Equal(c * -1, v.CompareTo(l));
c = u.CompareTo(b);
Assert.Equal(c * -1, b.CompareTo(u));
c = u.CompareTo(l);
Assert.Equal(c * -1, l.CompareTo(u));
c = u.CompareTo(v);
Assert.Equal(c * -1, v.CompareTo(u));
c = v.CompareTo(b);
Assert.Equal(c * -1, b.CompareTo(v));
c = v.CompareTo(l);
Assert.Equal(c * -1, l.CompareTo(v));
c = v.CompareTo(u);
Assert.Equal(c * -1, u.CompareTo(v));
}
public void NodeCompareToMixedNodes2()
{
Graph g = new Graph();
IBlankNode b = g.CreateBlankNode();
ILiteralNode l = g.CreateLiteralNode("literal", "en");
IUriNode u = g.CreateUriNode(new Uri("http://example.org"));
IVariableNode v = g.CreateVariableNode("var");
int c = b.CompareTo(l);
Assert.AreEqual(c * -1, l.CompareTo(b), "Expected l compareTo b to be inverse of b compareTo l");
c = b.CompareTo(u);
Assert.AreEqual(c * -1, u.CompareTo(b), "Expected l compareTo u to be inverse of u compareTo l");
c = b.CompareTo(v);
Assert.AreEqual(c * -1, v.CompareTo(b), "Expected l compareTo v to be inverse of v compareTo l");
c = l.CompareTo(b);
Assert.AreEqual(c * -1, b.CompareTo(l), "Expected b compareTo l to be inverse of l compareTo b");
c = l.CompareTo(u);
Assert.AreEqual(c * -1, u.CompareTo(l), "Expected u compareTo l to be inverse of l compareTo u");
c = l.CompareTo(v);
Assert.AreEqual(c * -1, v.CompareTo(l), "Expected v compareTo l to be inverse of l compareTo v");
c = u.CompareTo(b);
Assert.AreEqual(c * -1, b.CompareTo(u), "Expected b compareTo u to be inverse of u compareTo b");
c = u.CompareTo(l);
Assert.AreEqual(c * -1, l.CompareTo(u), "Expected l compareTo u to be inverse of u compareTo l");
c = u.CompareTo(v);
Assert.AreEqual(c * -1, v.CompareTo(u), "Expected v compareTo u to be inverse of u compareTo v");
c = v.CompareTo(b);
Assert.AreEqual(c * -1, b.CompareTo(v), "Expected b compareTo v to be inverse of v compareTo b");
c = v.CompareTo(l);
Assert.AreEqual(c * -1, l.CompareTo(v), "Expected l compareTo v to be inverse of v compareTo l");
c = v.CompareTo(u);
Assert.AreEqual(c * -1, u.CompareTo(v), "Expected u compareTo v to be inverse of v compareTo u");
}
public static void Main(string[] args)
{
StreamWriter output = new StreamWriter("HashCodeTests.txt");
Console.SetOut(output);
try
{
Console.WriteLine("## Hash Code Tests");
Console.WriteLine("Tests that Literal and URI Nodes produce different Hashes");
Console.WriteLine();
//Create the Nodes
Graph g = new Graph();
IUriNode u = g.CreateUriNode(new Uri("http://www.google.com"));
ILiteralNode l = g.CreateLiteralNode("http://www.google.com/");
Console.WriteLine("Created a URI and Literal Node both referring to 'http://www.google.com'");
Console.WriteLine("String form of URI Node is:");
Console.WriteLine(u.ToString());
Console.WriteLine("String form of Literal Node is:");
Console.WriteLine(l.ToString());
Console.WriteLine("Hash Code of URI Node is " + u.GetHashCode());
Console.WriteLine("Hash Code of Literal Node is " + l.GetHashCode());
Console.WriteLine("Hash Codes are Equal? " + u.GetHashCode().Equals(l.GetHashCode()));
Console.WriteLine("Nodes are equal? " + u.Equals(l));
//Create Triples
IBlankNode b = g.CreateBlankNode();
IUriNode type = g.CreateUriNode("rdf:type");
Triple t1, t2;
t1 = new Triple(b, type, u);
t2 = new Triple(b, type, l);
Console.WriteLine();
Console.WriteLine("Created two Triples stating a Blank Node has rdf:type of the Nodes created earlier");
Console.WriteLine("String form of Triple 1 (using URI Node) is:");
Console.WriteLine(t1.ToString());
Console.WriteLine("String form of Triple 2 (using Literal Node) is:");
Console.WriteLine(t2.ToString());
Console.WriteLine("Hash Code of Triple 1 is " + t1.GetHashCode());
Console.WriteLine("Hash Code of Triple 2 is " + t2.GetHashCode());
Console.WriteLine("Hash Codes are Equal? " + t1.GetHashCode().Equals(t2.GetHashCode()));
Console.WriteLine("Triples are Equal? " + t1.Equals(t2));
//Now going to look at the Hash Code collisions from the dotNetRDF Store
Console.WriteLine();
Console.WriteLine("Examing the Hash Code Collisions from one of our SQL Store test data sets");
// MicrosoftSqlStoreManager manager = new MicrosoftSqlStoreManager("localhost", "bbcone", "example", "password");
// DataTable collisions = manager.ExecuteQuery(@"SELECT * FROM TRIPLES WHERE tripleHash IN
// (
// SELECT tripleHash FROM TRIPLES GROUP BY tripleHash HAVING COUNT(tripleID)>1
// ) ORDER BY tripleHash");
// foreach (DataRow r in collisions.Rows)
// {
// String s, p, o;
// int hash;
// s = r["tripleSubject"].ToString();
// p = r["triplePredicate"].ToString();
// o = r["tripleObject"].ToString();
// hash = Int32.Parse(r["tripleHash"].ToString());
// INode subj = manager.LoadNode(g, s);
// INode pred = manager.LoadNode(g, p);
// INode obj = manager.LoadNode(g, o);
// Triple t = new Triple(subj, pred, obj);
// Console.WriteLine("Subject (ID " + s + "): " + subj.ToString() + " (Hash " + subj.GetHashCode() + ")");
// Console.WriteLine("Predicate (ID " + p + "): " + pred.ToString() + " (Hash " + pred.GetHashCode() + ")");
// Console.WriteLine("Object (ID " + o + "): " + obj.ToString() + " (Hash " + obj.GetHashCode() + ")");
// Console.WriteLine(t.ToString());
// Console.WriteLine("Triple Hash " + t.GetHashCode());
// Console.WriteLine("Triple Hash Code Construct " + subj.GetHashCode().ToString() + pred.GetHashCode().ToString() + obj.GetHashCode().ToString());
// Console.WriteLine("Triple Hash in Store " + hash);
// Console.WriteLine();
// }
// manager.Dispose();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
finally
{
output.Close();
}
}
public void WritingRdfXmlBNodes()
{
Graph g = new Graph();
INode s = g.CreateUriNode(new Uri("http://example.org/subject"));
INode p = g.CreateUriNode(new Uri("http://example.org/predicate"));
INode o = g.CreateBlankNode();
g.Assert(s, p, o);
s = o;
p = g.CreateUriNode(new Uri("http://example.org/nextPredicate"));
o = g.CreateLiteralNode("string");
g.Assert(s, p, o);
this.CheckRoundTrip(g);
}
public void NodesEqualityOperator()
{
Console.WriteLine("Testing that the overridden operators for Nodes work as expected");
try
{
Graph g = new Graph();
IBlankNode a = g.CreateBlankNode();
IBlankNode b = g.CreateBlankNode();
Console.WriteLine("Testing using Equals() method");
Assert.IsFalse(a.Equals(b), "Two different Blank Nodes should be non-equal");
Assert.IsTrue(a.Equals(a), "A Blank Node should be equal to itself");
Assert.IsTrue(b.Equals(b), "A Blank Node should be equal to itself");
Console.WriteLine("OK");
Console.WriteLine();
Console.WriteLine("Testing using == operator");
Assert.IsFalse(a == b, "Two different Blank Nodes should be non-equal");
Assert.IsTrue(a == a, "A Blank Node should be equal to itself");
Assert.IsTrue(b == b, "A Blank Node should be equal to itself");
Console.WriteLine("OK");
Console.WriteLine();
//Test typed as INode
INode c = g.CreateBlankNode();
INode d = g.CreateBlankNode();
Console.WriteLine("Now testing with typed as INode using Equals()");
Assert.IsFalse(c.Equals(d), "Two different Nodes should be non-equal");
Assert.IsTrue(c.Equals(c), "A Node should be equal to itself");
Assert.IsTrue(d.Equals(d), "A Node should be equal to itself");
Console.WriteLine("OK");
Console.WriteLine();
Console.WriteLine("Now testing with typed as INode using == operator");
Assert.IsFalse(c == d, "Two different Nodes should be non-equal");
Assert.IsTrue(c == c, "A Node should be equal to itself");
Assert.IsTrue(d == d, "A Node should be equal to itself");
Console.WriteLine("OK");
}
catch (RdfException rdfEx)
{
TestTools.ReportError("RDF Error", rdfEx, true);
}
catch (Exception ex)
{
TestTools.ReportError("Error", ex, true);
}
}
static void Main(string[] args)
{
//Going to create a Graph and assert some stuff into it
Graph g = new Graph();
//Try to read from a file
TurtleParser parser = new TurtleParser();
parser.TraceTokeniser = true;
parser.TraceParsing = true;
try
{
StreamReader input = new StreamReader("test.n3");
parser.Load(g, input);
}
catch (RDFException rdfEx)
{
reportError("RDF Exception", rdfEx);
}
catch (IOException ioEx)
{
reportError("IO Exception", ioEx);
}
catch (Exception ex)
{
reportError("Other Exception", ex);
}
Console.WriteLine();
Console.WriteLine();
//Show Namespaces
Console.WriteLine("All Namespaces");
foreach (String pre in g.NamespaceMap.Prefixes)
{
Console.WriteLine(pre + " = " + g.NamespaceMap.GetNamespaceURI(pre));
}
Console.WriteLine();
//Now print all the Statements
Console.WriteLine("All Statements");
foreach (Triple t in g.Triples)
{
Console.WriteLine(t.ToString());
}
System.Threading.Thread.Sleep(60000);
return;
g.NamespaceMap.AddNamespace("vds", new Uri("http://www.vdesign-studios.com/dotNetRDF#"));
g.NamespaceMap.AddNamespace("ecs", new Uri("http://id.ecs.soton.ac.uk/person/"));
//g.BaseURI = g.NamespaceMap.GetNamespaceURI("vds");
URINode rav08r, wh, lac, hcd;
rav08r = g.CreateURINode("ecs:11471");
wh = g.CreateURINode("ecs:1650");
hcd = g.CreateURINode("ecs:46");
lac = g.CreateURINode("ecs:60");
BlankNode blank = g.CreateBlankNode();
URINode a, b, c, d, has;
a = g.CreateURINode("vds:someRel");
b = g.CreateURINode("vds:someOtherRel");
c = g.CreateURINode("vds:someObj");
d = g.CreateURINode("vds:someOtherObj");
has = g.CreateURINode("vds:has");
URINode supervises, collaborates, advises;
supervises = g.CreateURINode("vds:supervises");
collaborates = g.CreateURINode("vds:collaborates");
advises = g.CreateURINode("vds:advises");
LiteralNode singleLine = g.CreateLiteralNode("Some string");
LiteralNode multiLine = g.CreateLiteralNode("This goes over\n\nseveral\n\nlines");
LiteralNode french = g.CreateLiteralNode("Bonjour", "fr");
g.Assert(new Triple(wh, supervises, rav08r));
g.Assert(new Triple(lac, supervises, rav08r));
g.Assert(new Triple(hcd, advises, rav08r));
g.Assert(new Triple(wh, collaborates, lac));
g.Assert(new Triple(wh, collaborates, hcd));
g.Assert(new Triple(lac, collaborates, hcd));
//g.Assert(new Triple(rav08r, blank, c));
//g.Assert(new Triple(rav08r, blank, d));
g.Assert(new Triple(rav08r, has, singleLine));
g.Assert(new Triple(rav08r, has, multiLine));
g.Assert(new Triple(rav08r, has, french));
//Now print all the Statements
Console.WriteLine("All Statements");
foreach (Triple t in g.Triples)
{
Console.WriteLine(t.ToString());
}
//Get statements about Rob Vesse
Console.WriteLine();
Console.WriteLine("Statements about Rob Vesse");
foreach (Triple t in g.GetTriples(rav08r))
{
Console.WriteLine(t.ToString());
}
//Get Statements about Collaboration
Console.WriteLine();
Console.WriteLine("Statements about Collaboration");
foreach (Triple t in g.GetTriples(collaborates))
{
Console.WriteLine(t.ToString());
}
//Show Namespaces for URINodes
Console.WriteLine();
Console.WriteLine("Namespaces for URI Nodes");
foreach (URINode u in g.Nodes.URINodes)
{
Console.WriteLine(u.Namespace + " = " + u.URI);
}
//Attempt to output Notation 3 for this Graph
try
{
TurtleWriter n3writer = new TurtleWriter();
n3writer.Save(g, "test.n3");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
System.Threading.Thread.Sleep(30000);
}
public static void Main(string[] args)
{
//Stream for Output
StreamWriter output = new StreamWriter("SortingTests.txt");
Console.SetOut(output);
Console.WriteLine("## Sorting Test");
Console.WriteLine("NULLs < Blank Nodes < URI Nodes < Untyped Literals < Typed Literals");
Console.WriteLine();
//Create a Graph
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/");
g.NamespaceMap.AddNamespace("",new Uri("http://example.org/"));
//Create a list of various Nodes
List<INode> nodes = new List<INode>();
nodes.Add(g.CreateUriNode(":someUri"));
nodes.Add(g.CreateBlankNode());
nodes.Add(null);
nodes.Add(g.CreateBlankNode());
nodes.Add(g.CreateLiteralNode("cheese"));
nodes.Add(g.CreateLiteralNode("aardvark"));
nodes.Add(g.CreateLiteralNode(DateTime.Now.AddDays(-25).ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat), new Uri(XmlSpecsHelper.XmlSchemaDataTypeDateTime)));
nodes.Add(g.CreateLiteralNode("duck"));
nodes.Add(g.CreateUriNode(":otherUri"));
nodes.Add(g.CreateLiteralNode("1.5",new Uri(XmlSpecsHelper.XmlSchemaDataTypeDouble)));
nodes.Add(g.CreateUriNode(new Uri("http://www.google.com")));
nodes.Add(g.CreateLiteralNode(DateTime.Now.AddYears(3).ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat), new Uri(XmlSpecsHelper.XmlSchemaDataTypeDateTime)));
nodes.Add(g.CreateLiteralNode("23",new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateLiteralNode("M43d", new Uri(XmlSpecsHelper.XmlSchemaDataTypeBase64Binary)));
nodes.Add(g.CreateUriNode(new Uri("http://www.dotnetrdf.org")));
nodes.Add(g.CreateLiteralNode("12",new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateBlankNode("monkey"));
nodes.Add(g.CreateBlankNode());
nodes.Add(g.CreateLiteralNode("chaese"));
nodes.Add(g.CreateLiteralNode("1.0456345",new Uri(XmlSpecsHelper.XmlSchemaDataTypeDouble)));
nodes.Add(g.CreateLiteralNode("cheese"));
nodes.Add(g.CreateLiteralNode(Convert.ToBase64String(new byte[] { Byte.Parse("32") }), new Uri(XmlSpecsHelper.XmlSchemaDataTypeBase64Binary)));
nodes.Add(g.CreateLiteralNode("TA==", new Uri(XmlSpecsHelper.XmlSchemaDataTypeBase64Binary)));
nodes.Add(g.CreateLiteralNode("-45454", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateLiteralNode(DateTime.Now.ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat), new Uri(XmlSpecsHelper.XmlSchemaDataTypeDateTime)));
nodes.Add(g.CreateLiteralNode("-3",new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateLiteralNode("242344.3456435",new Uri(XmlSpecsHelper.XmlSchemaDataTypeDouble)));
nodes.Add(g.CreateLiteralNode("true",new Uri(XmlSpecsHelper.XmlSchemaDataTypeBoolean)));
nodes.Add(g.CreateUriNode(":what"));
nodes.Add(null);
nodes.Add(g.CreateLiteralNode("false",new Uri(XmlSpecsHelper.XmlSchemaDataTypeBoolean)));
for (int i = 0; i < 32; i++)
{
nodes.Add(g.CreateLiteralNode(i.ToString("x"),new Uri(XmlSpecsHelper.XmlSchemaDataTypeHexBinary)));
}
for (byte b = 50; b < 77; b++)
{
nodes.Add(g.CreateLiteralNode(Convert.ToBase64String(new byte[] { b }), new Uri(XmlSpecsHelper.XmlSchemaDataTypeBase64Binary)));
}
nodes.Sort();
//Output the Results
foreach (INode n in nodes) {
if (n == null) {
Console.WriteLine("NULL");
} else {
Console.WriteLine(n.ToString());
}
}
Console.WriteLine();
Console.WriteLine("Now in reverse...");
Console.WriteLine();
nodes.Reverse();
//Output the Results
foreach (INode n in nodes)
{
if (n == null)
{
Console.WriteLine("NULL");
}
else
{
Console.WriteLine(n.ToString());
}
}
output.Close();
}
public void GraphListsError2()
{
Graph g = new Graph();
Assert.Throws <RdfException>(() => g.GetListAsTriples(g.CreateBlankNode()));
}
public void NodeCompareToMixedNodes3()
{
Graph g = new Graph();
Graph h = new Graph();
IBlankNode b = g.CreateBlankNode();
ILiteralNode plain = g.CreateLiteralNode("plain");
IUriNode u = g.CreateUriNode("rdf:type");
List <INode> nodes = new List <INode>()
{
b,
g.CreateBlankNode(),
g.CreateBlankNode("id"),
g.CreateLiteralNode("1.2e3", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
g.CreateLiteralNode("1.2", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
g.CreateLiteralNode("1.2e1", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
g.CreateLiteralNode("10", new Uri(XmlSpecsHelper.XmlSchemaDataTypeShort)),
g.CreateLiteralNode("-3", new Uri(XmlSpecsHelper.XmlSchemaDataTypeShort)),
g.CreateLiteralNode("1.2E4", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
g.CreateLiteralNode("http://example.org:8080", new Uri(XmlSpecsHelper.XmlSchemaDataTypeAnyUri)),
g.CreateLiteralNode("http://example.org/path", new Uri(XmlSpecsHelper.XmlSchemaDataTypeAnyUri)),
g.CreateLiteralNode("ftp://ftp.example.org", new Uri(XmlSpecsHelper.XmlSchemaDataTypeAnyUri)),
g.CreateLiteralNode("1.2e0", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
DateTime.Now.ToLiteral(g),
DateTime.Now.AddYears(3).AddDays(1).ToLiteral(g),
DateTime.Now.AddYears(-25).AddMinutes(-17).ToLiteral(g),
g.CreateLiteralNode("1.2e-1", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
g.CreateLiteralNode("10", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
g.CreateLiteralNode("10e14", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
h.CreateBlankNode(),
h.CreateBlankNode("id"),
b,
plain,
g.CreateLiteralNode("plain english", "en"),
g.CreateLiteralNode("1", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)),
g.CreateLiteralNode("10", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)),
g.CreateLiteralNode("plain french", "fr"),
g.CreateLiteralNode("typed", new Uri(XmlSpecsHelper.XmlSchemaDataTypeString)),
(1234).ToLiteral(g),
(12.34m).ToLiteral(g),
(12.34d).ToLiteral(g),
(false).ToLiteral(g),
g.CreateLiteralNode((1).ToString("X2"), new Uri(XmlSpecsHelper.XmlSchemaDataTypeHexBinary)),
g.CreateLiteralNode((10).ToString("X2"), new Uri(XmlSpecsHelper.XmlSchemaDataTypeHexBinary)),
(true).ToLiteral(g),
plain,
u,
g.CreateUriNode(new Uri("http://example.org")),
g.CreateUriNode(new Uri("http://example.org:8080")),
g.CreateLiteralNode("1", new Uri(XmlSpecsHelper.XmlSchemaDataTypeByte)),
g.CreateLiteralNode("10", new Uri(XmlSpecsHelper.XmlSchemaDataTypeByte)),
g.CreateLiteralNode("-3", new Uri(XmlSpecsHelper.XmlSchemaDataTypeByte)),
g.CreateUriNode(new Uri("http://www.dotnetrdf.org")),
g.CreateUriNode(new Uri("http://www.dotnetrdf.org/configuration#")),
g.CreateUriNode(new Uri("http://www.dotnetrdf.org/Configuration#")),
g.CreateUriNode(new Uri("mailto:[email protected]")),
u
};
this.ShowOrdering(nodes);
this.CheckCombinations(nodes);
}
public void GraphListsError3()
{
Graph g = new Graph();
g.RetractList(g.CreateBlankNode());
}
public void GraphListsError5()
{
Graph g = new Graph();
g.RemoveFromList <int>(g.CreateBlankNode(), Enumerable.Range(1, 10), i => i.ToLiteral(g));
}
public void GraphListsError1()
{
Graph g = new Graph();
g.GetListItems(g.CreateBlankNode());
}
public void GraphListsError2()
{
Graph g = new Graph();
g.GetListAsTriples(g.CreateBlankNode());
}
public void GraphLists5()
{
Graph g = new Graph();
g.AddToList(g.CreateBlankNode(), Enumerable.Empty <INode>());
}
public void GraphListsError3()
{
Graph g = new Graph();
Assert.Throws <RdfException>(() => g.RetractList(g.CreateBlankNode()));
}
public void GraphListsError5()
{
Graph g = new Graph();
Assert.Throws <RdfException>(() => g.RemoveFromList <int>(g.CreateBlankNode(), Enumerable.Range(1, 10), i => i.ToLiteral(g)));
}
public void NodesSortingSparqlOrder()
{
SparqlOrderingComparer comparer = new SparqlOrderingComparer();
//Stream for Output
Console.WriteLine("## Sorting Test");
Console.WriteLine("NULLs < Blank Nodes < URI Nodes < Untyped Literals < Typed Literals");
Console.WriteLine();
//Create a Graph
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/");
g.NamespaceMap.AddNamespace("", new Uri("http://example.org/"));
//Create a list of various Nodes
List <INode> nodes = new List <INode>();
nodes.Add(g.CreateUriNode(":someUri"));
nodes.Add(g.CreateBlankNode());
nodes.Add(null);
nodes.Add(g.CreateBlankNode());
nodes.Add(g.CreateLiteralNode("cheese"));
nodes.Add(g.CreateLiteralNode("aardvark"));
nodes.Add(g.CreateLiteralNode(DateTime.Now.AddDays(-25).ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat), new Uri(XmlSpecsHelper.XmlSchemaDataTypeDateTime)));
nodes.Add(g.CreateLiteralNode("duck"));
nodes.Add(g.CreateUriNode(":otherUri"));
nodes.Add(g.CreateLiteralNode("1.5", new Uri(XmlSpecsHelper.XmlSchemaDataTypeDouble)));
nodes.Add(g.CreateUriNode(new Uri("http://www.google.com")));
nodes.Add(g.CreateLiteralNode(DateTime.Now.AddYears(3).ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat), new Uri(XmlSpecsHelper.XmlSchemaDataTypeDateTime)));
nodes.Add(g.CreateLiteralNode("23", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateLiteralNode("M43d", new Uri(XmlSpecsHelper.XmlSchemaDataTypeBase64Binary)));
nodes.Add(g.CreateUriNode(new Uri("http://www.dotnetrdf.org")));
nodes.Add(g.CreateLiteralNode("12", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateBlankNode("monkey"));
nodes.Add(g.CreateBlankNode());
nodes.Add(g.CreateLiteralNode("chaese"));
nodes.Add(g.CreateLiteralNode("1.0456345", new Uri(XmlSpecsHelper.XmlSchemaDataTypeDouble)));
nodes.Add(g.CreateLiteralNode("cheese"));
nodes.Add(g.CreateLiteralNode(Convert.ToBase64String(new byte[] { Byte.Parse("32") }), new Uri(XmlSpecsHelper.XmlSchemaDataTypeBase64Binary)));
nodes.Add(g.CreateLiteralNode("TA==", new Uri(XmlSpecsHelper.XmlSchemaDataTypeBase64Binary)));
nodes.Add(g.CreateLiteralNode("-45454", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateLiteralNode(DateTime.Now.ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat), new Uri(XmlSpecsHelper.XmlSchemaDataTypeDateTime)));
nodes.Add(g.CreateLiteralNode("-3", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateLiteralNode("242344.3456435", new Uri(XmlSpecsHelper.XmlSchemaDataTypeDouble)));
nodes.Add(g.CreateLiteralNode("true", new Uri(XmlSpecsHelper.XmlSchemaDataTypeBoolean)));
nodes.Add(g.CreateUriNode(":what"));
nodes.Add(null);
nodes.Add(g.CreateLiteralNode("false", new Uri(XmlSpecsHelper.XmlSchemaDataTypeBoolean)));
nodes.Add(g.CreateLiteralNode("invalid-value", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Sort(comparer);
//Output the Results
foreach (INode n in nodes)
{
if (n == null)
{
Console.WriteLine("NULL");
}
else
{
Console.WriteLine(n.ToString());
}
}
Console.WriteLine();
Console.WriteLine("Now in reverse...");
Console.WriteLine();
nodes.Reverse();
//Output the Results
foreach (INode n in nodes)
{
if (n == null)
{
Console.WriteLine("NULL");
}
else
{
Console.WriteLine(n.ToString());
}
}
}
public void NodesHashCodes()
{
Console.WriteLine("Tests that Literal and URI Nodes produce different Hashes");
Console.WriteLine();
//Create the Nodes
Graph g = new Graph();
IUriNode u = g.CreateUriNode(new Uri("http://www.google.com"));
ILiteralNode l = g.CreateLiteralNode("http://www.google.com/");
Console.WriteLine("Created a URI and Literal Node both referring to 'http://www.google.com'");
Console.WriteLine("String form of URI Node is:");
Console.WriteLine(u.ToString());
Console.WriteLine("String form of Literal Node is:");
Console.WriteLine(l.ToString());
Console.WriteLine("Hash Code of URI Node is " + u.GetHashCode());
Console.WriteLine("Hash Code of Literal Node is " + l.GetHashCode());
Console.WriteLine("Hash Codes are Equal? " + u.GetHashCode().Equals(l.GetHashCode()));
Console.WriteLine("Nodes are equal? " + u.Equals(l));
Assert.NotEqual(u.GetHashCode(), l.GetHashCode());
Assert.NotSame(u, l);
//Assert.NotEqual(u, l);
//Create some plain and typed literals which may have colliding Hash Codes
ILiteralNode plain = g.CreateLiteralNode("test^^http://example.org/type");
ILiteralNode typed = g.CreateLiteralNode("test", new Uri("http://example.org/type"));
Console.WriteLine();
Console.WriteLine("Created a Plain and Typed Literal where the String representations are identical");
Console.WriteLine("Plain Literal String form is:");
Console.WriteLine(plain.ToString());
Console.WriteLine("Typed Literal String from is:");
Console.WriteLine(typed.ToString());
Console.WriteLine("Hash Code of Plain Literal is " + plain.GetHashCode());
Console.WriteLine("Hash Code of Typed Literal is " + typed.GetHashCode());
Console.WriteLine("Hash Codes are Equal? " + plain.GetHashCode().Equals(typed.GetHashCode()));
Console.WriteLine("Nodes are equal? " + plain.Equals(typed));
Assert.NotEqual(plain.GetHashCode(), typed.GetHashCode());
Assert.NotEqual(plain, typed);
//Create Triples
IBlankNode b = g.CreateBlankNode();
IUriNode type = g.CreateUriNode("rdf:type");
Triple t1, t2;
t1 = new Triple(b, type, u);
t2 = new Triple(b, type, l);
Console.WriteLine();
Console.WriteLine("Created two Triples stating a Blank Node has rdf:type of the URI Nodes created earlier");
Console.WriteLine("String form of Triple 1 (using URI Node) is:");
Console.WriteLine(t1.ToString());
Console.WriteLine("String form of Triple 2 (using Literal Node) is:");
Console.WriteLine(t2.ToString());
Console.WriteLine("Hash Code of Triple 1 is " + t1.GetHashCode());
Console.WriteLine("Hash Code of Triple 2 is " + t2.GetHashCode());
Console.WriteLine("Hash Codes are Equal? " + t1.GetHashCode().Equals(t2.GetHashCode()));
Console.WriteLine("Triples are Equal? " + t1.Equals(t2));
Assert.NotEqual(t1.GetHashCode(), t2.GetHashCode());
Assert.NotEqual(t1, t2);
//Create Triples from the earlier Literal Nodes
t1 = new Triple(b, type, plain);
t2 = new Triple(b, type, typed);
Console.WriteLine();
Console.WriteLine("Created two Triples stating a Blank Node has rdf:type of the Literal Nodes created earlier");
Console.WriteLine("String form of Triple 1 (using Plain Literal) is:");
Console.WriteLine(t1.ToString());
Console.WriteLine("String form of Triple 2 (using Typed Literal) is:");
Console.WriteLine(t2.ToString());
Console.WriteLine("Hash Code of Triple 1 is " + t1.GetHashCode());
Console.WriteLine("Hash Code of Triple 2 is " + t2.GetHashCode());
Console.WriteLine("Hash Codes are Equal? " + t1.GetHashCode().Equals(t2.GetHashCode()));
Console.WriteLine("Triples are Equal? " + t1.Equals(t2));
Assert.NotEqual(t1.GetHashCode(), t2.GetHashCode());
Assert.NotEqual(t1, t2);
}
