mirror of
https://github.com/ICDSystems/ICD.Common.Utils.git
synced 2026-02-15 20:54:58 +00:00
Entension methods for finding indices in a sequence, and finding the closest item in a sequence
This commit is contained in:
Chris Cameron
@@ -8,170 +8,186 @@ using System;
|
|||||||
namespace ICD.Common.Utils.Tests.Extensions
|
namespace ICD.Common.Utils.Tests.Extensions
|
||||||
{
|
{
|
||||||
[TestFixture]
|
[TestFixture]
|
||||||
public sealed class EnumerableExtensionsTest
|
public sealed class EnumerableExtensionsTest
|
||||||
{
|
{
|
||||||
[TestCase(0)]
|
[TestCase(0)]
|
||||||
[TestCase(1)]
|
[TestCase(1)]
|
||||||
public void FirstOrDefaultTest(int expected)
|
public void FirstOrDefaultTest(int expected)
|
||||||
{
|
{
|
||||||
IEnumerable<int> sequence = Enumerable.Empty<int>();
|
IEnumerable<int> sequence = Enumerable.Empty<int>();
|
||||||
Assert.AreEqual(expected, sequence.FirstOrDefault(expected));
|
Assert.AreEqual(expected, sequence.FirstOrDefault(expected));
|
||||||
}
|
}
|
||||||
|
|
||||||
[TestCase(0)]
|
[TestCase(0)]
|
||||||
[TestCase(1)]
|
[TestCase(1)]
|
||||||
public void FirstOrDefaultPredicateTest(int expected)
|
public void FirstOrDefaultPredicateTest(int expected)
|
||||||
{
|
{
|
||||||
IEnumerable<int> sequence = Enumerable.Range(1, 10).Except(expected);
|
IEnumerable<int> sequence = Enumerable.Range(1, 10).Except(expected);
|
||||||
Assert.AreEqual(expected, sequence.FirstOrDefault(i => i == expected, expected));
|
Assert.AreEqual(expected, sequence.FirstOrDefault(i => i == expected, expected));
|
||||||
}
|
}
|
||||||
|
|
||||||
[TestCase(0)]
|
[TestCase(0)]
|
||||||
[TestCase(1)]
|
[TestCase(1)]
|
||||||
public void TryFirstTest(int expected)
|
public void TryFirstTest(int expected)
|
||||||
{
|
{
|
||||||
IEnumerable<int> sequence = Enumerable.Empty<int>();
|
IEnumerable<int> sequence = Enumerable.Empty<int>();
|
||||||
int result;
|
int result;
|
||||||
bool exists = sequence.TryFirst(out result);
|
bool exists = sequence.TryFirst(out result);
|
||||||
|
|
||||||
Assert.AreEqual(0, result);
|
Assert.AreEqual(0, result);
|
||||||
Assert.AreEqual(false, exists);
|
Assert.AreEqual(false, exists);
|
||||||
|
|
||||||
sequence = new[] { expected };
|
sequence = new[] {expected};
|
||||||
exists = sequence.TryFirst(out result);
|
exists = sequence.TryFirst(out result);
|
||||||
|
|
||||||
Assert.AreEqual(expected, result);
|
Assert.AreEqual(expected, result);
|
||||||
Assert.AreEqual(true, exists);
|
Assert.AreEqual(true, exists);
|
||||||
}
|
}
|
||||||
|
|
||||||
[TestCase(0)]
|
[TestCase(0)]
|
||||||
[TestCase(1)]
|
[TestCase(1)]
|
||||||
public void TryFirstPredicateTest(int expected)
|
public void TryFirstPredicateTest(int expected)
|
||||||
{
|
{
|
||||||
IEnumerable<int> sequence = Enumerable.Range(1, 10).Except(expected);
|
IEnumerable<int> sequence = Enumerable.Range(1, 10).Except(expected);
|
||||||
int result;
|
int result;
|
||||||
bool exists = sequence.TryFirst(i => i == expected, out result);
|
bool exists = sequence.TryFirst(i => i == expected, out result);
|
||||||
|
|
||||||
Assert.AreEqual(0, result);
|
Assert.AreEqual(0, result);
|
||||||
Assert.AreEqual(false, exists);
|
Assert.AreEqual(false, exists);
|
||||||
|
|
||||||
sequence = new[] { expected };
|
sequence = new[] {expected};
|
||||||
exists = sequence.TryFirst(i => i == expected, out result);
|
exists = sequence.TryFirst(i => i == expected, out result);
|
||||||
|
|
||||||
Assert.AreEqual(expected, result);
|
Assert.AreEqual(expected, result);
|
||||||
Assert.AreEqual(true, exists);
|
Assert.AreEqual(true, exists);
|
||||||
}
|
}
|
||||||
|
|
||||||
[TestCase(0, 0)]
|
[TestCase(0, 0)]
|
||||||
[TestCase(1, 10)]
|
[TestCase(1, 10)]
|
||||||
public void TryElementAtTest(int index, int expected)
|
public void TryElementAtTest(int index, int expected)
|
||||||
{
|
{
|
||||||
IEnumerable<int> sequence = Enumerable.Empty<int>();
|
IEnumerable<int> sequence = Enumerable.Empty<int>();
|
||||||
int result;
|
int result;
|
||||||
bool exists = sequence.TryElementAt(index, out result);
|
bool exists = sequence.TryElementAt(index, out result);
|
||||||
|
|
||||||
Assert.AreEqual(0, result);
|
Assert.AreEqual(0, result);
|
||||||
Assert.AreEqual(false, exists);
|
Assert.AreEqual(false, exists);
|
||||||
|
|
||||||
sequence = new[] { expected };
|
sequence = new[] {expected};
|
||||||
exists = sequence.TryElementAt(0, out result);
|
exists = sequence.TryElementAt(0, out result);
|
||||||
|
|
||||||
Assert.AreEqual(expected, result);
|
Assert.AreEqual(expected, result);
|
||||||
Assert.AreEqual(true, exists);
|
Assert.AreEqual(true, exists);
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void SequenceEqualTest()
|
public void SequenceEqualTest()
|
||||||
{
|
{
|
||||||
int[] a = new[] { 1, 2, 3, 4};
|
int[] a = new[] {1, 2, 3, 4};
|
||||||
int[] b = new[] { 1, 4, 9, 16};
|
int[] b = new[] {1, 4, 9, 16};
|
||||||
|
|
||||||
Assert.IsFalse(a.SequenceEqual(b, (x, y) => x == y));
|
Assert.IsFalse(a.SequenceEqual(b, (x, y) => x == y));
|
||||||
Assert.IsTrue(a.SequenceEqual(b, (x, y) => x * x == y));
|
Assert.IsTrue(a.SequenceEqual(b, (x, y) => x * x == y));
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void ScrambledEqualsTest()
|
public void ScrambledEqualsTest()
|
||||||
{
|
{
|
||||||
IEnumerable<int> a = new[] { 1, 2, 3, 4 };
|
IEnumerable<int> a = new[] {1, 2, 3, 4};
|
||||||
IEnumerable<int> b = new[] { 3, 1, 2, 4 };
|
IEnumerable<int> b = new[] {3, 1, 2, 4};
|
||||||
IEnumerable<int> c = new[] { 1, 2, 3, 4, 4 };
|
IEnumerable<int> c = new[] {1, 2, 3, 4, 4};
|
||||||
IEnumerable<int> d = new[] { 1, 2, 3, 4, 5 };
|
IEnumerable<int> d = new[] {1, 2, 3, 4, 5};
|
||||||
|
|
||||||
Assert.IsTrue(a.ScrambledEquals(b));
|
Assert.IsTrue(a.ScrambledEquals(b));
|
||||||
Assert.IsFalse(a.ScrambledEquals(c));
|
Assert.IsFalse(a.ScrambledEquals(c));
|
||||||
Assert.IsFalse(a.ScrambledEquals(d));
|
Assert.IsFalse(a.ScrambledEquals(d));
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void ScrambledEqualsComparerTest()
|
public void ScrambledEqualsComparerTest()
|
||||||
{
|
{
|
||||||
IEnumerable<int> a = new[] { 1, 2, 3, 4 };
|
IEnumerable<int> a = new[] {1, 2, 3, 4};
|
||||||
IEnumerable<int> b = new[] { 3, 1, 2, 4 };
|
IEnumerable<int> b = new[] {3, 1, 2, 4};
|
||||||
IEnumerable<int> c = new[] { 1, 2, 3, 4, 4 };
|
IEnumerable<int> c = new[] {1, 2, 3, 4, 4};
|
||||||
IEnumerable<int> d = new[] { 1, 2, 3, 4, 5 };
|
IEnumerable<int> d = new[] {1, 2, 3, 4, 5};
|
||||||
|
|
||||||
Assert.IsTrue(a.ScrambledEquals(b, EqualityComparer<int>.Default));
|
Assert.IsTrue(a.ScrambledEquals(b, EqualityComparer<int>.Default));
|
||||||
Assert.IsFalse(a.ScrambledEquals(c, EqualityComparer<int>.Default));
|
Assert.IsFalse(a.ScrambledEquals(c, EqualityComparer<int>.Default));
|
||||||
Assert.IsFalse(a.ScrambledEquals(d, EqualityComparer<int>.Default));
|
Assert.IsFalse(a.ScrambledEquals(d, EqualityComparer<int>.Default));
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void FindIndexPredicateTest()
|
public void FindIndexPredicateTest()
|
||||||
{
|
{
|
||||||
IEnumerable<int> a = new[] { 1, 2, 3, 4 };
|
IEnumerable<int> a = new[] {1, 2, 3, 4};
|
||||||
Assert.AreEqual(2, a.FindIndex(i => i == 3));
|
Assert.AreEqual(2, a.FindIndex(i => i == 3));
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void SelectMultiTest()
|
public void FindIndicesPredicateTest()
|
||||||
{
|
{
|
||||||
int[] values = { 1, 2, 3 };
|
IEnumerable<int> a = new[] {1, 2, 3, 4};
|
||||||
int[] result = values.SelectMulti(i => 1, i => 2).ToArray();
|
|
||||||
|
|
||||||
Assert.AreEqual(6, result.Length);
|
int[] indices = a.FindIndices(i => i % 2 == 0).ToArray();
|
||||||
Assert.AreEqual(1, result[0]);
|
|
||||||
Assert.AreEqual(2, result[1]);
|
|
||||||
Assert.AreEqual(1, result[2]);
|
|
||||||
Assert.AreEqual(2, result[3]);
|
|
||||||
Assert.AreEqual(1, result[4]);
|
|
||||||
Assert.AreEqual(2, result[5]);
|
|
||||||
}
|
|
||||||
|
|
||||||
[Test]
|
Assert.AreEqual(2, indices.Length);
|
||||||
public void ExecuteTest()
|
Assert.AreEqual(1, indices[0]);
|
||||||
{
|
Assert.AreEqual(3, indices[1]);
|
||||||
int[] values = { 1, 2, 3 };
|
}
|
||||||
|
|
||||||
int sum = 0;
|
[Test]
|
||||||
IEnumerable<int> sequence = values.Select(v => { sum += v; return v; });
|
public void SelectMultiTest()
|
||||||
|
{
|
||||||
|
int[] values = {1, 2, 3};
|
||||||
|
int[] result = values.SelectMulti(i => 1, i => 2).ToArray();
|
||||||
|
|
||||||
Assert.AreEqual(0, sum);
|
Assert.AreEqual(6, result.Length);
|
||||||
sequence.Execute();
|
Assert.AreEqual(1, result[0]);
|
||||||
Assert.AreEqual(6, sum);
|
Assert.AreEqual(2, result[1]);
|
||||||
}
|
Assert.AreEqual(1, result[2]);
|
||||||
|
Assert.AreEqual(2, result[3]);
|
||||||
|
Assert.AreEqual(1, result[4]);
|
||||||
|
Assert.AreEqual(2, result[5]);
|
||||||
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void ForEachTest()
|
public void ExecuteTest()
|
||||||
{
|
{
|
||||||
int[] values = { 1, 2, 3 };
|
int[] values = {1, 2, 3};
|
||||||
|
|
||||||
int sum = 0;
|
int sum = 0;
|
||||||
values.ForEach(v => sum += v);
|
IEnumerable<int> sequence = values.Select(v =>
|
||||||
|
{
|
||||||
|
sum += v;
|
||||||
|
return v;
|
||||||
|
});
|
||||||
|
|
||||||
Assert.AreEqual(6, sum);
|
Assert.AreEqual(0, sum);
|
||||||
}
|
sequence.Execute();
|
||||||
|
Assert.AreEqual(6, sum);
|
||||||
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void ForEachIndexTest()
|
public void ForEachTest()
|
||||||
{
|
{
|
||||||
int[] values = { 1, 2, 3 };
|
int[] values = {1, 2, 3};
|
||||||
|
|
||||||
int sum = 0;
|
int sum = 0;
|
||||||
values.ForEach((v, i) => sum += i);
|
values.ForEach(v => sum += v);
|
||||||
|
|
||||||
Assert.AreEqual(3, sum);
|
Assert.AreEqual(6, sum);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
[Test]
|
||||||
|
public void ForEachIndexTest()
|
||||||
|
{
|
||||||
|
int[] values = {1, 2, 3};
|
||||||
|
|
||||||
|
int sum = 0;
|
||||||
|
values.ForEach((v, i) => sum += i);
|
||||||
|
|
||||||
|
Assert.AreEqual(3, sum);
|
||||||
|
}
|
||||||
|
|
||||||
#if SIMPLSHARP
|
#if SIMPLSHARP
|
||||||
[Test]
|
[Test]
|
||||||
@@ -181,19 +197,19 @@ namespace ICD.Common.Utils.Tests.Extensions
|
|||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void PrependManyTest()
|
public void PrependManyTest()
|
||||||
{
|
{
|
||||||
int[] values = (new[] { 4, 5, 6 }).PrependMany(1, 2, 3).ToArray();
|
int[] values = (new[] {4, 5, 6}).PrependMany(1, 2, 3).ToArray();
|
||||||
|
|
||||||
Assert.AreEqual(6, values.Length);
|
Assert.AreEqual(6, values.Length);
|
||||||
Assert.AreEqual(1, values[0]);
|
Assert.AreEqual(1, values[0]);
|
||||||
Assert.AreEqual(2, values[1]);
|
Assert.AreEqual(2, values[1]);
|
||||||
Assert.AreEqual(3, values[2]);
|
Assert.AreEqual(3, values[2]);
|
||||||
Assert.AreEqual(4, values[3]);
|
Assert.AreEqual(4, values[3]);
|
||||||
Assert.AreEqual(5, values[4]);
|
Assert.AreEqual(5, values[4]);
|
||||||
Assert.AreEqual(6, values[5]);
|
Assert.AreEqual(6, values[5]);
|
||||||
}
|
}
|
||||||
|
|
||||||
#if SIMPLSHARP
|
#if SIMPLSHARP
|
||||||
[Test]
|
[Test]
|
||||||
@@ -203,224 +219,230 @@ namespace ICD.Common.Utils.Tests.Extensions
|
|||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void AppendManyTest()
|
public void AppendManyTest()
|
||||||
{
|
{
|
||||||
int[] values = (new[] { 1, 2, 3 }).AppendMany(4, 5, 6).ToArray();
|
int[] values = (new[] {1, 2, 3}).AppendMany(4, 5, 6).ToArray();
|
||||||
|
|
||||||
Assert.AreEqual(6, values.Length);
|
Assert.AreEqual(6, values.Length);
|
||||||
Assert.AreEqual(1, values[0]);
|
Assert.AreEqual(1, values[0]);
|
||||||
Assert.AreEqual(2, values[1]);
|
Assert.AreEqual(2, values[1]);
|
||||||
Assert.AreEqual(3, values[2]);
|
Assert.AreEqual(3, values[2]);
|
||||||
Assert.AreEqual(4, values[3]);
|
Assert.AreEqual(4, values[3]);
|
||||||
Assert.AreEqual(5, values[4]);
|
Assert.AreEqual(5, values[4]);
|
||||||
Assert.AreEqual(6, values[5]);
|
Assert.AreEqual(6, values[5]);
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void OrderTest()
|
public void OrderTest()
|
||||||
{
|
{
|
||||||
int[] values = (new[] { 2, 3, 1 }).Order().ToArray();
|
int[] values = (new[] {2, 3, 1}).Order().ToArray();
|
||||||
|
|
||||||
Assert.AreEqual(3, values.Length);
|
Assert.AreEqual(3, values.Length);
|
||||||
Assert.AreEqual(1, values[0]);
|
Assert.AreEqual(1, values[0]);
|
||||||
Assert.AreEqual(2, values[1]);
|
Assert.AreEqual(2, values[1]);
|
||||||
Assert.AreEqual(3, values[2]);
|
Assert.AreEqual(3, values[2]);
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void ExceptTest()
|
public void ExceptTest()
|
||||||
{
|
{
|
||||||
int[] values = (new[] { 1, 2, 3 }).Except(2).ToArray();
|
int[] values = (new[] {1, 2, 3}).Except(2).ToArray();
|
||||||
|
|
||||||
Assert.AreEqual(2, values.Length);
|
Assert.AreEqual(2, values.Length);
|
||||||
Assert.AreEqual(1, values[0]);
|
Assert.AreEqual(1, values[0]);
|
||||||
Assert.AreEqual(3, values[1]);
|
Assert.AreEqual(3, values[1]);
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void ToHashSetTest()
|
public void ToHashSetTest()
|
||||||
{
|
{
|
||||||
IcdHashSet<int> values = (new[] { 1, 2, 3 }).ToHashSet();
|
IcdHashSet<int> values = (new[] {1, 2, 3}).ToHashSet();
|
||||||
|
|
||||||
Assert.AreEqual(3, values.Count);
|
Assert.AreEqual(3, values.Count);
|
||||||
Assert.IsTrue(values.Contains(1));
|
Assert.IsTrue(values.Contains(1));
|
||||||
Assert.IsTrue(values.Contains(2));
|
Assert.IsTrue(values.Contains(2));
|
||||||
Assert.IsTrue(values.Contains(3));
|
Assert.IsTrue(values.Contains(3));
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void ToDictionaryIntTest()
|
public void ToDictionaryIntTest()
|
||||||
{
|
{
|
||||||
Dictionary<int, int> values = (new[] { 1, 2, 3 }).ToDictionary();
|
Dictionary<int, int> values = (new[] {1, 2, 3}).ToDictionary();
|
||||||
|
|
||||||
Assert.AreEqual(3, values.Count);
|
Assert.AreEqual(3, values.Count);
|
||||||
Assert.AreEqual(1, values[0]);
|
Assert.AreEqual(1, values[0]);
|
||||||
Assert.AreEqual(2, values[1]);
|
Assert.AreEqual(2, values[1]);
|
||||||
Assert.AreEqual(3, values[2]);
|
Assert.AreEqual(3, values[2]);
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void ToDictionaryUIntTest()
|
public void ToDictionaryUIntTest()
|
||||||
{
|
{
|
||||||
Dictionary<uint, int> values = (new[] { 1, 2, 3 }).ToDictionaryUInt();
|
Dictionary<uint, int> values = (new[] {1, 2, 3}).ToDictionaryUInt();
|
||||||
|
|
||||||
Assert.AreEqual(3, values.Count);
|
Assert.AreEqual(3, values.Count);
|
||||||
Assert.AreEqual(1, values[0]);
|
Assert.AreEqual(1, values[0]);
|
||||||
Assert.AreEqual(2, values[1]);
|
Assert.AreEqual(2, values[1]);
|
||||||
Assert.AreEqual(3, values[2]);
|
Assert.AreEqual(3, values[2]);
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void ToDictionaryTest()
|
public void ToDictionaryTest()
|
||||||
{
|
{
|
||||||
KeyValuePair<int, string>[] items =
|
KeyValuePair<int, string>[] items =
|
||||||
{
|
{
|
||||||
new KeyValuePair<int, string>(0, "A"),
|
new KeyValuePair<int, string>(0, "A"),
|
||||||
new KeyValuePair<int, string>(1, "B"),
|
new KeyValuePair<int, string>(1, "B"),
|
||||||
new KeyValuePair<int, string>(2, "C")
|
new KeyValuePair<int, string>(2, "C")
|
||||||
};
|
};
|
||||||
|
|
||||||
Dictionary<int, string> values = items.ToDictionary();
|
Dictionary<int, string> values = items.ToDictionary();
|
||||||
|
|
||||||
Assert.AreEqual(3, values.Count);
|
Assert.AreEqual(3, values.Count);
|
||||||
Assert.AreEqual("A", values[0]);
|
Assert.AreEqual("A", values[0]);
|
||||||
Assert.AreEqual("B", values[1]);
|
Assert.AreEqual("B", values[1]);
|
||||||
Assert.AreEqual("C", values[2]);
|
Assert.AreEqual("C", values[2]);
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void UnanimousTest()
|
public void UnanimousTest()
|
||||||
{
|
{
|
||||||
Assert.IsTrue((new[] { true, true, true}).Unanimous());
|
Assert.IsTrue((new[] {true, true, true}).Unanimous());
|
||||||
Assert.IsTrue((new[] { false, false, false }).Unanimous());
|
Assert.IsTrue((new[] {false, false, false}).Unanimous());
|
||||||
Assert.IsFalse((new[] { false, true, false }).Unanimous());
|
Assert.IsFalse((new[] {false, true, false}).Unanimous());
|
||||||
Assert.IsFalse((new bool[] { }).Unanimous());
|
Assert.IsFalse((new bool[] { }).Unanimous());
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void UnanimousOtherTest()
|
public void UnanimousOtherTest()
|
||||||
{
|
{
|
||||||
Assert.AreEqual("A", (new[] { "A", "A", "A" }).Unanimous("B"));
|
Assert.AreEqual("A", (new[] {"A", "A", "A"}).Unanimous("B"));
|
||||||
Assert.AreEqual("C", (new[] { "B", "A", "B" }).Unanimous("C"));
|
Assert.AreEqual("C", (new[] {"B", "A", "B"}).Unanimous("C"));
|
||||||
Assert.AreEqual("A", (new string[] { }).Unanimous("A"));
|
Assert.AreEqual("A", (new string[] { }).Unanimous("A"));
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void PartitionTest()
|
public void PartitionTest()
|
||||||
{
|
{
|
||||||
int[][] items = (new[] { 1, 2, 3, 4, 5, 6, 7, 8 }).Partition(3)
|
int[][] items = (new[] {1, 2, 3, 4, 5, 6, 7, 8}).Partition(3)
|
||||||
.Select(p => p.ToArray())
|
.Select(p => p.ToArray())
|
||||||
.ToArray();
|
.ToArray();
|
||||||
|
|
||||||
Assert.AreEqual(3, items.Length);
|
Assert.AreEqual(3, items.Length);
|
||||||
|
|
||||||
Assert.AreEqual(3, items[0].Length);
|
Assert.AreEqual(3, items[0].Length);
|
||||||
Assert.AreEqual(3, items[1].Length);
|
Assert.AreEqual(3, items[1].Length);
|
||||||
Assert.AreEqual(2, items[2].Length);
|
Assert.AreEqual(2, items[2].Length);
|
||||||
|
|
||||||
Assert.AreEqual(1, items[0][0]);
|
Assert.AreEqual(1, items[0][0]);
|
||||||
Assert.AreEqual(2, items[0][1]);
|
Assert.AreEqual(2, items[0][1]);
|
||||||
Assert.AreEqual(3, items[0][2]);
|
Assert.AreEqual(3, items[0][2]);
|
||||||
|
|
||||||
Assert.AreEqual(4, items[1][0]);
|
Assert.AreEqual(4, items[1][0]);
|
||||||
Assert.AreEqual(5, items[1][1]);
|
Assert.AreEqual(5, items[1][1]);
|
||||||
Assert.AreEqual(6, items[1][2]);
|
Assert.AreEqual(6, items[1][2]);
|
||||||
|
|
||||||
Assert.AreEqual(7, items[2][0]);
|
Assert.AreEqual(7, items[2][0]);
|
||||||
Assert.AreEqual(8, items[2][1]);
|
Assert.AreEqual(8, items[2][1]);
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void GetAdjacentPairsTest()
|
public void GetAdjacentPairsTest()
|
||||||
{
|
{
|
||||||
IEnumerable<int> a = new int[] {};
|
IEnumerable<int> a = new int[] { };
|
||||||
Assert.AreEqual(0, a.GetAdjacentPairs().Count());
|
Assert.AreEqual(0, a.GetAdjacentPairs().Count());
|
||||||
|
|
||||||
IEnumerable<int> b = new[] { 1 };
|
IEnumerable<int> b = new[] {1};
|
||||||
Assert.AreEqual(0, b.GetAdjacentPairs().Count());
|
Assert.AreEqual(0, b.GetAdjacentPairs().Count());
|
||||||
|
|
||||||
IEnumerable<int> c = new[] { 1, 2, 3 };
|
IEnumerable<int> c = new[] {1, 2, 3};
|
||||||
int[][] cPairs = c.GetAdjacentPairs().ToArray();
|
int[][] cPairs = c.GetAdjacentPairs().ToArray();
|
||||||
|
|
||||||
Assert.AreEqual(2, cPairs.Length);
|
Assert.AreEqual(2, cPairs.Length);
|
||||||
Assert.AreEqual(1, cPairs[0][0]);
|
Assert.AreEqual(1, cPairs[0][0]);
|
||||||
Assert.AreEqual(2, cPairs[0][1]);
|
Assert.AreEqual(2, cPairs[0][1]);
|
||||||
Assert.AreEqual(2, cPairs[1][0]);
|
Assert.AreEqual(2, cPairs[1][0]);
|
||||||
Assert.AreEqual(3, cPairs[1][1]);
|
Assert.AreEqual(3, cPairs[1][1]);
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void MinByTest()
|
public void GetClosestTest()
|
||||||
{
|
{
|
||||||
Assert.AreEqual(1, new[] { 3, 6, 2, 7, 1 }.MinBy(i => i));
|
Assert.AreEqual(20, new[] {10, 15, 20, 30, 35}.GetClosest(i => i - 21));
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void MinByComparerTest()
|
public void MinByTest()
|
||||||
{
|
{
|
||||||
IComparer<int> comparer = new NegativeComparer();
|
Assert.AreEqual(1, new[] {3, 6, 2, 7, 1}.MinBy(i => i));
|
||||||
Assert.AreEqual(7, new[] { 3, 6, 2, 7, 1 }.MinBy(i => i, comparer));
|
}
|
||||||
}
|
|
||||||
|
|
||||||
private class NegativeComparer : IComparer<int>
|
[Test]
|
||||||
{
|
public void MinByComparerTest()
|
||||||
public int Compare(int x, int y)
|
{
|
||||||
{
|
IComparer<int> comparer = new NegativeComparer();
|
||||||
return Comparer<int>.Default.Compare(-x, -y);
|
Assert.AreEqual(7, new[] {3, 6, 2, 7, 1}.MinBy(i => i, comparer));
|
||||||
}
|
}
|
||||||
}
|
|
||||||
|
|
||||||
[Test]
|
private class NegativeComparer : IComparer<int>
|
||||||
public void ExceptNullsTest()
|
{
|
||||||
{
|
public int Compare(int x, int y)
|
||||||
IEnumerable<int?> sequence = new int?[] { 1, 2, null, 3, 4, null };
|
{
|
||||||
int[] result = sequence.ExceptNulls().ToArray();
|
return Comparer<int>.Default.Compare(-x, -y);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
Assert.AreEqual(4, result.Length);
|
[Test]
|
||||||
Assert.AreEqual(1, result[0]);
|
public void ExceptNullsTest()
|
||||||
Assert.AreEqual(2, result[1]);
|
{
|
||||||
Assert.AreEqual(3, result[2]);
|
IEnumerable<int?> sequence = new int?[] {1, 2, null, 3, 4, null};
|
||||||
Assert.AreEqual(4, result[3]);
|
int[] result = sequence.ExceptNulls().ToArray();
|
||||||
}
|
|
||||||
|
|
||||||
[Test]
|
Assert.AreEqual(4, result.Length);
|
||||||
public void SumTest()
|
Assert.AreEqual(1, result[0]);
|
||||||
{
|
Assert.AreEqual(2, result[1]);
|
||||||
IEnumerable<byte> sequence = new byte[] { 1, 2, 3, 4 };
|
Assert.AreEqual(3, result[2]);
|
||||||
Assert.AreEqual(10, sequence.Sum());
|
Assert.AreEqual(4, result[3]);
|
||||||
}
|
}
|
||||||
|
|
||||||
[Test]
|
[Test]
|
||||||
public void ConsolidateTest()
|
public void SumTest()
|
||||||
{
|
{
|
||||||
string[] sequence = EnumerableExtensions.Consolidate(new[] { "A", "B", "B", "C" }).ToArray();
|
IEnumerable<byte> sequence = new byte[] {1, 2, 3, 4};
|
||||||
|
Assert.AreEqual(10, sequence.Sum());
|
||||||
|
}
|
||||||
|
|
||||||
Assert.AreEqual(3, sequence.Length, StringUtils.ArrayFormat(sequence));
|
[Test]
|
||||||
Assert.AreEqual("A", sequence[0]);
|
public void ConsolidateTest()
|
||||||
Assert.AreEqual("B", sequence[1]);
|
{
|
||||||
Assert.AreEqual("C", sequence[2]);
|
string[] sequence = EnumerableExtensions.Consolidate(new[] {"A", "B", "B", "C"}).ToArray();
|
||||||
}
|
|
||||||
|
|
||||||
[Test]
|
Assert.AreEqual(3, sequence.Length, StringUtils.ArrayFormat(sequence));
|
||||||
public void ConsolidateComparerTest()
|
Assert.AreEqual("A", sequence[0]);
|
||||||
{
|
Assert.AreEqual("B", sequence[1]);
|
||||||
string[] sequence = EnumerableExtensions.Consolidate(new[] { "A", "B", "B", "C" }, Comparer<string>.Default).ToArray();
|
Assert.AreEqual("C", sequence[2]);
|
||||||
|
}
|
||||||
|
|
||||||
Assert.AreEqual(3, sequence.Length, StringUtils.ArrayFormat(sequence));
|
[Test]
|
||||||
Assert.AreEqual("A", sequence[0]);
|
public void ConsolidateComparerTest()
|
||||||
Assert.AreEqual("B", sequence[1]);
|
{
|
||||||
Assert.AreEqual("C", sequence[2]);
|
string[] sequence = EnumerableExtensions.Consolidate(new[] {"A", "B", "B", "C"}, Comparer<string>.Default).ToArray();
|
||||||
}
|
|
||||||
|
|
||||||
[Test]
|
Assert.AreEqual(3, sequence.Length, StringUtils.ArrayFormat(sequence));
|
||||||
public void AnyAndAllTest()
|
Assert.AreEqual("A", sequence[0]);
|
||||||
{
|
Assert.AreEqual("B", sequence[1]);
|
||||||
IEnumerable<int> sequence = new[] { 1, 2, 3, 4 };
|
Assert.AreEqual("C", sequence[2]);
|
||||||
|
}
|
||||||
|
|
||||||
Assert.IsTrue(sequence.AnyAndAll(i => i > 0));
|
[Test]
|
||||||
Assert.IsFalse(sequence.AnyAndAll(i => i < 0));
|
public void AnyAndAllTest()
|
||||||
Assert.IsFalse(Enumerable.Empty<int>().AnyAndAll(i => i > 0));
|
{
|
||||||
}
|
IEnumerable<int> sequence = new[] {1, 2, 3, 4};
|
||||||
}
|
|
||||||
|
Assert.IsTrue(sequence.AnyAndAll(i => i > 0));
|
||||||
|
Assert.IsFalse(sequence.AnyAndAll(i => i < 0));
|
||||||
|
Assert.IsFalse(Enumerable.Empty<int>().AnyAndAll(i => i > 0));
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -226,6 +226,24 @@ namespace ICD.Common.Utils.Extensions
|
|||||||
/// <param name="match"></param>
|
/// <param name="match"></param>
|
||||||
/// <returns></returns>
|
/// <returns></returns>
|
||||||
public static int FindIndex<T>(this IEnumerable<T> extends, Predicate<T> match)
|
public static int FindIndex<T>(this IEnumerable<T> extends, Predicate<T> match)
|
||||||
|
{
|
||||||
|
if (extends == null)
|
||||||
|
throw new ArgumentNullException("extends");
|
||||||
|
|
||||||
|
if (match == null)
|
||||||
|
throw new ArgumentNullException("match");
|
||||||
|
|
||||||
|
return extends.FindIndices(match).FirstOrDefault(-1);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Returns the indices that match the predicate.
|
||||||
|
/// </summary>
|
||||||
|
/// <typeparam name="T"></typeparam>
|
||||||
|
/// <param name="extends"></param>
|
||||||
|
/// <param name="match"></param>
|
||||||
|
/// <returns></returns>
|
||||||
|
public static IEnumerable<int> FindIndices<T>(this IEnumerable<T> extends, Predicate<T> match)
|
||||||
{
|
{
|
||||||
if (extends == null)
|
if (extends == null)
|
||||||
throw new ArgumentNullException("extends");
|
throw new ArgumentNullException("extends");
|
||||||
@@ -238,11 +256,9 @@ namespace ICD.Common.Utils.Extensions
|
|||||||
foreach (T item in extends)
|
foreach (T item in extends)
|
||||||
{
|
{
|
||||||
if (match(item))
|
if (match(item))
|
||||||
return index;
|
yield return index;
|
||||||
index++;
|
index++;
|
||||||
}
|
}
|
||||||
|
|
||||||
return -1;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
@@ -583,6 +599,18 @@ namespace ICD.Common.Utils.Extensions
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gets the item from the sequence with the smallest calculated delta.
|
||||||
|
/// </summary>
|
||||||
|
/// <typeparam name="T"></typeparam>
|
||||||
|
/// <param name="extends"></param>
|
||||||
|
/// <param name="getDelta"></param>
|
||||||
|
/// <returns></returns>
|
||||||
|
public static T GetClosest<T>(this IEnumerable<T> extends, Func<T, int> getDelta)
|
||||||
|
{
|
||||||
|
return extends.MinBy(n => Math.Abs(getDelta(n)));
|
||||||
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Returns the minimal element of the given sequence, based on
|
/// Returns the minimal element of the given sequence, based on
|
||||||
/// the given projection.
|
/// the given projection.
|
||||||
|
|||||||
Reference in New Issue
Block a user