diff --git a/ICD.Common.Utils.Tests/EnumUtilsTest.cs b/ICD.Common.Utils.Tests/EnumUtilsTest.cs
index e5031b6..e829ff5 100644
--- a/ICD.Common.Utils.Tests/EnumUtilsTest.cs
+++ b/ICD.Common.Utils.Tests/EnumUtilsTest.cs
@@ -1,5 +1,6 @@
 using NUnit.Framework;
 using System;
+using System.Linq;
 
 namespace ICD.Common.Utils.Tests_NetStandard
 {
@@ -8,15 +9,26 @@ namespace ICD.Common.Utils.Tests_NetStandard
     {
 		private enum eTestEnum
 		{
-			A, 
-			B,
-			C
+			None = 0,
+			A = 1, 
+			B = 2,
+			C = 3,
+		}
+
+		[Flags]
+		private enum eTestFlagsEnum
+		{
+			None = 0,
+			A = 1,
+			B = 2,
+			C = 4
 		}
 
 		[Test]
 		public void IsEnumTypeTest()
 		{
 			Assert.IsTrue(EnumUtils.IsEnumType(typeof(eTestEnum)));
+			Assert.IsTrue(EnumUtils.IsEnumType(typeof(eTestFlagsEnum)));
 			Assert.IsTrue(EnumUtils.IsEnumType(typeof(Enum)));
 			Assert.IsFalse(EnumUtils.IsEnumType(typeof(EnumUtilsTest)));
 			Assert.Throws<ArgumentNullException>(() => EnumUtils.IsEnumType(null));
@@ -26,6 +38,7 @@ namespace ICD.Common.Utils.Tests_NetStandard
 		public void IsEnumTypeGenericTest()
 		{
 			Assert.IsTrue(EnumUtils.IsEnumType<eTestEnum>());
+			Assert.IsTrue(EnumUtils.IsEnumType<eTestFlagsEnum>());
 			Assert.IsTrue(EnumUtils.IsEnumType<Enum>());
 			Assert.IsFalse(EnumUtils.IsEnumType<EnumUtilsTest>());
 		}
@@ -34,6 +47,7 @@ namespace ICD.Common.Utils.Tests_NetStandard
 		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(null));
@@ -45,37 +59,65 @@ namespace ICD.Common.Utils.Tests_NetStandard
 		[Test]
 		public void GetUnderlyingValueTest()
 		{
-			Assert.Inconclusive();
+			Assert.AreEqual(0, EnumUtils.GetUnderlyingValue(eTestEnum.None));
+			Assert.AreEqual(1, EnumUtils.GetUnderlyingValue(eTestEnum.A));
+			Assert.AreEqual(2, EnumUtils.GetUnderlyingValue(eTestEnum.B));
+			Assert.AreEqual(3, EnumUtils.GetUnderlyingValue(eTestEnum.C));
 		}
 
 		[Test]
 		public void GetValuesGenericTest()
 		{
-			Assert.Inconclusive();
+			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 GetValuesTest()
 		{
-			Assert.Inconclusive();
+			object[] values = EnumUtils.GetValues(typeof(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 GetNoneValueGenericTest()
 		{
-			Assert.Inconclusive();
+			Assert.AreEqual(eTestEnum.None, EnumUtils.GetNoneValue<eTestEnum>());
+			Assert.AreEqual(eTestFlagsEnum.None, EnumUtils.GetNoneValue<eTestFlagsEnum>());
 		}
 
 		[Test]
 		public void GetValuesExceptNoneGenericTest()
 		{
-			Assert.Inconclusive();
+			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));
 		}
 
 		[Test]
 		public void GetValuesExceptNoneTest()
 		{
-			Assert.Inconclusive();
+			object[] values = EnumUtils.GetValuesExceptNone(typeof(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
@@ -85,61 +127,84 @@ namespace ICD.Common.Utils.Tests_NetStandard
 		[Test]
 		public void IsFlagsEnumGenericTest()
 		{
-			Assert.Inconclusive();
+			Assert.IsFalse(EnumUtils.IsFlagsEnum<eTestEnum>());
+			Assert.IsTrue(EnumUtils.IsFlagsEnum<eTestFlagsEnum>());
 		}
 
 		[Test]
 		public void IsFlagsEnumTest()
 		{
-			Assert.Inconclusive();
+			Assert.IsFalse(EnumUtils.IsFlagsEnum(typeof(eTestEnum)));
+			Assert.IsTrue(EnumUtils.IsFlagsEnum(typeof(eTestFlagsEnum)));
 		}
 
 		[Test]
 		public void GetFlagsIntersectionGenericTest()
 		{
-			Assert.Inconclusive();
+			Assert.AreEqual(eTestFlagsEnum.B, EnumUtils.GetFlagsIntersection(eTestFlagsEnum.A | eTestFlagsEnum.B, eTestFlagsEnum.B | eTestFlagsEnum.C));
 		}
 
 		[Test]
 		public void GetFlagsGenericTest()
 		{
-			Assert.Inconclusive();
+			eTestFlagsEnum a = EnumUtils.GetFlagsAllValue<eTestFlagsEnum>();
+			eTestFlagsEnum[] aValues = EnumUtils.GetFlags(a).ToArray();
+
+			Assert.AreEqual(4, 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));
 		}
 
 		[Test]
 		public void GetFlagsExceptNoneGenericTest()
 		{
-			Assert.Inconclusive();
+			eTestFlagsEnum a = EnumUtils.GetFlagsAllValue<eTestFlagsEnum>();
+			eTestFlagsEnum[] aValues = EnumUtils.GetFlagsExceptNone(a).ToArray();
+
+			Assert.AreEqual(3, 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));
 		}
 
 		[Test]
 		public void GetFlagsAllValueGenericTest()
 		{
-			Assert.Inconclusive();
+			eTestFlagsEnum value = EnumUtils.GetFlagsAllValue<eTestFlagsEnum>();
+			Assert.AreEqual(eTestFlagsEnum.None | eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.C, value);
 		}
 
 		[Test]
 		public void HasFlagGenericTest()
 		{
-			Assert.Inconclusive();
+			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.Inconclusive();
+			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.Inconclusive();
+			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.Inconclusive();
+			Assert.IsFalse(EnumUtils.HasMultipleFlags(eTestFlagsEnum.A));
+			Assert.IsFalse(EnumUtils.HasMultipleFlags(eTestFlagsEnum.None));
+			Assert.IsTrue(EnumUtils.HasMultipleFlags(eTestFlagsEnum.A | eTestFlagsEnum.B));
 		}
 
 		#endregion
@@ -149,25 +214,37 @@ namespace ICD.Common.Utils.Tests_NetStandard
 		[Test]
 		public void ParseGenericTest()
 		{
-			Assert.Inconclusive();
+			Assert.AreEqual(eTestEnum.A, EnumUtils.Parse<eTestEnum>("A", false));
+			Assert.AreEqual(eTestEnum.A, EnumUtils.Parse<eTestEnum>("a", true));
 		}
 
 		[Test]
 		public void TryParseGenericTest()
 		{
-			Assert.Inconclusive();
+			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 ToEnumGenericTest()
 		{
-			Assert.Inconclusive();
+			Assert.AreEqual(eTestEnum.A, EnumUtils.ToEnum(eTestEnum.A));
+			Assert.AreNotEqual(eTestEnum.B, EnumUtils.ToEnum(eTestEnum.A));
 		}
 
 		[Test]
 		public void ToEnumTest()
 		{
-			Assert.Inconclusive();
+			Assert.AreEqual(eTestEnum.A, EnumUtils.ToEnum((object)eTestEnum.A));
+			Assert.AreNotEqual(eTestEnum.B, EnumUtils.ToEnum((object)eTestEnum.A));
 		}
 
 		#endregion