public void TestEnumComparer_Int()
{
var comparer = Enum32EqualityComparer.Create <IntEnum>();
Assert.IsFalse(comparer.Equals(IntEnum.Value1, IntEnum.Value2));
Assert.IsTrue(comparer.Equals(IntEnum.Value3, IntEnum.Value3));
Assert.AreEqual((int)IntEnum.Value2, comparer.GetHashCode(IntEnum.Value2));
}
public void TestEnumComparer_Byte()
{
var comparer = Enum32EqualityComparer.Create <ByteEnum>();
Assert.IsFalse(comparer.Equals(ByteEnum.Value1, ByteEnum.Value2));
Assert.IsTrue(comparer.Equals(ByteEnum.Value3, ByteEnum.Value3));
EnumConverter.ToInt8(ByteEnum.Value3);
Assert.AreEqual((int)ByteEnum.Value2, comparer.GetHashCode(ByteEnum.Value2));
}
private static IEqualityComparer <T> EnumEqualityComparer <T>(Type type)
{
switch (Type.GetTypeCode(type))
{
case TypeCode.Int64:
case TypeCode.UInt64:
return(Enum64EqualityComparer.CreateUnsafe <T>());
default:
return(Enum32EqualityComparer.CreateUnsafe <T>());
}
}
/// <summary>
/// Registers an equality comparer for type T where T is an enumeration.
/// Note: Enumerations are handled automatically and do not need to be registered when JIT is enabled.
/// </summary>
public static void RegisterEnum <T>() where T : struct, IConvertible
{
var type = typeof(T);
if (type.IsEnum)
{
switch (Type.GetTypeCode(type))
{
case TypeCode.Int64:
case TypeCode.UInt64:
Register(Enum64EqualityComparer.Create <T>());
break;
default:
Register(Enum32EqualityComparer.Create <T>());
break;
}
}
else
{
SmoothLogger.LogError("Tried to register a non-enumeration type as an enumeration.");
}
}
public void TestEnumComparer_WrongType()
{
Assert.Throws <InvalidOperationException>(() => Enum32EqualityComparer.Create <int>());
}
