From 8ee4000e4eaf4c1660af8b8aa207248e50dd77bc Mon Sep 17 00:00:00 2001 From: Chris Cameron Date: Mon, 31 Jul 2017 20:48:09 -0400 Subject: [PATCH] Additional tests --- .../Extensions/EnumerableExtensionsTest.cs | 281 +++++++++++++++++- 1 file changed, 272 insertions(+), 9 deletions(-) diff --git a/ICD.Common.Utils.Tests/Extensions/EnumerableExtensionsTest.cs b/ICD.Common.Utils.Tests/Extensions/EnumerableExtensionsTest.cs index d2244e4..bc700aa 100644 --- a/ICD.Common.Utils.Tests/Extensions/EnumerableExtensionsTest.cs +++ b/ICD.Common.Utils.Tests/Extensions/EnumerableExtensionsTest.cs @@ -1,5 +1,6 @@ using ICD.Common.Utils.Extensions; using NUnit.Framework; +using System.Collections.Generic; using System.Linq; namespace ICD.Common.Utils.Tests_NetStandard.Extensions @@ -7,15 +8,277 @@ namespace ICD.Common.Utils.Tests_NetStandard.Extensions [TestFixture] public sealed class EnumerableExtensionsTest { - [Test] - public void ConsolidateTest() - { - string[] sequence = EnumerableExtensions.Consolidate(new string[] { "A", "B", "B", "C" }).ToArray(); + [TestCase(0)] + [TestCase(1)] + public void FirstOrDefaultTest(int expected) + { + IEnumerable sequence = Enumerable.Empty(); + Assert.AreEqual(expected, sequence.FirstOrDefault(expected)); + } - Assert.AreEqual(3, sequence.Length, StringUtils.ArrayFormat(sequence)); - Assert.AreEqual("A", sequence[0]); - Assert.AreEqual("B", sequence[1]); - Assert.AreEqual("C", sequence[2]); + [TestCase(0)] + [TestCase(1)] + public void FirstOrDefaultPredicateTest(int expected) + { + IEnumerable sequence = Enumerable.Range(1, 10).Except(expected); + Assert.AreEqual(expected, sequence.FirstOrDefault(i => i == expected, expected)); + } + + [TestCase(0)] + [TestCase(1)] + public void TryFirstTest(int expected) + { + IEnumerable sequence = Enumerable.Empty(); + int result; + bool exists = sequence.TryFirst(out result); + + Assert.AreEqual(0, result); + Assert.AreEqual(false, exists); + + sequence = new int[] { expected }; + exists = sequence.TryFirst(out result); + + Assert.AreEqual(expected, result); + Assert.AreEqual(true, exists); + } + + [TestCase(0)] + [TestCase(1)] + public void TryFirstPredicateTest(int expected) + { + IEnumerable sequence = Enumerable.Range(1, 10).Except(expected); + int result; + bool exists = sequence.TryFirst(i => i == expected, out result); + + Assert.AreEqual(0, result); + Assert.AreEqual(false, exists); + + sequence = new int[] { expected }; + exists = sequence.TryFirst(i => i == expected, out result); + + Assert.AreEqual(expected, result); + Assert.AreEqual(true, exists); + } + + [TestCase(0, 0)] + [TestCase(1, 10)] + public void TryElementAtTest(int index, int expected) + { + IEnumerable sequence = Enumerable.Empty(); + int result; + bool exists = sequence.TryElementAt(index, out result); + + Assert.AreEqual(0, result); + Assert.AreEqual(false, exists); + + sequence = new int[] { expected }; + exists = sequence.TryElementAt(0, out result); + + Assert.AreEqual(expected, result); + Assert.AreEqual(true, exists); + } + + [Test] + public void ScrambledEqualsTest() + { + IEnumerable a = new int[] { 1, 2, 3, 4 }; + IEnumerable b = new int[] { 3, 1, 2, 4 }; + IEnumerable c = new int[] { 1, 2, 3, 4, 4 }; + IEnumerable d = new int[] { 1, 2, 3, 4, 5 }; + + Assert.IsTrue(a.ScrambledEquals(b)); + Assert.IsFalse(a.ScrambledEquals(c)); + Assert.IsFalse(a.ScrambledEquals(d)); + } + + [Test] + public void ScrambledEqualsComparerTest() + { + IEnumerable a = new int[] { 1, 2, 3, 4 }; + IEnumerable b = new int[] { 3, 1, 2, 4 }; + IEnumerable c = new int[] { 1, 2, 3, 4, 4 }; + IEnumerable d = new int[] { 1, 2, 3, 4, 5 }; + + Assert.IsTrue(a.ScrambledEquals(b, EqualityComparer.Default)); + Assert.IsFalse(a.ScrambledEquals(c, EqualityComparer.Default)); + Assert.IsFalse(a.ScrambledEquals(d, EqualityComparer.Default)); + } + + [Test] + public void FindIndexPredicateTest() + { + IEnumerable a = new int[] { 1, 2, 3, 4 }; + Assert.AreEqual(2, a.FindIndex(i => i == 3)); + } + + [Test] + public void SelectMultiTest() + { + Assert.Inconclusive(); + } + + [Test] + public void ExecuteTest() + { + Assert.Inconclusive(); + } + + [Test] + public void ForEachTest() + { + Assert.Inconclusive(); + } + + [Test] + public void ForEachIndexTest() + { + Assert.Inconclusive(); + } + +#if SIMPLSHARP + [Test] + public void PrependTest() + { + Assert.Inconclusive(); } - } +#endif + + [Test] + public void PrependManyTest() + { + Assert.Inconclusive(); + } + +#if SIMPLSHARP + [Test] + public void AppendTest() + { + Assert.Inconclusive(); + } +#endif + + [Test] + public void AppendManyTest() + { + Assert.Inconclusive(); + } + + [Test] + public void OrderTest() + { + Assert.Inconclusive(); + } + + [Test] + public void ExceptTest() + { + Assert.Inconclusive(); + } + + [Test] + public void ToHashSetTest() + { + Assert.Inconclusive(); + } + + [Test] + public void ToDictionaryIntTest() + { + Assert.Inconclusive(); + } + + [Test] + public void ToDictionaryUIntTest() + { + Assert.Inconclusive(); + } + + [Test] + public void ToDictionaryTest() + { + Assert.Inconclusive(); + } + + [Test] + public void UnanimousTest() + { + Assert.Inconclusive(); + } + + [Test] + public void UnanimousOtherTest() + { + Assert.Inconclusive(); + } + + [Test] + public void PartitionTest() + { + Assert.Inconclusive(); + } + + [Test] + public void MinByTest() + { + Assert.Inconclusive(); + } + + [Test] + public void MinByComparerTest() + { + Assert.Inconclusive(); + } + + [Test] + public void ExceptNullsTest() + { + IEnumerable sequence = new int?[] { 1, 2, null, 3, 4, null }; + int[] result = sequence.ExceptNulls().ToArray(); + + Assert.AreEqual(4, result.Length); + Assert.AreEqual(1, result[0]); + Assert.AreEqual(2, result[1]); + Assert.AreEqual(3, result[2]); + Assert.AreEqual(4, result[3]); + } + + [Test] + public void SumTest() + { + IEnumerable sequence = new byte[] { 1, 2, 3, 4 }; + Assert.AreEqual(10, sequence.Sum()); + } + + [Test] + public void ConsolidateTest() + { + string[] sequence = EnumerableExtensions.Consolidate(new string[] { "A", "B", "B", "C" }).ToArray(); + + Assert.AreEqual(3, sequence.Length, StringUtils.ArrayFormat(sequence)); + Assert.AreEqual("A", sequence[0]); + Assert.AreEqual("B", sequence[1]); + Assert.AreEqual("C", sequence[2]); + } + + [Test] + public void ConsolidateComparerTest() + { + string[] sequence = EnumerableExtensions.Consolidate(new string[] { "A", "B", "B", "C" }, Comparer.Default).ToArray(); + + Assert.AreEqual(3, sequence.Length, StringUtils.ArrayFormat(sequence)); + Assert.AreEqual("A", sequence[0]); + Assert.AreEqual("B", sequence[1]); + Assert.AreEqual("C", sequence[2]); + } + + [Test] + public void AnyAndAllTest() + { + IEnumerable sequence = new int[] { 1, 2, 3, 4 }; + + Assert.IsTrue(sequence.AnyAndAll(i => i > 0)); + Assert.IsFalse(sequence.AnyAndAll(i => i < 0)); + Assert.IsFalse(Enumerable.Empty().AnyAndAll(i => i > 0)); + } + } }