mirror of
https://github.com/ICDSystems/ICD.Common.Utils.git
synced 2026-01-11 19:44:55 +00:00
318 lines
10 KiB
C#
318 lines
10 KiB
C#
using NUnit.Framework;
|
|
using System;
|
|
using System.Linq;
|
|
|
|
namespace ICD.Common.Utils.Tests
|
|
{
|
|
[TestFixture]
|
|
public sealed class EnumUtilsTest
|
|
{
|
|
public enum eTestEnum
|
|
{
|
|
None = 0,
|
|
A = 1,
|
|
B = 2,
|
|
C = 3,
|
|
}
|
|
|
|
[Flags]
|
|
public enum eTestFlagsEnum
|
|
{
|
|
None = 0,
|
|
A = 1,
|
|
B = 2,
|
|
C = 4,
|
|
D = 32,
|
|
BandC = B | C
|
|
}
|
|
|
|
[Test]
|
|
public void GetValuesTest()
|
|
{
|
|
eTestEnum[] values = EnumUtils.GetValues<eTestEnum>().ToArray();
|
|
|
|
Assert.AreEqual(4, values.Length);
|
|
Assert.AreEqual(eTestEnum.None, values[0]);
|
|
Assert.AreEqual(eTestEnum.A, values[1]);
|
|
Assert.AreEqual(eTestEnum.B, values[2]);
|
|
Assert.AreEqual(eTestEnum.C, values[3]);
|
|
}
|
|
|
|
[Test]
|
|
public void IsEnumTypeGenericTest()
|
|
{
|
|
Assert.IsTrue(EnumUtils.IsEnumType<eTestEnum>());
|
|
Assert.IsTrue(EnumUtils.IsEnumType<eTestFlagsEnum>());
|
|
Assert.IsTrue(EnumUtils.IsEnumType<Enum>());
|
|
Assert.IsFalse(EnumUtils.IsEnumType<EnumUtilsTest>());
|
|
}
|
|
|
|
[Test]
|
|
public void IsEnumTest()
|
|
{
|
|
Assert.IsTrue(EnumUtils.IsEnum(eTestEnum.A));
|
|
Assert.IsTrue(EnumUtils.IsEnum(eTestFlagsEnum.A));
|
|
Assert.IsTrue(EnumUtils.IsEnum(eTestEnum.A as object));
|
|
Assert.IsTrue(EnumUtils.IsEnum(eTestEnum.A as Enum));
|
|
Assert.IsFalse(EnumUtils.IsEnum<Enum>(null));
|
|
Assert.IsFalse(EnumUtils.IsEnum(""));
|
|
}
|
|
|
|
[Test]
|
|
public void IsDefinedTest()
|
|
{
|
|
Assert.IsFalse(EnumUtils.IsDefined((eTestEnum)20));
|
|
Assert.IsTrue(EnumUtils.IsDefined((eTestEnum)2));
|
|
|
|
Assert.IsFalse(EnumUtils.IsDefined((eTestFlagsEnum)8));
|
|
Assert.IsTrue(EnumUtils.IsDefined((eTestFlagsEnum)3));
|
|
}
|
|
|
|
#region Values
|
|
|
|
[Test]
|
|
public void GetNamesTest()
|
|
{
|
|
string[] names = EnumUtils.GetNames<eTestEnum>().ToArray();
|
|
|
|
Assert.AreEqual(4, names.Length);
|
|
Assert.IsTrue(names.Contains("None"));
|
|
Assert.IsTrue(names.Contains("A"));
|
|
Assert.IsTrue(names.Contains("B"));
|
|
Assert.IsTrue(names.Contains("C"));
|
|
}
|
|
|
|
[Test]
|
|
public void GetValuesGenericTest()
|
|
{
|
|
eTestEnum[] values = EnumUtils.GetValues<eTestEnum>().ToArray();
|
|
|
|
Assert.AreEqual(4, values.Length);
|
|
Assert.IsTrue(values.Contains(eTestEnum.None));
|
|
Assert.IsTrue(values.Contains(eTestEnum.A));
|
|
Assert.IsTrue(values.Contains(eTestEnum.B));
|
|
Assert.IsTrue(values.Contains(eTestEnum.C));
|
|
}
|
|
|
|
[Test]
|
|
public void GetValuesExceptNoneGenericTest()
|
|
{
|
|
eTestEnum[] values = EnumUtils.GetValuesExceptNone<eTestEnum>().ToArray();
|
|
|
|
Assert.AreEqual(3, values.Length);
|
|
Assert.IsFalse(values.Contains(eTestEnum.None));
|
|
Assert.IsTrue(values.Contains(eTestEnum.A));
|
|
Assert.IsTrue(values.Contains(eTestEnum.B));
|
|
Assert.IsTrue(values.Contains(eTestEnum.C));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Flags
|
|
|
|
[Test]
|
|
public void IsFlagsEnumGenericTest()
|
|
{
|
|
Assert.IsFalse(EnumUtils.IsFlagsEnum<eTestEnum>());
|
|
Assert.IsTrue(EnumUtils.IsFlagsEnum<eTestFlagsEnum>());
|
|
}
|
|
|
|
[Test]
|
|
public void GetFlagsIntersectionGenericTest()
|
|
{
|
|
Assert.AreEqual(eTestFlagsEnum.B,
|
|
EnumUtils.GetFlagsIntersection(eTestFlagsEnum.A | eTestFlagsEnum.B,
|
|
eTestFlagsEnum.B | eTestFlagsEnum.C));
|
|
}
|
|
|
|
[Test]
|
|
public void GetFlagsGenericTest()
|
|
{
|
|
eTestFlagsEnum a = EnumUtils.GetFlagsAllValue<eTestFlagsEnum>();
|
|
eTestFlagsEnum[] aValues = EnumUtils.GetFlags(a).ToArray();
|
|
|
|
Assert.AreEqual(5, aValues.Length);
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.None));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.B));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.C));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.D));
|
|
}
|
|
|
|
[Test]
|
|
public void GetFlagsExceptNoneGenericTest()
|
|
{
|
|
eTestFlagsEnum a = EnumUtils.GetFlagsAllValue<eTestFlagsEnum>();
|
|
eTestFlagsEnum[] aValues = EnumUtils.GetFlagsExceptNone(a).ToArray();
|
|
|
|
Assert.AreEqual(4, aValues.Length);
|
|
Assert.IsFalse(aValues.Contains(eTestFlagsEnum.None));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.B));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.C));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.D));
|
|
}
|
|
|
|
[Test]
|
|
public void GetAllFlagCombinationsExceptNoneGenericTest()
|
|
{
|
|
eTestFlagsEnum a = eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.C | eTestFlagsEnum.D;
|
|
eTestFlagsEnum[] aValues = EnumUtils.GetAllFlagCombinationsExceptNone(a).ToArray();
|
|
|
|
Assert.AreEqual(15, aValues.Length);
|
|
Assert.IsFalse(aValues.Contains(eTestFlagsEnum.None));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.B));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.C));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.D));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A | eTestFlagsEnum.B));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A | eTestFlagsEnum.C));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A | eTestFlagsEnum.D));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.B | eTestFlagsEnum.C));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.B | eTestFlagsEnum.D));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.C | eTestFlagsEnum.D));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.C));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.D));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A | eTestFlagsEnum.C | eTestFlagsEnum.D));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.B | eTestFlagsEnum.C | eTestFlagsEnum.D));
|
|
Assert.IsTrue(aValues.Contains(eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.C | eTestFlagsEnum.D));
|
|
}
|
|
|
|
[Test]
|
|
public void GetFlagsAllValueGenericTest()
|
|
{
|
|
eTestFlagsEnum value = EnumUtils.GetFlagsAllValue<eTestFlagsEnum>();
|
|
Assert.AreEqual(eTestFlagsEnum.None | eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.C | eTestFlagsEnum.D,
|
|
value);
|
|
}
|
|
|
|
[TestCase(eTestFlagsEnum.A, eTestFlagsEnum.B | eTestFlagsEnum.C | eTestFlagsEnum.D)]
|
|
[TestCase(eTestFlagsEnum.BandC, eTestFlagsEnum.A | eTestFlagsEnum.D)]
|
|
[TestCase(eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.C | eTestFlagsEnum.D, eTestFlagsEnum.None)]
|
|
[TestCase(eTestFlagsEnum.None, eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.C | eTestFlagsEnum.D)]
|
|
[TestCase(eTestFlagsEnum.D, eTestFlagsEnum.A | eTestFlagsEnum.BandC)]
|
|
public void GetInverseFlagsTest(eTestFlagsEnum expected, eTestFlagsEnum value)
|
|
{
|
|
Assert.AreEqual(expected, EnumUtils.GetInverseFlags(value));
|
|
}
|
|
|
|
[Test]
|
|
public void HasFlagGenericTest()
|
|
{
|
|
Assert.IsTrue(EnumUtils.HasFlag(eTestFlagsEnum.A | eTestFlagsEnum.B, eTestFlagsEnum.A));
|
|
Assert.IsFalse(EnumUtils.HasFlag(eTestFlagsEnum.A | eTestFlagsEnum.B, eTestFlagsEnum.C));
|
|
}
|
|
|
|
[Test]
|
|
public void HasFlagsGenericTest()
|
|
{
|
|
Assert.IsTrue(EnumUtils.HasFlags(eTestFlagsEnum.A | eTestFlagsEnum.B, eTestFlagsEnum.A | eTestFlagsEnum.B));
|
|
Assert.IsFalse(EnumUtils.HasFlags(eTestFlagsEnum.A | eTestFlagsEnum.B,
|
|
eTestFlagsEnum.A | eTestFlagsEnum.C));
|
|
}
|
|
|
|
[Test]
|
|
public void HasSingleFlagGenericTest()
|
|
{
|
|
Assert.IsTrue(EnumUtils.HasSingleFlag(eTestFlagsEnum.A));
|
|
Assert.IsFalse(EnumUtils.HasSingleFlag(eTestFlagsEnum.None));
|
|
Assert.IsFalse(EnumUtils.HasSingleFlag(eTestFlagsEnum.A | eTestFlagsEnum.B));
|
|
}
|
|
|
|
[Test]
|
|
public void HasMultipleFlagsGenericTest()
|
|
{
|
|
Assert.IsFalse(EnumUtils.HasMultipleFlags(eTestFlagsEnum.A));
|
|
Assert.IsFalse(EnumUtils.HasMultipleFlags(eTestFlagsEnum.None));
|
|
Assert.IsTrue(EnumUtils.HasMultipleFlags(eTestFlagsEnum.A | eTestFlagsEnum.B));
|
|
}
|
|
|
|
[TestCase(false, eTestFlagsEnum.None)]
|
|
[TestCase(true, eTestFlagsEnum.B)]
|
|
[TestCase(true, eTestFlagsEnum.B | eTestFlagsEnum.C)]
|
|
public void HasAnyFlagsTest(bool expected, eTestFlagsEnum value)
|
|
{
|
|
Assert.AreEqual(expected, EnumUtils.HasAnyFlags(value));
|
|
}
|
|
|
|
[TestCase(false, eTestFlagsEnum.None, eTestFlagsEnum.None)]
|
|
[TestCase(false, eTestFlagsEnum.None, eTestFlagsEnum.B)]
|
|
[TestCase(true, eTestFlagsEnum.B, eTestFlagsEnum.B)]
|
|
[TestCase(false, eTestFlagsEnum.None | eTestFlagsEnum.A, eTestFlagsEnum.B | eTestFlagsEnum.C)]
|
|
public void HasAnyFlagsValueTest(bool expected, eTestFlagsEnum value, eTestFlagsEnum other)
|
|
{
|
|
Assert.AreEqual(expected, EnumUtils.HasAnyFlags(value, other));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Conversion
|
|
|
|
[Test]
|
|
public void ParseGenericTest()
|
|
{
|
|
Assert.AreEqual(eTestEnum.A, EnumUtils.Parse<eTestEnum>("A", false));
|
|
Assert.AreEqual(eTestEnum.A, EnumUtils.Parse<eTestEnum>("a", true));
|
|
}
|
|
|
|
[Test]
|
|
public void TryParseGenericTest()
|
|
{
|
|
eTestEnum output;
|
|
|
|
Assert.IsTrue(EnumUtils.TryParse("A", false, out output));
|
|
Assert.AreEqual(eTestEnum.A, output);
|
|
|
|
Assert.IsTrue(EnumUtils.TryParse("a", true, out output));
|
|
Assert.AreEqual(eTestEnum.A, output);
|
|
|
|
Assert.IsFalse(EnumUtils.TryParse("derp", true, out output));
|
|
Assert.AreEqual(default(eTestEnum), output);
|
|
}
|
|
|
|
[Test]
|
|
public void ParseStrictGenericTest()
|
|
{
|
|
Assert.AreEqual(eTestEnum.A, EnumUtils.ParseStrict<eTestEnum>("1", false));
|
|
Assert.Throws<ArgumentOutOfRangeException>(() => EnumUtils.ParseStrict<eTestEnum>("4", false));
|
|
|
|
Assert.AreEqual(eTestFlagsEnum.A | eTestFlagsEnum.B, EnumUtils.ParseStrict<eTestFlagsEnum>("3", false));
|
|
Assert.Throws<ArgumentOutOfRangeException>(() => EnumUtils.ParseStrict<eTestFlagsEnum>("8", false));
|
|
}
|
|
|
|
[Test]
|
|
public void TryParseStrictGenericTest()
|
|
{
|
|
eTestEnum outputA;
|
|
|
|
Assert.AreEqual(true, EnumUtils.TryParseStrict("1", false, out outputA));
|
|
Assert.AreEqual(eTestEnum.A, outputA);
|
|
|
|
Assert.AreEqual(false, EnumUtils.TryParseStrict("4", false, out outputA));
|
|
Assert.AreEqual(eTestEnum.None, outputA);
|
|
|
|
eTestFlagsEnum outputB;
|
|
|
|
Assert.AreEqual(true, EnumUtils.TryParseStrict("3", false, out outputB));
|
|
Assert.AreEqual(eTestFlagsEnum.A | eTestFlagsEnum.B, outputB);
|
|
|
|
Assert.AreEqual(false, EnumUtils.TryParseStrict("8", false, out outputB));
|
|
Assert.AreEqual(eTestFlagsEnum.None, outputB);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Formatting
|
|
|
|
[TestCase(eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.C | (eTestFlagsEnum)8,
|
|
"A, B, C, 8")]
|
|
public void ToStringUndefinedTest(eTestFlagsEnum value, string expected)
|
|
{
|
|
string toString = EnumUtils.ToStringUndefined(value);
|
|
Assert.AreEqual(expected, toString);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|