From 118814b54922b44be49922ba4feab6c29893efc8 Mon Sep 17 00:00:00 2001
From: Chris Cameron <chris.cameron@wedoresi.com>
Date: Thu, 6 Jul 2017 16:45:20 -0400
Subject: [PATCH 1/4] Excluding file from Net Standard project

---
 ICD.Common.Utils/ICD.Common.Utils_NetStandard.csproj | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ICD.Common.Utils/ICD.Common.Utils_NetStandard.csproj b/ICD.Common.Utils/ICD.Common.Utils_NetStandard.csproj
index 0f33e67..0e0686f 100644
--- a/ICD.Common.Utils/ICD.Common.Utils_NetStandard.csproj
+++ b/ICD.Common.Utils/ICD.Common.Utils_NetStandard.csproj
@@ -36,6 +36,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <None Remove="ICD.Common.projectinfo" />
     <None Remove="ICD.Common_SimplSharp.suo" />
     <None Remove="ICD.SimplSharp.projectinfo" />
   </ItemGroup>

From 76b4643f8c9b0a462cab1ea92cc9a56a23432fae Mon Sep 17 00:00:00 2001
From: Chris Cameron <chris.cameron@wedoresi.com>
Date: Fri, 7 Jul 2017 17:20:17 -0400
Subject: [PATCH 2/4] Initial commit of utils test project for Net Standard

---
 .../ICD.Common.Utils.Tests_NetStandard.csproj | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 ICD.Common.Utils.Tests/ICD.Common.Utils.Tests_NetStandard.csproj

diff --git a/ICD.Common.Utils.Tests/ICD.Common.Utils.Tests_NetStandard.csproj b/ICD.Common.Utils.Tests/ICD.Common.Utils.Tests_NetStandard.csproj
new file mode 100644
index 0000000..30b5a19
--- /dev/null
+++ b/ICD.Common.Utils.Tests/ICD.Common.Utils.Tests_NetStandard.csproj
@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp1.1</TargetFramework>
+  </PropertyGroup>
+  
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <DefineConstants>TRACE;DEBUG;STANDARD</DefineConstants>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <DefineConstants>TRACE;STANDARD</DefineConstants>
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
+    <PackageReference Include="NUnit" Version="3.7.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.8.0-alpha1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ICD.Common.Utils\ICD.Common.Utils_NetStandard.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
+  </ItemGroup>
+
+</Project>
\ No newline at end of file

From b84f95e48d1ace3f59b1855e6924b17b9aea63fc Mon Sep 17 00:00:00 2001
From: Chris Cameron <chris.cameron@wedoresi.com>
Date: Fri, 7 Jul 2017 17:20:39 -0400
Subject: [PATCH 3/4] Stub tests for EnumUtils, need to figure out test
 generation...

---
 ICD.Common.Utils.Tests/EnumUtilsTest.cs | 175 ++++++++++++++++++++++++
 1 file changed, 175 insertions(+)
 create mode 100644 ICD.Common.Utils.Tests/EnumUtilsTest.cs

diff --git a/ICD.Common.Utils.Tests/EnumUtilsTest.cs b/ICD.Common.Utils.Tests/EnumUtilsTest.cs
new file mode 100644
index 0000000..e5031b6
--- /dev/null
+++ b/ICD.Common.Utils.Tests/EnumUtilsTest.cs
@@ -0,0 +1,175 @@
+using NUnit.Framework;
+using System;
+
+namespace ICD.Common.Utils.Tests_NetStandard
+{
+	[TestFixture]
+    public sealed class EnumUtilsTest
+    {
+		private enum eTestEnum
+		{
+			A, 
+			B,
+			C
+		}
+
+		[Test]
+		public void IsEnumTypeTest()
+		{
+			Assert.IsTrue(EnumUtils.IsEnumType(typeof(eTestEnum)));
+			Assert.IsTrue(EnumUtils.IsEnumType(typeof(Enum)));
+			Assert.IsFalse(EnumUtils.IsEnumType(typeof(EnumUtilsTest)));
+			Assert.Throws<ArgumentNullException>(() => EnumUtils.IsEnumType(null));
+		}
+
+		[Test]
+		public void IsEnumTypeGenericTest()
+		{
+			Assert.IsTrue(EnumUtils.IsEnumType<eTestEnum>());
+			Assert.IsTrue(EnumUtils.IsEnumType<Enum>());
+			Assert.IsFalse(EnumUtils.IsEnumType<EnumUtilsTest>());
+		}
+
+		[Test]
+		public void IsEnumTest()
+		{
+			Assert.IsTrue(EnumUtils.IsEnum(eTestEnum.A));
+			Assert.IsTrue(EnumUtils.IsEnum(eTestEnum.A as object));
+			Assert.IsTrue(EnumUtils.IsEnum(eTestEnum.A as Enum));
+			Assert.IsFalse(EnumUtils.IsEnum(null));
+			Assert.IsFalse(EnumUtils.IsEnum(""));
+		}
+
+		#region Values
+
+		[Test]
+		public void GetUnderlyingValueTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void GetValuesGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void GetValuesTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void GetNoneValueGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void GetValuesExceptNoneGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void GetValuesExceptNoneTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		#endregion
+
+		#region Flags
+
+		[Test]
+		public void IsFlagsEnumGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void IsFlagsEnumTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void GetFlagsIntersectionGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void GetFlagsGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void GetFlagsExceptNoneGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void GetFlagsAllValueGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void HasFlagGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void HasFlagsGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void HasSingleFlagGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void HasMultipleFlagsGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		#endregion
+
+		#region Conversion
+
+		[Test]
+		public void ParseGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void TryParseGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void ToEnumGenericTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void ToEnumTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		#endregion
+	}
+}

From ee58b5109b684439e90964499a84508dd0404f20 Mon Sep 17 00:00:00 2001
From: Chris Cameron <chris.cameron@wedoresi.com>
Date: Mon, 10 Jul 2017 17:05:18 -0400
Subject: [PATCH 4/4] Complete EnumUtils unit tests

---
 ICD.Common.Utils.Tests/EnumUtilsTest.cs | 123 +++++++++++++++++++-----
 1 file changed, 100 insertions(+), 23 deletions(-)

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