Skip to content

Commit a5d96b9

Browse files
MrMatthewLaytonMrMatthewLayton
authored
update/cleanup (#44)
Added `FirstOrNone`, `LastOrNone` and `SingleOrNone` for LINQ, bugfix for `BigDecimal` and `NumberInfo` equality and corresponding tests, and some formatting changes.
1 parent 5b167d5 commit a5d96b9

File tree

101 files changed

+813
-1501
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

101 files changed

+813
-1501
lines changed

‎OnixLabs.Core.UnitTests/Linq/IEnumerableExtensionTests.cs

+202-1
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,6 @@
1515
using System;
1616
using System.Collections.Generic;
1717
using System.Globalization;
18-
using System.Linq;
1918
using System.Numerics;
2019
using OnixLabs.Core.Linq;
2120
using OnixLabs.Core.UnitTests.Data;
@@ -107,6 +106,62 @@ public void CountNotShouldProduceExpectedResult()
107106
Assert.Equal(expected, actual);
108107
}
109108

109+
[Fact(DisplayName = "IEnumerable.FirstOrNone should return none when the enumerable is empty.")]
110+
public void FirstOrNoneShouldReturnNoneWhenEnumerableIsEmpty()
111+
{
112+
// Given
113+
IEnumerable<int> elements = [];
114+
Optional<int> expected = Optional<int>.None;
115+
116+
// When
117+
Optional<int> actual = elements.FirstOrNone();
118+
119+
// Then
120+
Assert.Equal(expected, actual);
121+
}
122+
123+
[Fact(DisplayName = "IEnumerable.FirstOrNone should return the first element when the collection is not empty.")]
124+
public void FirstOrNoneShouldReturnFirstElementWhenCollectionIsNotEmpty()
125+
{
126+
// Given
127+
IEnumerable<int> elements = [1, 2, 3];
128+
Optional<int> expected = 1;
129+
130+
// When
131+
Optional<int> actual = elements.FirstOrNone();
132+
133+
// Then
134+
Assert.Equal(expected, actual);
135+
}
136+
137+
[Fact(DisplayName = "IEnumerable.FirstOrNone should return the first element matching the predicate when the collection is not empty.")]
138+
public void FirstOrNoneShouldReturnFirstElementMatchingPredicateWhenCollectionIsNotEmpty()
139+
{
140+
// Given
141+
IEnumerable<int> elements = [1, 2, 3];
142+
Optional<int> expected = 2;
143+
144+
// When
145+
Optional<int> actual = elements.FirstOrNone(number => number > 1);
146+
147+
// Then
148+
Assert.Equal(expected, actual);
149+
}
150+
151+
[Fact(DisplayName = "IEnumerable.FirstOrNone should return none when no element matches the predicate and the collection is not empty.")]
152+
public void FirstOrNoneShouldReturnNoneWhenNoElementMatchesPredicateAndCollectionIsNotEmpty()
153+
{
154+
// Given
155+
IEnumerable<int> elements = [1, 2, 3];
156+
Optional<int> expected = Optional<int>.None;
157+
158+
// When
159+
Optional<int> actual = elements.FirstOrNone(number => number > 3);
160+
161+
// Then
162+
Assert.Equal(expected, actual);
163+
}
164+
110165
[Fact(DisplayName = "IEnumerable.ForEach should iterate over every element in the enumerable")]
111166
public void ForEachShouldProduceExpectedResult()
112167
{
@@ -321,6 +376,62 @@ public void JoinToStringShouldProduceExpectedResultWithCustomSeparator()
321376
Assert.Equal(expected, actual);
322377
}
323378

379+
[Fact(DisplayName = "IEnumerable.LastOrNone should return none when the enumerable is empty.")]
380+
public void LastOrNoneShouldReturnNoneWhenEnumerableIsEmpty()
381+
{
382+
// Given
383+
IEnumerable<int> elements = [];
384+
Optional<int> expected = Optional<int>.None;
385+
386+
// When
387+
Optional<int> actual = elements.LastOrNone();
388+
389+
// Then
390+
Assert.Equal(expected, actual);
391+
}
392+
393+
[Fact(DisplayName = "IEnumerable.LastOrNone should return the last element when the collection is not empty.")]
394+
public void LastOrNoneShouldReturnLastElementWhenCollectionIsNotEmpty()
395+
{
396+
// Given
397+
IEnumerable<int> elements = [1, 2, 3];
398+
Optional<int> expected = 3;
399+
400+
// When
401+
Optional<int> actual = elements.LastOrNone();
402+
403+
// Then
404+
Assert.Equal(expected, actual);
405+
}
406+
407+
[Fact(DisplayName = "IEnumerable.LastOrNone should return the last element matching the predicate when the collection is not empty.")]
408+
public void LastOrNoneShouldReturnFirstElementMatchingPredicateWhenCollectionIsNotEmpty()
409+
{
410+
// Given
411+
IEnumerable<int> elements = [1, 2, 3];
412+
Optional<int> expected = 3;
413+
414+
// When
415+
Optional<int> actual = elements.LastOrNone(number => number > 1);
416+
417+
// Then
418+
Assert.Equal(expected, actual);
419+
}
420+
421+
[Fact(DisplayName = "IEnumerable.LastOrNone should return none when no element matches the predicate and the collection is not empty.")]
422+
public void LastOrNoneShouldReturnNoneWhenNoElementMatchesPredicateAndCollectionIsNotEmpty()
423+
{
424+
// Given
425+
IEnumerable<int> elements = [1, 2, 3];
426+
Optional<int> expected = Optional<int>.None;
427+
428+
// When
429+
Optional<int> actual = elements.LastOrNone(number => number > 3);
430+
431+
// Then
432+
Assert.Equal(expected, actual);
433+
}
434+
324435
[Fact(DisplayName = "IEnumerable.None should return true when none of the elements satisfy the specified predicate condition")]
325436
public void NoneShouldProduceExpectedResultTrue()
326437
{
@@ -369,6 +480,96 @@ public void NoneShouldProduceExpectedResultFalseAll()
369480
Assert.False(result);
370481
}
371482

483+
[Fact(DisplayName = "IEnumerable.SingleOrNone should return success none when the enumerable contains no elements.")]
484+
public void SingleOrNoneShouldReturnSuccessNoneWhenEnumerableContainsNoElements()
485+
{
486+
// Given
487+
IEnumerable<int> elements = [];
488+
Result<Optional<int>> expected = Optional<int>.None.ToResult();
489+
490+
// When
491+
Result<Optional<int>> actual = elements.SingleOrNone();
492+
493+
// Then
494+
Assert.Equal(expected, actual);
495+
}
496+
497+
[Fact(DisplayName = "IEnumerable.SingleOrNone should return success some when the enumerable contains a single element.")]
498+
public void SingleOrNoneShouldReturnSuccessSomeWhenEnumerableContainsSingleElement()
499+
{
500+
// Given
501+
IEnumerable<int> elements = [1];
502+
Result<Optional<int>> expected = Optional<int>.Some(1).ToResult();
503+
504+
// When
505+
Result<Optional<int>> actual = elements.SingleOrNone();
506+
507+
// Then
508+
Assert.Equal(expected, actual);
509+
}
510+
511+
[Fact(DisplayName = "IEnumerable.SingleOrNone should return failure when the enumerable contains more than one element.")]
512+
public void SingleOrNoneShouldReturnFailureSomeWhenEnumerableContainsMoreThanOneElement()
513+
{
514+
// Given
515+
IEnumerable<int> elements = [1, 2, 3];
516+
Failure<Optional<int>> expected = Result<Optional<int>>.Failure(new InvalidOperationException("Sequence contains more than one matching element"));
517+
518+
// When
519+
Result<Optional<int>> actual = elements.SingleOrNone();
520+
Exception actualException = Assert.Throws<InvalidOperationException>(actual.Throw);
521+
522+
// Then
523+
Assert.True(actual is Failure<Optional<int>>);
524+
Assert.Equal(expected.Exception.GetType(), actualException.GetType());
525+
Assert.Equal(expected.Exception.Message, actualException.Message);
526+
}
527+
528+
[Fact(DisplayName = "IEnumerable.SingleOrNone should return success none when the enumerable contains no elements matching the predicate.")]
529+
public void SingleOrNoneShouldReturnSuccessNoneWhenEnumerableContainsNoElementsMatchingPredicate()
530+
{
531+
// Given
532+
IEnumerable<int> elements = [1, 2, 3];
533+
Result<Optional<int>> expected = Optional<int>.None.ToResult();
534+
535+
// When
536+
Result<Optional<int>> actual = elements.SingleOrNone(number => number > 3);
537+
538+
// Then
539+
Assert.Equal(expected, actual);
540+
}
541+
542+
[Fact(DisplayName = "IEnumerable.SingleOrNone should return success some when the enumerable contains a single element matching the predicate.")]
543+
public void SingleOrNoneShouldReturnSuccessSomeWhenEnumerableContainsSingleElementMatchingPredicate()
544+
{
545+
// Given
546+
IEnumerable<int> elements = [1, 2, 3];
547+
Result<Optional<int>> expected = Optional<int>.Some(1).ToResult();
548+
549+
// When
550+
Result<Optional<int>> actual = elements.SingleOrNone(number => number < 2);
551+
552+
// Then
553+
Assert.Equal(expected, actual);
554+
}
555+
556+
[Fact(DisplayName = "IEnumerable.SingleOrNone should return failure when the enumerable contains more than one element matching the predicate.")]
557+
public void SingleOrNoneShouldReturnFailureSomeWhenEnumerableContainsMoreThanOneElementMatchingPredidate()
558+
{
559+
// Given
560+
IEnumerable<int> elements = [1, 2, 3];
561+
Failure<Optional<int>> expected = Result<Optional<int>>.Failure(new InvalidOperationException("Sequence contains more than one matching element"));
562+
563+
// When
564+
Result<Optional<int>> actual = elements.SingleOrNone(number => number > 1);
565+
Exception actualException = Assert.Throws<InvalidOperationException>(actual.Throw);
566+
567+
// Then
568+
Assert.True(actual is Failure<Optional<int>>);
569+
Assert.Equal(expected.Exception.GetType(), actualException.GetType());
570+
Assert.Equal(expected.Exception.Message, actualException.Message);
571+
}
572+
372573
[Fact(DisplayName = "IEnumerable.Sum should produce the expected result")]
373574
public void SumShouldProduceExpectedResult()
374575
{

‎OnixLabs.Core/Enumeration.Comparable.cs

+2-8
Original file line numberDiff line numberDiff line change
@@ -23,10 +23,7 @@ public abstract partial class Enumeration<T>
2323
/// </summary>
2424
/// <param name="other">An object to compare with the current instance.</param>
2525
/// <returns>Returns a value that indicates the relative order of the objects being compared.</returns>
26-
public int CompareTo(T? other)
27-
{
28-
return Value.CompareTo(other?.Value);
29-
}
26+
public int CompareTo(T? other) => Value.CompareTo(other?.Value);
3027

3128
/// <summary>
3229
/// Compares the current instance with another object of the same type and returns an integer that indicates
@@ -35,8 +32,5 @@ public int CompareTo(T? other)
3532
/// </summary>
3633
/// <param name="obj">An object to compare with the current instance.</param>
3734
/// <returns>Returns a value that indicates the relative order of the objects being compared.</returns>
38-
public int CompareTo(object? obj)
39-
{
40-
return this.CompareToObject(obj);
41-
}
35+
public int CompareTo(object? obj) => this.CompareToObject(obj);
4236
}

‎OnixLabs.Core/Enumeration.Equatable.cs

+4-16
Original file line numberDiff line numberDiff line change
@@ -37,39 +37,27 @@ public bool Equals(T? other)
3737
/// </summary>
3838
/// <param name="obj">The object to check for equality.</param>
3939
/// <returns>Returns <see langword="true"/> if the object is equal to the current instance; otherwise, <see langword="false"/>.</returns>
40-
public override bool Equals(object? obj)
41-
{
42-
return Equals(obj as T);
43-
}
40+
public override bool Equals(object? obj) => Equals(obj as T);
4441

4542
/// <summary>
4643
/// Serves as a hash code function for the current instance.
4744
/// </summary>
4845
/// <returns>Returns a hash code for the current instance.</returns>
49-
public override int GetHashCode()
50-
{
51-
return HashCode.Combine(GetType(), Name, Value);
52-
}
46+
public override int GetHashCode() => HashCode.Combine(GetType(), Name, Value);
5347

5448
/// <summary>
5549
/// Performs an equality comparison between two object instances.
5650
/// </summary>
5751
/// <param name="left">The left-hand instance to compare.</param>
5852
/// <param name="right">The right-hand instance to compare.</param>
5953
/// <returns>Returns <see langword="true"/> if the left-hand instance is equal to the right-hand instance; otherwise, <see langword="false"/>.</returns>
60-
public static bool operator ==(Enumeration<T> left, Enumeration<T> right)
61-
{
62-
return Equals(left, right);
63-
}
54+
public static bool operator ==(Enumeration<T> left, Enumeration<T> right) => Equals(left, right);
6455

6556
/// <summary>
6657
/// Performs an inequality comparison between two object instances.
6758
/// </summary>
6859
/// <param name="left">The left-hand instance to compare.</param>
6960
/// <param name="right">The right-hand instance to compare.</param>
7061
/// <returns>Returns <see langword="true"/> if the left-hand instance is not equal to the right-hand instance; otherwise, <see langword="false"/>.</returns>
71-
public static bool operator !=(Enumeration<T> left, Enumeration<T> right)
72-
{
73-
return !Equals(left, right);
74-
}
62+
public static bool operator !=(Enumeration<T> left, Enumeration<T> right) => !Equals(left, right);
7563
}

‎OnixLabs.Core/Enumeration.Get.cs

+3-12
Original file line numberDiff line numberDiff line change
@@ -38,26 +38,17 @@ public static IReadOnlySet<T> GetAll()
3838
/// Gets all of the enumeration entries for the current type.
3939
/// </summary>
4040
/// <returns>Returns all of the enumeration entries for the current type.</returns>
41-
public static IReadOnlySet<(int Value, string Name)> GetEntries()
42-
{
43-
return GetAll().Select(entry => entry.ToEntry()).ToFrozenSet();
44-
}
41+
public static IReadOnlySet<(int Value, string Name)> GetEntries() => GetAll().Select(entry => entry.ToEntry()).ToFrozenSet();
4542

4643
/// <summary>
4744
/// Gets all of the enumeration names for the current type.
4845
/// </summary>
4946
/// <returns>Returns all of the enumeration names for the current type.</returns>
50-
public static IReadOnlySet<string> GetNames()
51-
{
52-
return GetAll().Select(entry => entry.Name).ToFrozenSet();
53-
}
47+
public static IReadOnlySet<string> GetNames() => GetAll().Select(entry => entry.Name).ToFrozenSet();
5448

5549
/// <summary>
5650
/// Gets all of the enumeration values for the current type.
5751
/// </summary>
5852
/// <returns>Returns all of the enumeration values for the current type.</returns>
59-
public static IReadOnlySet<int> GetValues()
60-
{
61-
return GetAll().Select(entry => entry.Value).ToFrozenSet();
62-
}
53+
public static IReadOnlySet<int> GetValues() => GetAll().Select(entry => entry.Value).ToFrozenSet();
6354
}

‎OnixLabs.Core/Enumeration.To.cs

+2-8
Original file line numberDiff line numberDiff line change
@@ -22,17 +22,11 @@ public abstract partial class Enumeration<T>
2222
/// Returns a <see cref="ValueTuple{T1,T2}"/> that represents the current object.
2323
/// </summary>
2424
/// <returns>Returns a tuple that represents the current object.</returns>
25-
public (int Value, string Name) ToEntry()
26-
{
27-
return (Value, Name);
28-
}
25+
public (int Value, string Name) ToEntry() => (Value, Name);
2926

3027
/// <summary>
3128
/// Returns a <see cref="String"/> that represents the current object.
3229
/// </summary>
3330
/// <returns>Returns a <see cref="String"/> that represents the current object.</returns>
34-
public override string ToString()
35-
{
36-
return Name;
37-
}
31+
public override string ToString() => Name;
3832
}

‎OnixLabs.Core/Extensions.Array.cs

+3-12
Original file line numberDiff line numberDiff line change
@@ -28,10 +28,7 @@ public static class ArrayExtensions
2828
/// <param name="array">The current <see cref="T:T[]"/> to copy.</param>
2929
/// <typeparam name="T">The underlying type of the array.</typeparam>
3030
/// <returns>Returns an exact copy of the current <see cref="T:T[]"/>.</returns>
31-
public static T[] Copy<T>(this T[] array)
32-
{
33-
return [..array];
34-
}
31+
public static T[] Copy<T>(this T[] array) => [..array];
3532

3633
/// <summary>
3734
/// Creates a copy of the current <see cref="T:T[]"/>.
@@ -41,10 +38,7 @@ public static T[] Copy<T>(this T[] array)
4138
/// <param name="count">The number of elements of the array to copy.</param>
4239
/// <typeparam name="T">The underlying type of the array.</typeparam>
4340
/// <returns>Returns an exact copy of the current <see cref="T:T[]"/>.</returns>
44-
public static T[] Copy<T>(this T[] array, int index, int count)
45-
{
46-
return [..array[index..(index + count)]];
47-
}
41+
public static T[] Copy<T>(this T[] array, int index, int count) => [..array[index..(index + count)]];
4842

4943
/// <summary>
5044
/// Concatenates the current <see cref="T:T[]"/> with another <see cref="T:T[]"/>.
@@ -53,8 +47,5 @@ public static T[] Copy<T>(this T[] array, int index, int count)
5347
/// <param name="other">The other <see cref="T:T[]"/> to concatenate with the source <see cref="T:T[]"/>.</param>
5448
/// <typeparam name="T">The underlying type of the <see cref="T:T[]"/>.</typeparam>
5549
/// <returns>Returns the current <see cref="T:T[]"/> concatenated with the other <see cref="T:T[]"/>.</returns>
56-
public static T[] ConcatenateWith<T>(this T[] array, T[] other)
57-
{
58-
return [..array, ..other];
59-
}
50+
public static T[] ConcatenateWith<T>(this T[] array, T[] other) => [..array, ..other];
6051
}

‎OnixLabs.Core/Extensions.Object.cs

+5-5
Original file line numberDiff line numberDiff line change
@@ -35,12 +35,12 @@ public static class ObjectExtensions
3535
/// <typeparam name="T">The underlying type of the current <see cref="IComparable{T}"/>.</typeparam>
3636
/// <returns>Returns a signed integer that indicates the relative order of the objects being compared.</returns>
3737
/// <exception cref="ArgumentException">If the specified object is not <see langword="null"/>, or of the specified type.</exception>
38-
public static int CompareToObject<T>(this IComparable<T> comparable, object? obj)
38+
public static int CompareToObject<T>(this IComparable<T> comparable, object? obj) => obj switch
3939
{
40-
if (obj is null) return 1;
41-
if (obj is T other) return comparable.CompareTo(other);
42-
throw new ArgumentException($"Object must be of type {typeof(T).Name}", nameof(obj));
43-
}
40+
null => 1,
41+
T other => comparable.CompareTo(other),
42+
_ => throw new ArgumentException($"Object must be of type {typeof(T).Name}", nameof(obj))
43+
};
4444

4545
/// <summary>
4646
/// Gets a record-like <see cref="String"/> representation of the current <see cref="Object"/> instance.

0 commit comments

Comments
 (0)