public void EnumComparerTest()
{
AdvancedComparer <Direction> comparer = AdvancedComparer <Direction> .System;
Assert.IsNotNull(comparer);
Assert.AreEqual("EnumComparer`2", comparer.Implementation.GetType().Name);
Assert.Greater(comparer.Compare(Direction.Positive, Direction.Negative), 0);
Assert.Greater(comparer.Compare(Direction.Positive, Direction.None), 0);
Assert.Less(comparer.Compare(Direction.Negative, Direction.Positive), 0);
Assert.Less(comparer.Compare(Direction.Negative, Direction.None), 0);
Assert.AreEqual(comparer.Compare(Direction.Positive, Direction.Positive), 0);
Assert.AreEqual(comparer.Compare(Direction.None, Direction.None), 0);
Assert.AreEqual(comparer.Compare(Direction.Negative, Direction.Negative), 0);
Assert.IsTrue(comparer.Equals(comparer.ValueRangeInfo.MaxValue, Direction.Positive));
Assert.IsTrue(comparer.Equals(comparer.ValueRangeInfo.MinValue, Direction.Negative));
Assert.IsFalse(comparer.Equals(Direction.Positive, Direction.Negative));
Assert.AreEqual(comparer.GetNearestValue(Direction.Negative, Direction.Negative), Direction.Negative);
Assert.AreEqual(comparer.GetNearestValue(Direction.Negative, Direction.Positive), Direction.None);
Assert.AreEqual(comparer.GetNearestValue(Direction.Positive, Direction.Negative), Direction.None);
Assert.AreEqual(comparer.GetNearestValue(Direction.Positive, Direction.Positive), Direction.Positive);
Assert.AreEqual(comparer.GetNearestValue(Direction.None, Direction.Negative), Direction.Negative);
Assert.AreEqual(comparer.GetNearestValue(Direction.None, Direction.Positive), Direction.Positive);
Assert.IsFalse(comparer.ValueRangeInfo.HasDeltaValue);
}
public double GetEqualityProbability <T>(Random r1, Random r2, int size)
{
IEnumerator <T> enumerator1 = InstanceGeneratorProvider.Default.GetInstanceGenerator <T>().GetInstances(r1, size).GetEnumerator();
IEnumerator <T> enumerator2 = InstanceGeneratorProvider.Default.GetInstanceGenerator <T>().GetInstances(r2, size).GetEnumerator();
AdvancedComparer <T> comparer = AdvancedComparer <T> .Default;
int equalCount = 0;
int totalCount = 0;
while (true)
{
bool isMoved1 = enumerator1.MoveNext();
bool isMoved2 = enumerator2.MoveNext();
if (isMoved1 != isMoved2)
{
return(0);
}
if (!isMoved1)
{
break;
}
totalCount++;
if (CheckIfEquals(comparer, enumerator1.Current, enumerator2.Current))
{
equalCount++;
}
}
return((totalCount == 0)?1:(double)equalCount / (double)totalCount);
}
public void SerializationTest()
{
AdvancedComparer <short> comparer = AdvancedComparer <short> .Default;
Assert.IsNotNull(comparer.Compare);
var deserializedComparer = Cloner.Clone(comparer);
Assert.IsNotNull(deserializedComparer.Compare);
}
public void CastingComparerTest()
{
Wrapper1 <int> o1 = new Wrapper1 <int>(1);
Wrapper1 <int> o2 = new Wrapper1 <int>(2);
AdvancedComparer <Wrapper <int> > comparer = AdvancedComparer <Wrapper1 <int> > .Default.Cast <Wrapper <int> >();
Assert.IsNotNull(comparer);
AssertEx.IsPatternMatch(comparer.Implementation.GetType().Name, "CastingComparer*");
Assert.Greater(comparer.Compare(o2, o1), 0);
}
public void InheritedComparerTest()
{
Wrapper2a <int, int> o1 = new Wrapper2a <int, int>(0, 1);
Wrapper2a <int, int> o2 = new Wrapper2a <int, int>(0, 2);
AdvancedComparer <Wrapper2a <int, int> > comparer = AdvancedComparer <Wrapper2a <int, int> > .Default;
Assert.IsNotNull(comparer);
AssertEx.IsPatternMatch(comparer.Implementation.GetType().Name, "BaseComparerWrapper*");
Assert.AreEqual(comparer.Compare(o2, o1), 0);
}
public void CustomComparerTest2()
{
Wrapper2 <int, int> o1 = new Wrapper2 <int, int>(0, 1);
Wrapper2 <int, int> o2 = new Wrapper2 <int, int>(0, 2);
AdvancedComparer <Wrapper2 <int, int> > comparer = AdvancedComparer <Wrapper2 <int, int> > .Default;
Assert.IsNotNull(comparer);
AssertEx.IsPatternMatch(comparer.Implementation.GetType().Name, "Wrapper2Comparer*");
Assert.Greater(comparer.Compare(o2, o1), 0);
}
private bool CheckIfEquals <T>(AdvancedComparer <T> comparer, T x, T y)
{
// Tuple is no longer implementation of IComparable
// so need to use Equals
if (x is Tuple)
{
return(comparer.Equals(x, y));
}
return(comparer.Compare(x, y) == 0);
}
public void StringComparerTest()
{
string o1 = "1";
string o2 = "2";
AdvancedComparer <string> comparer = AdvancedComparer <string> .Default;
Assert.IsNotNull(comparer);
AssertEx.IsPatternMatch(comparer.Implementation.GetType().Name, "StringComparer*");
Assert.IsFalse(comparer.Equals(o2, o1));
Assert.IsFalse(comparer.GetHashCode(o1) == comparer.GetHashCode(o2));
Assert.IsTrue(comparer.Equals("1", o1));
Assert.IsTrue(comparer.Equals("2", o2));
}
public void StringComparerTest()
{
string o1 = "1";
string o2 = "2";
AdvancedComparer <string> comparer = AdvancedComparer <string> .Default;
Assert.IsNotNull(comparer);
Assert.AreEqual("StringComparer", comparer.Implementation.GetType().Name);
Assert.Greater(comparer.Compare(o2, o1), 0);
Assert.IsTrue(comparer.ValueRangeInfo.HasMinValue);
Assert.IsFalse(comparer.ValueRangeInfo.HasMaxValue);
Assert.AreEqual(null, comparer.ValueRangeInfo.MinValue);
AssertEx.ThrowsInvalidOperationException(delegate { string s = comparer.ValueRangeInfo.MaxValue; });
char z = char.MaxValue;
char y = unchecked ((char)(char.MaxValue - 1));
char a = char.MinValue;
string str = "BCD";
str = comparer.GetNearestValue(str, Direction.Negative);
Assert.AreEqual("BCC" + z, str);
str = comparer.GetNearestValue(str, Direction.Negative);
Assert.AreEqual("BCC" + y + z, str);
str = comparer.GetNearestValue(str, Direction.Negative);
Assert.AreEqual("BCC" + y + y + z, str);
str = comparer.GetNearestValue(str, Direction.Positive);
Assert.AreEqual("BCC" + y + z, str);
str = comparer.GetNearestValue(str, Direction.Positive);
Assert.AreEqual("BCC" + z, str);
str = comparer.GetNearestValue(str, Direction.Positive);
Assert.AreEqual("BCD", str);
str = comparer.GetNearestValue(str, Direction.Positive);
Assert.AreEqual("BCD" + a, str);
str = comparer.GetNearestValue(str, Direction.Positive);
Assert.AreEqual("BCD" + a + a, str);
str = comparer.GetNearestValue(str, Direction.Negative);
Assert.AreEqual("BCD" + a, str);
str = comparer.GetNearestValue(str, Direction.Negative);
Assert.AreEqual("BCD", str);
Assert.IsNull(comparer.GetNearestValue(null, Direction.Negative));
Assert.IsNull(comparer.GetNearestValue(string.Empty, Direction.Negative));
Assert.AreEqual(string.Empty, comparer.GetNearestValue(null, Direction.Positive));
Assert.AreEqual(char.MaxValue.ToString(), comparer.GetNearestValue(char.MaxValue.ToString(), Direction.Positive));
AssertEx.Throws <ArgumentOutOfRangeException>(delegate { comparer.GetNearestValue(str, Direction.None); });
}
public void Int32ComparerTest()
{
int o1 = 1;
int o2 = 2;
AdvancedComparer <int> comparer = AdvancedComparer <int> .Default;
Assert.IsNotNull(comparer);
Assert.AreEqual("Int32Comparer", comparer.Implementation.GetType().Name);
Assert.Greater(comparer.Compare(o2, o1), 0);
Assert.IsTrue(comparer.ValueRangeInfo.HasMinValue);
Assert.IsTrue(comparer.ValueRangeInfo.HasMaxValue);
Assert.AreEqual(int.MinValue, comparer.ValueRangeInfo.MinValue);
Assert.AreEqual(int.MaxValue, comparer.ValueRangeInfo.MaxValue);
Assert.AreEqual(1, comparer.ValueRangeInfo.DeltaValue);
Assert.AreEqual(1, comparer.GetNearestValue(0, Direction.Positive));
Assert.AreEqual(0, comparer.GetNearestValue(1, Direction.Negative));
}
public void Int32ComparerTest()
{
int o1 = 1;
int o2 = 2;
Func <int, int> hash = delegate(int item) { return(item.GetHashCode()); };
long a = hash(o2);
Func <long, int> hash1 = delegate(long item) { return(item.GetHashCode()); };
long a1 = hash1(o2);
AdvancedComparer <int> comparer = AdvancedComparer <int> .Default;
Assert.IsNotNull(comparer);
AssertEx.IsPatternMatch(comparer.Implementation.GetType().Name, "Int32Comparer*");
Assert.IsFalse(comparer.Equals(o2, o1));
Assert.IsFalse(comparer.GetHashCode(o1) == comparer.GetHashCode(o2));
Assert.IsTrue(comparer.Equals(1, o1));
Assert.IsTrue(comparer.Equals(2, o2));
}
public void NullableComparerTest()
{
AdvancedComparer <int?> comparer = AdvancedComparer <int?> .Default;
Assert.IsNotNull(comparer);
Assert.AreEqual("NullableComparer`1", comparer.Implementation.GetType().Name);
Assert.Greater(comparer.Compare(10, 1), 0);
Assert.Less(comparer.Compare(1, 10), 0);
Assert.AreEqual(comparer.Compare(10, 10), 0);
Assert.Less(comparer.Compare(1, 10), 0);
Assert.Greater(comparer.Compare(10, 1), 0);
Assert.AreEqual(comparer.Compare(10, 10), 0);
Assert.Less(comparer.Compare(null, 10), 0);
Assert.AreEqual(comparer.Compare(null, null), 0);
Assert.Greater(comparer.Compare(10, null), 0);
Assert.IsTrue(comparer.ValueRangeInfo.HasMinValue);
Assert.IsTrue(comparer.ValueRangeInfo.HasMaxValue);
Assert.IsTrue(comparer.ValueRangeInfo.HasDeltaValue);
Assert.AreEqual(null, comparer.ValueRangeInfo.MinValue);
Assert.AreEqual(int.MaxValue, comparer.ValueRangeInfo.MaxValue);
Assert.AreEqual(1, comparer.ValueRangeInfo.DeltaValue);
}
