Additional tests

ICD.Common.Utils.Tests/MathUtilsTest.cs

@@ -1,9 +1,11 @@
 using ICD.Common.Properties;
 using NUnit.Framework;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace ICD.Common.Utils.Tests
 {
-	[TestFixture]
+	[TestFixture, UsedImplicitly]
 	public sealed class MathUtilsTest
 	{
 		[Test, UsedImplicitly]
@@ -33,5 +35,48 @@ namespace ICD.Common.Utils.Tests
 			Assert.AreEqual(50, MathUtils.MapRange(0, 10, 0, 100, 5));
 			Assert.AreEqual(100, MathUtils.MapRange(0, 10, 0, 100, 10));
 		}
-	}
+
+        [UsedImplicitly]
+        [TestCase(-10000, 5)]
+        [TestCase(10000, 5)]
+        public void GetNumberOfDigitsTest(int number, int expected)
+        {
+            Assert.AreEqual(expected, MathUtils.GetNumberOfDigits(number));
+        }
+
+        [Test, UsedImplicitly]
+		public void GetRangesTest()
+        {
+            IEnumerable<int> values = new int[] { 1, 3, 5, 6, 7, 8, 9, 10, 12 };
+            int[][] ranges = MathUtils.GetRanges(values).ToArray();
+
+            Assert.AreEqual(4, ranges.Length);
+
+            Assert.AreEqual(1, ranges[0][0]);
+            Assert.AreEqual(1, ranges[0][1]);
+
+            Assert.AreEqual(3, ranges[1][0]);
+            Assert.AreEqual(3, ranges[1][1]);
+
+            Assert.AreEqual(5, ranges[2][0]);
+            Assert.AreEqual(10, ranges[2][1]);
+
+            Assert.AreEqual(12, ranges[3][0]);
+            Assert.AreEqual(12, ranges[3][1]);
+        }
+
+        [Test, UsedImplicitly]
+        public void RoundToNearestTest()
+        {
+            IEnumerable<int> values = new int[] { 0, 15, 30, 45 };
+            Assert.AreEqual(15, MathUtils.RoundToNearest(21, values));
+        }
+
+        [Test, UsedImplicitly]
+        public void GetNewIdTest()
+        {
+            IEnumerable<int> ids = Enumerable.Range(1, 10);
+            Assert.AreEqual(11, MathUtils.GetNewId(ids));
+        }
+    }
 }

ICD.Common.Utils.Tests/Services/Logging/LogItemEventArgsTest.cs

@@ -0,0 +1,18 @@
+using ICD.Common.Services.Logging;
+using NUnit.Framework;
+
+namespace ICD.Common.Utils.Tests_NetStandard.Services.Logging
+{
+    [TestFixture]
+    public sealed class LogItemEventArgsTest
+    {
+        [Test]
+        public void DataTest()
+        {
+            LogItem item = new LogItem(eSeverity.Critical, "test");
+            LogItemEventArgs eventArgs = new LogItemEventArgs(item);
+
+            Assert.AreEqual(item, eventArgs.Data);
+        }
+    }
+}

ICD.Common.Utils.Tests/Services/Logging/LogItemTest.cs

@@ -0,0 +1,79 @@
+using ICD.Common.Properties;
+using ICD.Common.Services.Logging;
+using NUnit.Framework;
+using System;
+
+namespace ICD.Common.Utils.Tests_NetStandard.Services.Logging
+{
+    [UsedImplicitly, TestFixture]
+    public sealed class LogItemTest
+    {
+        [UsedImplicitly, Test]
+        public void TimestampTest()
+        {
+            LogItem item = new LogItem(eSeverity.Critical, null);
+            DateTime time = IcdEnvironment.GetLocalTime();
+
+            Assert.IsTrue((time - item.Timestamp).TotalSeconds <= 1);
+        }
+
+        [UsedImplicitly]
+        [TestCase(eSeverity.Alert)]
+        public void SeverityTest(eSeverity severity)
+        {
+            LogItem item = new LogItem(severity, null);
+            Assert.AreEqual(severity, item.Severity);
+        }
+
+        [UsedImplicitly]
+        [TestCase(null)]
+        [TestCase("test")]
+        public void MessageTest(string message)
+        {
+            LogItem item = new LogItem(eSeverity.Critical, message);
+            Assert.AreEqual(message, item.Message);
+        }
+
+        [UsedImplicitly, Test]
+        public void GetFusionLogTextTest()
+        {
+            Assert.Inconclusive();
+        }
+
+        [UsedImplicitly, Test]
+        public void EqualityOperatorTest()
+        {
+            LogItem a = new LogItem(eSeverity.Alert, "test");
+            LogItem b = a;
+            LogItem c = new LogItem(eSeverity.Critical, "dsfds");
+
+            Assert.IsTrue(a == b);
+            Assert.IsFalse(b == c);
+            Assert.IsFalse(b == null);
+        }
+
+        [UsedImplicitly, Test]
+        public void InequalityOperatorTest()
+        {
+            LogItem a = new LogItem(eSeverity.Alert, "test");
+            LogItem b = a;
+            LogItem c = new LogItem(eSeverity.Critical, "dsfds");
+
+            Assert.IsFalse(a != b);
+            Assert.IsTrue(b != c);
+            Assert.IsTrue(b != null);
+        }
+
+        [UsedImplicitly, Test]
+        public void EqualityTest()
+        {
+            LogItem a = new LogItem(eSeverity.Alert, "test");
+            LogItem b = a;
+            LogItem c = new LogItem(eSeverity.Critical, "dsfds");
+
+            Assert.IsTrue(a.Equals(b));
+            Assert.IsFalse(b.Equals(c));
+            Assert.IsFalse(b.Equals(null));
+        }
+    }
+}

ICD.Common.Utils.Tests/Services/Logging/SeverityEventArgsTest.cs

@@ -0,0 +1,16 @@
+using ICD.Common.Services.Logging;
+using NUnit.Framework;
+
+namespace ICD.Common.Utils.Tests_NetStandard.Services.Logging
+{
+    [TestFixture]
+    public sealed class SeverityEventArgsTest
+    {
+        [TestCase(eSeverity.Critical)]
+        public void DataTest(eSeverity severity)
+        {
+            SeverityEventArgs args = new SeverityEventArgs(severity);
+            Assert.AreEqual(severity, args.Data);
+        }
+    }
+}