diff --git a/ICD.Common.Utils.Tests/EnumUtilsTest.cs b/ICD.Common.Utils.Tests/EnumUtilsTest.cs
new file mode 100644
index 0000000..e829ff5
--- /dev/null
+++ b/ICD.Common.Utils.Tests/EnumUtilsTest.cs
@@ -0,0 +1,252 @@
+using NUnit.Framework;
+using System;
+using System.Linq;
+
+namespace ICD.Common.Utils.Tests_NetStandard
+{
+	[TestFixture]
+    public sealed class EnumUtilsTest
+    {
+		private enum eTestEnum
+		{
+			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));
+		}
+
+		[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(null));
+			Assert.IsFalse(EnumUtils.IsEnum(""));
+		}
+
+		#region Values
+
+		[Test]
+		public void GetUnderlyingValueTest()
+		{
+			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()
+		{
+			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()
+		{
+			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.AreEqual(eTestEnum.None, EnumUtils.GetNoneValue<eTestEnum>());
+			Assert.AreEqual(eTestFlagsEnum.None, EnumUtils.GetNoneValue<eTestFlagsEnum>());
+		}
+
+		[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));
+		}
+
+		[Test]
+		public void GetValuesExceptNoneTest()
+		{
+			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
+
+		#region Flags
+
+		[Test]
+		public void IsFlagsEnumGenericTest()
+		{
+			Assert.IsFalse(EnumUtils.IsFlagsEnum<eTestEnum>());
+			Assert.IsTrue(EnumUtils.IsFlagsEnum<eTestFlagsEnum>());
+		}
+
+		[Test]
+		public void IsFlagsEnumTest()
+		{
+			Assert.IsFalse(EnumUtils.IsFlagsEnum(typeof(eTestEnum)));
+			Assert.IsTrue(EnumUtils.IsFlagsEnum(typeof(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(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()
+		{
+			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()
+		{
+			eTestFlagsEnum value = EnumUtils.GetFlagsAllValue<eTestFlagsEnum>();
+			Assert.AreEqual(eTestFlagsEnum.None | eTestFlagsEnum.A | eTestFlagsEnum.B | eTestFlagsEnum.C, 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));
+		}
+
+		#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 ToEnumGenericTest()
+		{
+			Assert.AreEqual(eTestEnum.A, EnumUtils.ToEnum(eTestEnum.A));
+			Assert.AreNotEqual(eTestEnum.B, EnumUtils.ToEnum(eTestEnum.A));
+		}
+
+		[Test]
+		public void ToEnumTest()
+		{
+			Assert.AreEqual(eTestEnum.A, EnumUtils.ToEnum((object)eTestEnum.A));
+			Assert.AreNotEqual(eTestEnum.B, EnumUtils.ToEnum((object)eTestEnum.A));
+		}
+
+		#endregion
+	}
+}
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
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>