public static int GetHashCode <T>(T[] a)
{
if (a == null)
{
return(0);
}
int result = 1;
bool isValueType = typeof(T).GetTypeInfo().IsValueType;
foreach (var item in a)
{
result = 31 * result + (item == null ? 0 :
// LUCENENET specific: if this is a reference type, pass to
// Collections.GetHashCode() in case we have an array of collections
(isValueType ? item.GetHashCode() : Collections.GetHashCode(item)));
}
return(result);
}
/// <summary>
/// Returns the hash code value for this list.
/// <para/>
/// The hash code determination takes into consideration any values in
/// this collection and values of any nested collections, but does not
/// take into consideration the data type. Therefore, the hash codes will
/// be exactly the same for this <see cref="EquatableSet{T}"/> and another
/// <see cref="ISet{T}"/> with the same values (in any order).
/// </summary>
/// <returns>the hash code value for this list</returns>
public override int GetHashCode()
{
return(Collections.GetHashCode(this));
}
public void TestEqualitySet()
{
var control = new HashSet <IDictionary <string, string> >
{
new Dictionary <string, string> {
{ "1", "one" }, { "2", "two" }, { "3", "three" }
},
new Dictionary <string, string> {
{ "4", "four" }, { "5", "five" }, { "6", "six" }
},
new Dictionary <string, string> {
{ "7", "seven" }, { "8", "eight" }, { "9", "nine" }
},
};
var equal = new HashSet <IDictionary <string, string> >
{
new Dictionary <string, string> {
{ "1", "one" }, { "2", "two" }, { "3", "three" }
},
new Dictionary <string, string> {
{ "4", "four" }, { "5", "five" }, { "6", "six" }
},
new Dictionary <string, string> {
{ "7", "seven" }, { "8", "eight" }, { "9", "nine" }
},
};
var equalDifferentType = new MockHashSet <IDictionary <string, string> >
{
new Dictionary <string, string> {
{ "1", "one" }, { "2", "two" }, { "3", "three" }
},
new Dictionary <string, string> {
{ "4", "four" }, { "5", "five" }, { "6", "six" }
},
new Dictionary <string, string> {
{ "7", "seven" }, { "8", "eight" }, { "9", "nine" }
},
};
var equalDifferentOrder = new HashSet <IDictionary <string, string> >
{
new Dictionary <string, string> {
{ "7", "seven" }, { "8", "eight" }, { "9", "nine" }
},
new Dictionary <string, string> {
{ "1", "one" }, { "2", "two" }, { "3", "three" }
},
new Dictionary <string, string> {
{ "4", "four" }, { "5", "five" }, { "6", "six" }
},
};
var level1EqualLevel2Unequal = new HashSet <IDictionary <string, string> >
{
new Dictionary <string, string> {
{ "1", "one" }, { "2", "two" }, { "3", "three" }
},
new Dictionary <string, string> {
{ "4", "four" }, { "5", "five" }, { "6", "six" }
},
new Dictionary <string, string> {
{ "7", "seven" }, { "8", "eight" }, { "9", "nine99" }
},
};
Assert.AreEqual(Collections.GetHashCode(control), Collections.GetHashCode(control));
Assert.IsTrue(Collections.Equals(control, control));
Assert.AreEqual(Collections.GetHashCode(control), Collections.GetHashCode(equal));
Assert.IsTrue(Collections.Equals(control, equal));
Assert.AreEqual(Collections.GetHashCode(control), Collections.GetHashCode(equalDifferentType));
Assert.IsTrue(Collections.Equals(control, equalDifferentType));
// Sets are not order-sensitive
Assert.AreEqual(Collections.GetHashCode(control), Collections.GetHashCode(equalDifferentOrder));
Assert.IsTrue(Collections.Equals(control, equalDifferentOrder));
Assert.AreNotEqual(Collections.GetHashCode(control), Collections.GetHashCode(level1EqualLevel2Unequal));
Assert.IsFalse(Collections.Equals(control, level1EqualLevel2Unequal));
}
public void TestEqualityDictionary()
{
var control = new Dictionary <string, IDictionary <HashMap <long, double>, string> >
{
{ "a", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 123, 9.87 }, { 80, 88 }
}, "qwerty" }
} },
{ "z", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 456, 9.86 }, { 81, 88 }
}, "hexagon" }
} },
{ "r", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 789, 9.85 }, { 82, 88 }
}, "parasite" }
} },
{ "t", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 101, 9.84 }, { 83, 88 }
}, "octopus" }
} },
};
var equal = new Dictionary <string, IDictionary <HashMap <long, double>, string> >
{
{ "a", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 123, 9.87 }, { 80, 88 }
}, "qwerty" }
} },
{ "z", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 456, 9.86 }, { 81, 88 }
}, "hexagon" }
} },
{ "r", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 789, 9.85 }, { 82, 88 }
}, "parasite" }
} },
{ "t", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 101, 9.84 }, { 83, 88 }
}, "octopus" }
} },
};
var equalDifferentType = new HashMap <string, IDictionary <HashMap <long, double>, string> >
{
{ "a", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 123, 9.87 }, { 80, 88 }
}, "qwerty" }
} },
{ "z", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 456, 9.86 }, { 81, 88 }
}, "hexagon" }
} },
{ "r", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 789, 9.85 }, { 82, 88 }
}, "parasite" }
} },
{ "t", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 101, 9.84 }, { 83, 88 }
}, "octopus" }
} },
};
var equalDifferentOrder = new Dictionary <string, IDictionary <HashMap <long, double>, string> >
{
{ "r", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 789, 9.85 }, { 82, 88 }
}, "parasite" }
} },
{ "t", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 101, 9.84 }, { 83, 88 }
}, "octopus" }
} },
{ "a", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 123, 9.87 }, { 80, 88 }
}, "qwerty" }
} },
{ "z", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 456, 9.86 }, { 81, 88 }
}, "hexagon" }
} },
};
var level1EqualLevel2EqualLevel3Unequal = new Dictionary <string, IDictionary <HashMap <long, double>, string> >
{
{ "a", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 123, 9.87 }, { 80, 88.1 }
}, "qwerty" }
} },
{ "z", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 456, 9.86 }, { 81, 88 }
}, "hexagon" }
} },
{ "r", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 789, 9.85 }, { 82, 88 }
}, "parasite" }
} },
{ "t", new Dictionary <HashMap <long, double>, string> {
{ new HashMap <long, double> {
{ 101, 9.84 }, { 83, 88 }
}, "octopus" }
} },
};
Assert.AreEqual(Collections.GetHashCode(control), Collections.GetHashCode(control));
Assert.IsTrue(Collections.Equals(control, control));
Assert.AreEqual(Collections.GetHashCode(control), Collections.GetHashCode(equal));
Assert.IsTrue(Collections.Equals(control, equal));
Assert.AreEqual(Collections.GetHashCode(control), Collections.GetHashCode(equalDifferentType));
Assert.IsTrue(Collections.Equals(control, equalDifferentType));
Assert.AreEqual(Collections.GetHashCode(control), Collections.GetHashCode(equalDifferentOrder));
Assert.IsTrue(Collections.Equals(control, equalDifferentOrder));
Assert.AreNotEqual(Collections.GetHashCode(control), Collections.GetHashCode(level1EqualLevel2EqualLevel3Unequal));
Assert.IsFalse(Collections.Equals(control, level1EqualLevel2EqualLevel3Unequal));
}
public void TestEqualityListSimple()
{
var control = new List <IList <string> >
{
new List <string> {
"one", "two", "three"
},
new List <string> {
"four", "five", "six"
},
new List <string> {
"seven", "eight", "nine"
},
};
var equal = new List <IList <string> >
{
new List <string> {
"one", "two", "three"
},
new List <string> {
"four", "five", "six"
},
new List <string> {
"seven", "eight", "nine"
},
};
var equalDifferentType = new IList <string>[]
{
new List <string> {
"one", "two", "three"
},
new List <string> {
"four", "five", "six"
},
new List <string> {
"seven", "eight", "nine"
},
};
var equalDifferentOrder = new List <IList <string> >
{
new List <string> {
"four", "five", "six"
},
new List <string> {
"seven", "eight", "nine"
},
new List <string> {
"one", "two", "three"
},
};
var level1EqualLevel2Unequal = new List <IList <string> >
{
new List <string> {
"one", "two", "three"
},
new List <string> {
"four", "five", "six"
},
new List <string> {
"seven", "eight", "nine-nine"
},
};
Assert.AreEqual(Collections.GetHashCode(control), Collections.GetHashCode(control));
Assert.IsTrue(Collections.Equals(control, control));
Assert.AreEqual(Collections.GetHashCode(control), Collections.GetHashCode(equal));
Assert.IsTrue(Collections.Equals(control, equal));
Assert.AreEqual(Collections.GetHashCode(control), Collections.GetHashCode(equalDifferentType));
Assert.IsTrue(Collections.Equals(control, equalDifferentType));
// Lists and arrays are order - sensitive
Assert.AreNotEqual(Collections.GetHashCode(control), Collections.GetHashCode(equalDifferentOrder));
Assert.IsFalse(Collections.Equals(control, equalDifferentOrder));
Assert.AreNotEqual(Collections.GetHashCode(control), Collections.GetHashCode(level1EqualLevel2Unequal));
Assert.IsFalse(Collections.Equals(control, level1EqualLevel2Unequal));
}