From 5640b663d6530c4206e88eb6b5b20973ef1c6c6f Mon Sep 17 00:00:00 2001
From: Chris Cameron <chris.cameron@wedoresi.com>
Date: Mon, 2 Oct 2017 13:40:12 -0400
Subject: [PATCH] Begin implementing ReflectionUtilsTest

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

diff --git a/ICD.Common.Utils.Tests/ReflectionUtilsTest.cs b/ICD.Common.Utils.Tests/ReflectionUtilsTest.cs
new file mode 100644
index 0000000..28458dc
--- /dev/null
+++ b/ICD.Common.Utils.Tests/ReflectionUtilsTest.cs
@@ -0,0 +1,125 @@
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+#if SIMPLSHARP
+using Crestron.SimplSharp.Reflection;
+#else
+using System.Reflection;
+#endif
+
+namespace ICD.Common.Utils.Tests
+{
+	[TestFixture]
+    public sealed class ReflectionUtilsTest
+    {
+		private string TestProperty { get; set; }
+
+		private void TestMethod(string param1, int param2)
+		{
+		}
+
+		private class TestClass
+		{
+			public string Param1 { get; set; }
+			public int Param2 { get; set; }
+
+			public TestClass(string param1, int param2)
+			{
+				Param1 = param1;
+				Param2 = param2;
+			}
+		}
+
+		[TestCase("test", 10)]
+		[TestCase(null, 0)]
+		public void InstantiateTest(string param1, int param2)
+		{
+			TestClass result = ReflectionUtils.Instantiate(typeof(TestClass), param1, param2) as TestClass;
+
+			Assert.NotNull(result);
+			Assert.AreEqual(param1, result.Param1);
+			Assert.AreEqual(param2, result.Param2);
+		}
+
+		[Test]
+		public void MatchesConstructorParametersTest()
+		{
+			Assert.Throws<ArgumentNullException>(() => ReflectionUtils.MatchesConstructorParameters(null, new object[] { "test", 10 }));
+
+			ConstructorInfo constructor = typeof(TestClass).GetConstructor(new Type[] { typeof(string), typeof(int) });
+
+			Assert.IsTrue(ReflectionUtils.MatchesConstructorParameters(constructor, new object[] { "test", 10 }));
+			Assert.IsTrue(ReflectionUtils.MatchesConstructorParameters(constructor, new object[] { null, 10 }));
+			Assert.IsFalse(ReflectionUtils.MatchesConstructorParameters(constructor, new object[] { "test", "test" }));
+			Assert.IsFalse(ReflectionUtils.MatchesConstructorParameters(constructor, new object[] { "test" }));
+			Assert.IsFalse(ReflectionUtils.MatchesConstructorParameters(constructor, new object[] { "test", "test", "test" }));
+			Assert.IsFalse(ReflectionUtils.MatchesConstructorParameters(constructor, new object[] { 10, 10 }));
+		}
+
+		[Test]
+		public void MatchesMethodParametersTest()
+		{
+			Assert.Throws<ArgumentNullException>(() => ReflectionUtils.MatchesMethodParameters(null, new object[] { "test", 10 }));
+
+			MethodInfo method = GetType().GetMethod("TestMethod",
+				BindingFlags.NonPublic |
+				BindingFlags.Instance);
+
+			Assert.IsTrue(ReflectionUtils.MatchesMethodParameters(method, new object[] { "test", 10 }));
+			Assert.IsTrue(ReflectionUtils.MatchesMethodParameters(method, new object[] { null, 10 }));
+			Assert.IsFalse(ReflectionUtils.MatchesMethodParameters(method, new object[] { "test", "test" }));
+			Assert.IsFalse(ReflectionUtils.MatchesMethodParameters(method, new object[] { "test" }));
+			Assert.IsFalse(ReflectionUtils.MatchesMethodParameters(method, new object[] { "test", "test", "test" }));
+			Assert.IsFalse(ReflectionUtils.MatchesMethodParameters(method, new object[] { 10, 10 }));
+		}
+
+		[Test]
+		public void MatchesPropertyParameterTest()
+		{
+			Assert.Throws<ArgumentNullException>(() => ReflectionUtils.MatchesPropertyParameter(null, 10));
+
+			PropertyInfo prop = GetType().GetProperty("TestProperty",
+				BindingFlags.NonPublic |
+				BindingFlags.Instance |
+				BindingFlags.GetProperty);
+
+			Assert.IsTrue(ReflectionUtils.MatchesPropertyParameter(prop, "test"));
+			Assert.IsTrue(ReflectionUtils.MatchesPropertyParameter(prop, null));
+			Assert.IsFalse(ReflectionUtils.MatchesPropertyParameter(prop, 1));
+			Assert.IsFalse(ReflectionUtils.MatchesPropertyParameter(prop, new string[0]));
+		}
+
+		[TestCase(typeof(string), null)]
+		[TestCase(typeof(int), 0)]
+		public void GetDefaultValueTest(Type type, object expected)
+		{
+			Assert.AreEqual(expected, ReflectionUtils.GetDefaultValue(type));
+		}
+
+		[Test]
+		public void CreateInstanceGenericTest()
+		{
+			List<string> output = ReflectionUtils.CreateInstance<List<string>>();
+			Assert.NotNull(output);
+		}
+
+		[Test]
+		public void CreateInstanceTest()
+		{
+			List<string> output = ReflectionUtils.CreateInstance(typeof(List<string>)) as List<string>;
+			Assert.NotNull(output);
+		}
+
+		[Test]
+		public void GetCustomAttributesTest()
+		{
+			Assert.Inconclusive();
+		}
+
+		[Test]
+		public void LoadAssemblyFromPath()
+		{
+			Assert.Inconclusive();
+		}
+	}
+}