public void Equals()
{
Triple <int, string, double> p1 = new Triple <int, string, double>(42, new string('z', 3), 4.5);
Triple <int, string, double> p2 = new Triple <int, string, double>(53, new string('z', 3), 4.5);
Triple <int, string, double> p3 = new Triple <int, string, double>(42, new string('z', 4), 2.1);
Triple <int, string, double> p4 = new Triple <int, string, double>(42, new string('z', 3), 4.5);
Triple <int, string, double> p5 = new Triple <int, string, double>(122, new string('y', 3), 3.14);
Triple <int, string, double> p6 = new Triple <int, string, double>(122, null, 3.14);
Triple <int, string, double> p7 = new Triple <int, string, double>(122, null, 3.14);
bool f;
f = p1.Equals(p2); Assert.IsFalse(f);
f = p1.Equals(p3); Assert.IsFalse(f);
f = p1.Equals(p4); Assert.IsTrue(f);
f = p1.Equals(p5); Assert.IsFalse(f);
f = p1.Equals("hi"); Assert.IsFalse(f);
f = p6.Equals(p7); Assert.IsTrue(f);
f = p1 == p2; Assert.IsFalse(f);
f = p1 == p3; Assert.IsFalse(f);
f = p1 == p4; Assert.IsTrue(f);
f = p1 == p5; Assert.IsFalse(f);
f = p6 == p7; Assert.IsTrue(f);
f = p1 != p2; Assert.IsTrue(f);
f = p1 != p3; Assert.IsTrue(f);
f = p1 != p4; Assert.IsFalse(f);
f = p1 != p5; Assert.IsTrue(f);
f = p6 != p7; Assert.IsFalse(f);
}
public void Test_Equals()
{
var tripOne = new Triple("12.3.4");
var tripTwo = new Triple("12.3.4");
// two instances should be equal
Assert.IsTrue(tripOne.Equals(tripTwo));
Assert.IsTrue(tripTwo.Equals(tripOne));
// self equality
Assert.IsTrue(tripOne.Equals(tripOne));
Assert.IsTrue(tripTwo.Equals(tripTwo));
}
public void EqualUncomparable()
{
var triple1 = new Triple <Unorderable, int, string>(new Unorderable(), 5, "hello");
var triple2 = new Triple <Unorderable, int, string>(new Unorderable(), 7, "world");
var triple3 = new Triple <Unorderable, int, string>(new Unorderable(), 5, "hello");
Assert.IsFalse(triple1.Equals(triple2));
Assert.IsTrue(triple1.Equals(triple3));
Assert.IsFalse(triple1 == triple2);
Assert.IsTrue(triple1 == triple3);
Assert.IsFalse(triple1.GetHashCode() == triple2.GetHashCode());
Assert.IsTrue(triple1.GetHashCode() == triple3.GetHashCode());
}
public bool Equals(SudokuRowHeader other)
{
if (other == null || this == null)
{
return(false);
}
return(cellLabel.Equals(other.cellLabel));
}
/// <summary>
/// Determines whether this instance is equal to another given node.
/// </summary>
/// <param name="other">The other node to compare this instance to.</param>
/// <returns>
/// <c>true</c> if the given node is equal to this instance; otherwise, <c>false</c>.
/// </returns>
public bool Equals(Node other)
{
//
// edge case for null values
if ((object)other == null)
{
return(false);
}
//
// for two nodes to be equal the representing variable or atom needs to be the same for
// both nodes, they need to contain the same SAP, and they need to contain the same
// operator. the trick for nodes in a join graph is that they don't always contain all
// of these values.
if (m_item == null)
{
if (other.m_item != null)
{
return(false);
}
}
else if (!m_item.Equals(other.m_item))
{
return(false);
}
if (m_sap == null)
{
if (other.m_sap != null)
{
return(false);
}
}
else if (!m_sap.Equals(other.m_sap))
{
return(false);
}
if (m_operator == null)
{
if (other.m_operator != null)
{
return(false);
}
}
else if (!ReferenceEquals(m_operator, other.m_operator))
{
return(false);
}
return(true);
}
/// <summary>
/// Equality for Batch Triples.
/// </summary>
/// <param name="obj">Object to test.</param>
/// <returns></returns>
public override bool Equals(object obj)
{
if (obj is BatchTriple)
{
BatchTriple other = (BatchTriple)obj;
return(_graphID == other.GraphID && _t.Equals(other.Triple));
}
else
{
return(false);
}
}
/// <summary>
/// Merges multiple ResultObjects of different categories to a single list of ContentObjects.
/// The merge is based on a set of weights.
/// </summary>
/// <param name="results">An array of different ResultObjects for several categories</param>
/// <param name="ratio">An array with weights for the different categories in the results array</param>
/// <returns>A list of ContentObjects where the content's value is the weighted score per category. The list is sorted in descending order (the higher the value, the earlier in the list)</returns>
public List <ContentObject> Merge(ResultObject[] results, CategoryRatio ratio)
{
// Attetion! No sanity checks: Must be different result.categories, ratios must sum up to 1.
List <ContentObject> totalResults = new List <ContentObject>();
List <List <Triple> > scores = Prepare(results);
while (scores.Count > 0)
{
List <Triple> list = Pop(scores);
while (list.Count > 0)
{
Triple needle = Pop(list);
bool lonely = true;
foreach (List <Triple> haystack in scores)
{
int size = haystack.Count;
for (int i = 0; i < size; i++)
{
if (needle.Equals(haystack[i]))
{
Triple t = haystack[i];
totalResults.Add(MergeWeighted(needle.Key, new [] { needle.Score, t.Score }, new [] { ratio.GetRatio(needle.Category), ratio.GetRatio(t.Category) }));
haystack.Remove(t);
size--;
lonely = false;
}
}
}
if (lonely)
{
double weightedScore = needle.Score * ratio.GetRatio(needle.Category);
totalResults.Add(new ContentObject(needle.Key, weightedScore.ToString()));
}
}
}
totalResults.Sort((a, b) => - 1 * a.CompareTo(b));
return(totalResults);
}
/// <summary>
/// Determines whether this instance is equal to another given edge label.
/// </summary>
/// <param name="other">The other edge label to compare this instance to.</param>
/// <returns>
/// <c>true</c> if the given edge label is equal to this instance; otherwise, <c>false</c>.
/// </returns>
public bool Equals(EdgeLabel other)
{
//
// edge case for null values
if ((object)other == null)
{
return(false);
}
//
// two edge labels are equal if all items in both labels are equal
if (!m_left.Equals(other.m_left))
{
return(false);
}
if (!m_right.Equals(other.m_right))
{
return(false);
}
if (!m_sharedItem.Equals(other.m_sharedItem))
{
return(false);
}
if (!m_posLeft.Equals(other.m_posLeft))
{
return(false);
}
if (!m_posRight.Equals(other.m_posRight))
{
return(false);
}
return(true);
}
public static bool foundNodeMoreThanTriple(IGraph g, INode n, Triple triple)
{
var found = g.GetTriples(n);
int others = 0;
StringWriter sw = new StringWriter();
foreach (var t in found)
{
if (!triple.Equals(t))
{
others++;
}
sw.WriteLine("found " + t);
}
if (others > 0)
{
return(true);
}
string warning = string.Format("cant resolve list node {0} but found {1}", n, sw);
Warn(warning);
return(false);
}
public void Test_Equals_negative()
{
// two different numbers should not be equal
var tripOne = new Triple("12.3.4");
var tripTwo = new Triple("12.1.2");
Assert.IsFalse(tripOne.Equals(tripTwo));
Assert.IsFalse(tripTwo.Equals(tripOne));
tripOne = new Triple("1.2.3");
tripTwo = new Triple("2.4.6");
Assert.IsFalse(tripOne.Equals(tripTwo));
Assert.IsFalse(tripTwo.Equals(tripOne));
tripOne = new Triple("1.2.3");
tripTwo = new Triple("1.4.6");
Assert.IsFalse(tripOne.Equals(tripTwo));
Assert.IsFalse(tripTwo.Equals(tripOne));
tripOne = new Triple("1.2.3");
tripTwo = new Triple("1.2.6");
Assert.IsFalse(tripOne.Equals(tripTwo));
Assert.IsFalse(tripTwo.Equals(tripOne));
}
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 GenericComparable()
{
Triple <int, GOddEvenComparable, string> triple1, triple2;
triple1 = new Triple <int, GOddEvenComparable, string>(4, new GOddEvenComparable(7), "B");
triple2 = new Triple <int, GOddEvenComparable, string>(7, new GOddEvenComparable(3), "A");
Assert.IsTrue(triple1.CompareTo(triple2) < 0);
Assert.IsFalse(triple1.Equals(triple2));
Assert.IsFalse(triple1.GetHashCode() == triple2.GetHashCode());
triple1 = new Triple <int, GOddEvenComparable, string>(4, new GOddEvenComparable(7), "B");
triple2 = new Triple <int, GOddEvenComparable, string>(4, new GOddEvenComparable(2), "A");
Assert.IsTrue(triple1.CompareTo(triple2) < 0);
Assert.IsFalse(triple1.Equals(triple2));
Assert.IsFalse(triple1.GetHashCode() == triple2.GetHashCode());
triple1 = new Triple <int, GOddEvenComparable, string>(4, new GOddEvenComparable(7), "A");
triple2 = new Triple <int, GOddEvenComparable, string>(4, new GOddEvenComparable(7), "A");
Assert.IsTrue(triple1.CompareTo(triple2) == 0);
Assert.IsTrue(triple1.Equals(triple2));
Assert.IsTrue(triple1.GetHashCode() == triple2.GetHashCode());
triple1 = new Triple <int, GOddEvenComparable, string>(7, new GOddEvenComparable(7), "B");
triple2 = new Triple <int, GOddEvenComparable, string>(4, new GOddEvenComparable(2), "C");
Assert.IsTrue(triple1.CompareTo(triple2) > 0);
Assert.IsFalse(triple1.Equals(triple2));
Assert.IsFalse(triple1.GetHashCode() == triple2.GetHashCode());
triple1 = new Triple <int, GOddEvenComparable, string>(0, new GOddEvenComparable(8), "A");
triple2 = new Triple <int, GOddEvenComparable, string>(0, new GOddEvenComparable(2), "A");
Assert.IsTrue(triple1.CompareTo(triple2) > 0);
Assert.IsFalse(triple1.Equals(triple2));
Assert.IsFalse(triple1.GetHashCode() == triple2.GetHashCode());
Triple <GOddEvenComparable, int, string> triple3, triple4;
triple3 = new Triple <GOddEvenComparable, int, string>(new GOddEvenComparable(7), 4, "A");
triple4 = new Triple <GOddEvenComparable, int, string>(new GOddEvenComparable(3), 7, "B");
Assert.IsTrue(triple3.CompareTo(triple4) > 0);
Assert.IsFalse(triple3.Equals(triple4));
Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());
triple3 = new Triple <GOddEvenComparable, int, string>(new GOddEvenComparable(7), 4, "B");
triple4 = new Triple <GOddEvenComparable, int, string>(new GOddEvenComparable(2), 4, "A");
Assert.IsTrue(triple3.CompareTo(triple4) < 0);
Assert.IsFalse(triple3.Equals(triple4));
Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());
triple3 = new Triple <GOddEvenComparable, int, string>(new GOddEvenComparable(7), 4, "C");
triple4 = new Triple <GOddEvenComparable, int, string>(new GOddEvenComparable(7), 4, "C");
Assert.IsTrue(triple3.CompareTo(triple4) == 0);
Assert.IsTrue(triple3.Equals(triple4));
Assert.IsTrue(triple3.GetHashCode() == triple4.GetHashCode());
triple3 = new Triple <GOddEvenComparable, int, string>(new GOddEvenComparable(2), 7, "A");
triple4 = new Triple <GOddEvenComparable, int, string>(new GOddEvenComparable(7), 4, "B");
Assert.IsTrue(triple3.CompareTo(triple4) > 0);
Assert.IsFalse(triple3.Equals(triple4));
Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());
triple3 = new Triple <GOddEvenComparable, int, string>(new GOddEvenComparable(8), 0, "A");
triple4 = new Triple <GOddEvenComparable, int, string>(new GOddEvenComparable(2), 0, "A");
Assert.IsTrue(triple3.CompareTo(triple4) > 0);
Assert.IsFalse(triple3.Equals(triple4));
Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());
triple3 = new Triple <GOddEvenComparable, int, string>(new GOddEvenComparable(2), 4, "A");
triple4 = new Triple <GOddEvenComparable, int, string>(new GOddEvenComparable(2), 3, "B");
Assert.IsTrue(triple3.CompareTo(triple4) > 0);
Assert.IsFalse(triple3.Equals(triple4));
Assert.IsFalse(triple3.GetHashCode() == triple4.GetHashCode());
Triple <int, string, GOddEvenComparable> triple5, triple6;
triple5 = new Triple <int, string, GOddEvenComparable>(4, "B", new GOddEvenComparable(7));
triple6 = new Triple <int, string, GOddEvenComparable>(7, "A", new GOddEvenComparable(3));
Assert.IsTrue(triple5.CompareTo(triple6) < 0);
Assert.IsFalse(triple5.Equals(triple6));
Assert.IsFalse(triple5.GetHashCode() == triple6.GetHashCode());
triple5 = new Triple <int, string, GOddEvenComparable>(4, "A", new GOddEvenComparable(7));
triple6 = new Triple <int, string, GOddEvenComparable>(4, "A", new GOddEvenComparable(2));
Assert.IsTrue(triple5.CompareTo(triple6) < 0);
Assert.IsFalse(triple5.Equals(triple6));
Assert.IsFalse(triple5.GetHashCode() == triple6.GetHashCode());
triple5 = new Triple <int, string, GOddEvenComparable>(4, "A", new GOddEvenComparable(7));
triple6 = new Triple <int, string, GOddEvenComparable>(4, "A", new GOddEvenComparable(7));
Assert.IsTrue(triple5.CompareTo(triple6) == 0);
Assert.IsTrue(triple5.Equals(triple6));
Assert.IsTrue(triple5.GetHashCode() == triple6.GetHashCode());
triple5 = new Triple <int, string, GOddEvenComparable>(7, "B", new GOddEvenComparable(7));
triple6 = new Triple <int, string, GOddEvenComparable>(4, "C", new GOddEvenComparable(2));
Assert.IsTrue(triple5.CompareTo(triple6) > 0);
Assert.IsFalse(triple5.Equals(triple6));
Assert.IsFalse(triple5.GetHashCode() == triple6.GetHashCode());
triple5 = new Triple <int, string, GOddEvenComparable>(0, "A", new GOddEvenComparable(8));
triple6 = new Triple <int, string, GOddEvenComparable>(0, "A", new GOddEvenComparable(2));
Assert.IsTrue(triple5.CompareTo(triple6) > 0);
Assert.IsFalse(triple5.Equals(triple6));
Assert.IsFalse(triple5.GetHashCode() == triple6.GetHashCode());
}
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.AreNotEqual(u.GetHashCode(), l.GetHashCode());
Assert.AreNotEqual(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.AreNotEqual(plain.GetHashCode(), typed.GetHashCode());
Assert.AreNotEqual(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.AreNotEqual(t1.GetHashCode(), t2.GetHashCode());
Assert.AreNotEqual(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.AreNotEqual(t1.GetHashCode(), t2.GetHashCode());
Assert.AreNotEqual(t1, t2);
}