Skip to content

Commit b6418a4

Browse files
MrMatthewLaytonMrMatthewLayton
committed
Merge branch 'refs/heads/main' into release
2 parents 39b5cc9 + 4fdd399 commit b6418a4

9 files changed

+457
-8
lines changed

‎OnixLabs.Core.UnitTests/OptionalEqualityComparerTests.cs

+177
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,177 @@
1+
// Copyright 2020 ONIXLabs
2+
//
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
14+
15+
using System;
16+
using System.Collections.Generic;
17+
using Xunit;
18+
19+
namespace OnixLabs.Core.UnitTests;
20+
21+
public class OptionalEqualityComparerTests
22+
{
23+
[Fact(DisplayName = "OptionalEqualityComparer.Equals should return true when comparing null values")]
24+
public void OptionalEqualityComparerEqualsShouldReturnTrueWhenComparingNullValues()
25+
{
26+
// Given
27+
Optional<string>? x = null;
28+
Optional<string>? y = null;
29+
OptionalEqualityComparer<string> comparer = new();
30+
31+
// When
32+
bool result = comparer.Equals(x, y);
33+
34+
// Then
35+
Assert.True(result);
36+
}
37+
38+
[Fact(DisplayName = "OptionalEqualityComparer.Equals should return false when comparing null and non-null values")]
39+
public void OptionalEqualityComparerEqualsShouldReturnFalseWhenComparingNullAndNonNullValues()
40+
{
41+
// Given
42+
Optional<string>? x = null;
43+
Optional<string> y = "abc";
44+
OptionalEqualityComparer<string> comparer = new();
45+
46+
// When
47+
bool result1 = comparer.Equals(x, y);
48+
bool result2 = comparer.Equals(y, x);
49+
50+
// Then
51+
Assert.False(result1);
52+
Assert.False(result2);
53+
}
54+
55+
[Fact(DisplayName = "OptionalEqualityComparer.Equals should return true when comparing None values")]
56+
public void OptionalEqualityComparerEqualsShouldReturnTrueWhenComparingNoneValues()
57+
{
58+
// Given
59+
Optional<string> x = Optional<string>.None;
60+
Optional<string> y = Optional<string>.None;
61+
OptionalEqualityComparer<string> comparer = new();
62+
63+
// When
64+
bool result1 = comparer.Equals(x, y);
65+
bool result2 = comparer.Equals(y, x);
66+
67+
// Then
68+
Assert.True(result1);
69+
Assert.True(result2);
70+
}
71+
72+
[Fact(DisplayName = "OptionalEqualityComparer.Equals should return false when comparing None and Some values")]
73+
public void OptionalEqualityComparerEqualsShouldReturnFalseWhenComparingNoneAndSomeValues()
74+
{
75+
// Given
76+
Optional<string> x = Optional<string>.None;
77+
Optional<string> y = "abc";
78+
OptionalEqualityComparer<string> comparer = new();
79+
80+
// When
81+
bool result1 = comparer.Equals(x, y);
82+
bool result2 = comparer.Equals(y, x);
83+
84+
// Then
85+
Assert.False(result1);
86+
Assert.False(result2);
87+
}
88+
89+
[Fact(DisplayName = "OptionalEqualityComparer.Equals should return true when comparing identical Some values")]
90+
public void OptionalEqualityComparerEqualsShouldReturnTrueWhenComparingIdenticalSomeValues()
91+
{
92+
// Given
93+
Optional<string> x = "abc";
94+
Optional<string> y = "abc";
95+
OptionalEqualityComparer<string> comparer = new();
96+
97+
// When
98+
bool result1 = comparer.Equals(x, y);
99+
bool result2 = comparer.Equals(y, x);
100+
101+
// Then
102+
Assert.True(result1);
103+
Assert.True(result2);
104+
}
105+
106+
[Fact(DisplayName = "OptionalEqualityComparer.Equals should return false when comparing non-identical Some values")]
107+
public void OptionalEqualityComparerEqualsShouldReturnFalseWhenComparingNonIdenticalSomeValues()
108+
{
109+
// Given
110+
Optional<string> x = "abc";
111+
Optional<string> y = "xyz";
112+
OptionalEqualityComparer<string> comparer = new();
113+
114+
// When
115+
bool result1 = comparer.Equals(x, y);
116+
bool result2 = comparer.Equals(y, x);
117+
118+
// Then
119+
Assert.False(result1);
120+
Assert.False(result2);
121+
}
122+
123+
[Fact(DisplayName = "OptionalEqualityComparer.Equals should return true when comparing identical Some values with value comparer")]
124+
public void OptionalEqualityComparerEqualsShouldReturnTrueWhenComparingIdenticalSomeValuesWithValueComparer()
125+
{
126+
// Given
127+
Optional<string> x = "abc";
128+
Optional<string> y = "ABC";
129+
OptionalEqualityComparer<string> comparer = new(new CaseInsensitiveStringComparer());
130+
131+
// When
132+
bool result1 = comparer.Equals(x, y);
133+
bool result2 = comparer.Equals(y, x);
134+
135+
// Then
136+
Assert.True(result1);
137+
Assert.True(result2);
138+
}
139+
140+
[Fact(DisplayName = "OptionalEqualityComparer.Equals should return false when comparing non-identical Some values with value comparer")]
141+
public void OptionalEqualityComparerEqualsShouldReturnFalseWhenComparingNonIdenticalSomeValuesWithValueComparer()
142+
{
143+
// Given
144+
Optional<string> x = "abc";
145+
Optional<string> y = "XYZ";
146+
OptionalEqualityComparer<string> comparer = new(new CaseInsensitiveStringComparer());
147+
148+
// When
149+
bool result1 = comparer.Equals(x, y);
150+
bool result2 = comparer.Equals(y, x);
151+
152+
// Then
153+
Assert.False(result1);
154+
Assert.False(result2);
155+
}
156+
157+
[Fact(DisplayName = "OptionalEqualityComparer.GetHashCode should return zero when the optional value is none.")]
158+
public void OptionalEqualityComparerGetHashCodeShouldReturnZeroWhenOptionalValueIsNone()
159+
{
160+
// Given
161+
const int expected = default;
162+
Optional<string> optional = Optional<string>.None;
163+
OptionalEqualityComparer<string> comparer = new();
164+
165+
// When
166+
int actual = comparer.GetHashCode(optional);
167+
168+
// Then
169+
Assert.Equal(expected, actual);
170+
}
171+
172+
private sealed class CaseInsensitiveStringComparer : EqualityComparer<string>
173+
{
174+
public override bool Equals(string? x, string? y) => string.Equals(x, y, StringComparison.InvariantCultureIgnoreCase);
175+
public override int GetHashCode(string obj) => obj.GetHashCode();
176+
}
177+
}

‎OnixLabs.Core.UnitTests/ResultEqualityComparerTests.cs

+164
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,164 @@
1+
// Copyright 2020 ONIXLabs
2+
//
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
14+
15+
using System;
16+
using System.Collections.Generic;
17+
using Xunit;
18+
19+
namespace OnixLabs.Core.UnitTests;
20+
21+
public class ResultEqualityComparerTests
22+
{
23+
[Fact(DisplayName = "ResultEqualityComparer.Equals should return true when comparing null values")]
24+
public void ResultEqualityComparerEqualsShouldReturnTrueWhenComparingNullValues()
25+
{
26+
// Given
27+
Result<string>? x = null;
28+
Result<string>? y = null;
29+
ResultEqualityComparer<string> comparer = new();
30+
31+
// When
32+
bool result = comparer.Equals(x, y);
33+
34+
// Then
35+
Assert.True(result);
36+
}
37+
38+
[Fact(DisplayName = "ResultEqualityComparer.Equals should return false when comparing null and non-null values")]
39+
public void ResultEqualityComparerEqualsShouldReturnFalseWhenComparingNullAndNonNullValues()
40+
{
41+
// Given
42+
Result<string>? x = null;
43+
Result<string> y = "abc";
44+
ResultEqualityComparer<string> comparer = new();
45+
46+
// When
47+
bool result1 = comparer.Equals(x, y);
48+
bool result2 = comparer.Equals(y, x);
49+
50+
// Then
51+
Assert.False(result1);
52+
Assert.False(result2);
53+
}
54+
55+
[Fact(DisplayName = "ResultEqualityComparer.Equals should return true when comparing Failure values")]
56+
public void ResultEqualityComparerEqualsShouldReturnTrueWhenComparingNoneValues()
57+
{
58+
// Given
59+
Exception exception = new("Failure");
60+
Result<string> x = exception;
61+
Result<string> y = exception;
62+
ResultEqualityComparer<string> comparer = new();
63+
64+
// When
65+
bool result1 = comparer.Equals(x, y);
66+
bool result2 = comparer.Equals(y, x);
67+
68+
// Then
69+
Assert.True(result1);
70+
Assert.True(result2);
71+
}
72+
73+
[Fact(DisplayName = "ResultEqualityComparer.Equals should return false when comparing Success and Failure values")]
74+
public void ResultEqualityComparerEqualsShouldReturnFalseWhenComparingNoneAndSomeValues()
75+
{
76+
// Given
77+
Exception exception = new("Failure");
78+
Result<string> x = exception;
79+
Result<string> y = "abc";
80+
ResultEqualityComparer<string> comparer = new();
81+
82+
// When
83+
bool result1 = comparer.Equals(x, y);
84+
bool result2 = comparer.Equals(y, x);
85+
86+
// Then
87+
Assert.False(result1);
88+
Assert.False(result2);
89+
}
90+
91+
[Fact(DisplayName = "ResultEqualityComparer.Equals should return true when comparing identical Success values")]
92+
public void ResultEqualityComparerEqualsShouldReturnTrueWhenComparingIdenticalSomeValues()
93+
{
94+
// Given
95+
Result<string> x = "abc";
96+
Result<string> y = "abc";
97+
ResultEqualityComparer<string> comparer = new();
98+
99+
// When
100+
bool result1 = comparer.Equals(x, y);
101+
bool result2 = comparer.Equals(y, x);
102+
103+
// Then
104+
Assert.True(result1);
105+
Assert.True(result2);
106+
}
107+
108+
[Fact(DisplayName = "ResultEqualityComparer.Equals should return false when comparing non-identical Success values")]
109+
public void ResultEqualityComparerEqualsShouldReturnFalseWhenComparingNonIdenticalSomeValues()
110+
{
111+
// Given
112+
Result<string> x = "abc";
113+
Result<string> y = "xyz";
114+
ResultEqualityComparer<string> comparer = new();
115+
116+
// When
117+
bool result1 = comparer.Equals(x, y);
118+
bool result2 = comparer.Equals(y, x);
119+
120+
// Then
121+
Assert.False(result1);
122+
Assert.False(result2);
123+
}
124+
125+
[Fact(DisplayName = "ResultEqualityComparer.Equals should return true when comparing identical Success values with value comparer")]
126+
public void ResultEqualityComparerEqualsShouldReturnTrueWhenComparingIdenticalSomeValuesWithValueComparer()
127+
{
128+
// Given
129+
Result<string> x = "abc";
130+
Result<string> y = "ABC";
131+
ResultEqualityComparer<string> comparer = new(new CaseInsensitiveStringComparer());
132+
133+
// When
134+
bool result1 = comparer.Equals(x, y);
135+
bool result2 = comparer.Equals(y, x);
136+
137+
// Then
138+
Assert.True(result1);
139+
Assert.True(result2);
140+
}
141+
142+
[Fact(DisplayName = "ResultEqualityComparer.Equals should return false when comparing non-identical Success values with value comparer")]
143+
public void ResultEqualityComparerEqualsShouldReturnFalseWhenComparingNonIdenticalSomeValuesWithValueComparer()
144+
{
145+
// Given
146+
Result<string> x = "abc";
147+
Result<string> y = "XYZ";
148+
ResultEqualityComparer<string> comparer = new(new CaseInsensitiveStringComparer());
149+
150+
// When
151+
bool result1 = comparer.Equals(x, y);
152+
bool result2 = comparer.Equals(y, x);
153+
154+
// Then
155+
Assert.False(result1);
156+
Assert.False(result2);
157+
}
158+
159+
private sealed class CaseInsensitiveStringComparer : EqualityComparer<string>
160+
{
161+
public override bool Equals(string? x, string? y) => string.Equals(x, y, StringComparison.InvariantCultureIgnoreCase);
162+
public override int GetHashCode(string obj) => obj.GetHashCode();
163+
}
164+
}

‎OnixLabs.Core/OnixLabs.Core.csproj

+2-2
Original file line numberDiff line numberDiff line change
@@ -7,11 +7,11 @@
77
<Title>OnixLabs.Core</Title>
88
<Authors>ONIXLabs</Authors>
99
<Description>ONIXLabs Core API for .NET</Description>
10-
<AssemblyVersion>8.10.1</AssemblyVersion>
10+
<AssemblyVersion>8.11.0</AssemblyVersion>
1111
<NeutralLanguage>en</NeutralLanguage>
1212
<Copyright>Copyright © ONIXLabs 2020</Copyright>
1313
<RepositoryUrl>https://github.com/onix-labs/onixlabs-dotnet</RepositoryUrl>
14-
<PackageVersion>8.10.1</PackageVersion>
14+
<PackageVersion>8.11.0</PackageVersion>
1515
</PropertyGroup>
1616
<PropertyGroup>
1717
<AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>

‎OnixLabs.Core/Optional.cs

+14
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,20 @@ internal Optional()
4040
/// </summary>
4141
public bool HasValue => this is Some<T>;
4242

43+
/// <summary>
44+
/// Gets a value indicating whether the specified <see cref="Optional{T}"/> instance is <see cref="None{T}"/>.
45+
/// </summary>
46+
/// <param name="value">The <see cref="Optional{T}"/> value to check.</param>
47+
/// <returns>Returns <see langword="true"/> if the specified <see cref="Optional{T}"/> instance is <see cref="None{T}"/>; otherwise, <see langword="false"/>.</returns>
48+
public static bool IsNone(Optional<T> value) => value is None<T>;
49+
50+
/// <summary>
51+
/// Gets a value indicating whether the specified <see cref="Optional{T}"/> instance is <see cref="Some{T}"/>.
52+
/// </summary>
53+
/// <param name="value">The <see cref="Optional{T}"/> value to check.</param>
54+
/// <returns>Returns <see langword="true"/> if the specified <see cref="Optional{T}"/> instance is <see cref="Some{T}"/>; otherwise, <see langword="false"/>.</returns>
55+
public static bool IsSome(Optional<T> value) => value is Some<T>;
56+
4357
/// <summary>
4458
/// Creates a new instance of the <see cref="Optional{T}"/> class, where the underlying value is present if
4559
/// the specified value is not <see langword="default"/>; otherwise, the underlying value is <see cref="None"/>.

0 commit comments

Comments
 (0)