public void NodeCompareToEquivalentLiterals3()
{
Graph g = new Graph();
ILiteralNode canonical = (1d).ToLiteral(g);
ILiteralNode alternate = g.CreateLiteralNode("1.00000", UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeDouble));
List <INode> ns = new List <INode>()
{
canonical,
alternate
};
Assert.NotEqual(canonical, alternate);
Assert.Equal(0, canonical.CompareTo(alternate));
this.ShowOrdering(ns);
this.CheckCombinations(ns);
this.CheckCombinations <ILiteralNode>(ns.OfType <ILiteralNode>().ToList());
this.CheckCombinations(ns, new FastNodeComparer());
}
public void NodeCompareToEquivalentLiterals2()
{
Graph g = new Graph();
ILiteralNode canonical = (true).ToLiteral(g);
ILiteralNode alternate = g.CreateLiteralNode("TRUE", UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeBoolean));
List<INode> ns = new List<INode>()
{
canonical,
alternate
};
Assert.AreNotEqual(canonical, alternate, "Alternate lexical forms should not be equal");
Assert.AreEqual(0, canonical.CompareTo(alternate), "Comparison should compare alternate lexical forms as equal");
this.ShowOrdering(ns);
this.CheckCombinations(ns);
this.CheckCombinations<ILiteralNode>(ns.OfType<ILiteralNode>().ToList());
this.CheckCombinations(ns, new FastNodeComparer());
}
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");
}
/// <summary>
/// Determines whether two Literals are equal.
/// </summary>
/// <param name="a">First Literal.</param>
/// <param name="b">Second Literal.</param>
/// <returns></returns>
public static bool AreLiteralsEqual(ILiteralNode a, ILiteralNode b)
{
if (ReferenceEquals(a, b))
{
return(true);
}
if (a == null)
{
if (b == null)
{
return(true);
}
return(false);
}
else if (b == null)
{
return(false);
}
// Language Tags must be equal (if present)
// If they don't have language tags then they'll both be set to String.Empty which will give true
if (a.Language.Equals(b.Language, StringComparison.OrdinalIgnoreCase))
{
// Datatypes must be equal (if present)
// If they don't have Data Types then they'll both be null
// Otherwise the URIs must be equal
if (a.DataType == null && b.DataType == null)
{
// Use String equality to get the result
return(a.Value.Equals(b.Value, StringComparison.Ordinal));
}
else if (a.DataType == null)
{
// We have a Null DataType but the other Node doesn't so can't be equal
return(false);
}
else if (b.DataType == null)
{
// The other Node has a Null DataType but we don't so can't be equal
return(false);
}
else if (AreUrisEqual(a.DataType, b.DataType))
{
// We have equal DataTypes so use String Equality to evaluate
if (Options.LiteralEqualityMode == LiteralEqualityMode.Strict)
{
// Strict Equality Mode uses Ordinal Lexical Comparison for Equality as per W3C RDF Spec
return(a.Value.Equals(b.Value, StringComparison.Ordinal));
}
else
{
// Loose Equality Mode uses Value Based Comparison for Equality of Typed Nodes
return(a.CompareTo(b) == 0);
}
}
else
{
// Data Types didn't match
return(false);
}
}
else
{
// Language Tags didn't match
return(false);
}
}
/// <summary>
/// Determines whether two Literals are equal
/// </summary>
/// <param name="a">First Literal</param>
/// <param name="b">Second Literal</param>
/// <returns></returns>
public static bool AreLiteralsEqual(ILiteralNode a, ILiteralNode b)
{
if (ReferenceEquals(a, b)) return true;
if (a == null)
{
if (b == null) return true;
return false;
}
else if (b == null)
{
return false;
}
//Language Tags must be equal (if present)
//If they don't have language tags then they'll both be set to String.Empty which will give true
if (a.Language.Equals(b.Language, StringComparison.OrdinalIgnoreCase))
{
//Datatypes must be equal (if present)
//If they don't have Data Types then they'll both be null
//Otherwise the URIs must be equal
if (a.DataType == null && b.DataType == null)
{
//Use String equality to get the result
return a.Value.Equals(b.Value, StringComparison.Ordinal);
}
else if (a.DataType == null)
{
//We have a Null DataType but the other Node doesn't so can't be equal
return false;
}
else if (b.DataType == null)
{
//The other Node has a Null DataType but we don't so can't be equal
return false;
}
else if (EqualityHelper.AreUrisEqual(a.DataType, b.DataType))
{
//We have equal DataTypes so use String Equality to evaluate
if (Options.LiteralEqualityMode == LiteralEqualityMode.Strict)
{
//Strict Equality Mode uses Ordinal Lexical Comparison for Equality as per W3C RDF Spec
return a.Value.Equals(b.Value, StringComparison.Ordinal);
}
else
{
//Loose Equality Mode uses Value Based Comparison for Equality of Typed Nodes
return (a.CompareTo(b) == 0);
}
}
else
{
//Data Types didn't match
return false;
}
}
else
{
//Language Tags didn't match
return false;
}
}
