Skip to content

C5: dedent test class to match file-scoped namespace convention (closes #92, #93) #133

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
Chris-Wolfgang merged 2 commits into from
Jun 3, 2026
Merged

C5: dedent test class to match file-scoped namespace convention (closes #92, #93) #133

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
eb9bf53
C5: dedent test class to match file-scoped namespace convention
Chris-Wolfgang Jun 1, 2026
0af71d6
Merge branch 'vNext' into stack/c5-code-review-fixes
Chris-Wolfgang Jun 3, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
274 changes: 137 additions & 137 deletions tests/Wolfgang.Extensions.IComparable.Tests.Unit/IComparableExtensionsTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,189 +2,189 @@

namespace Wolfgang.Extensions.IComparable.Tests.Unit;

// ReSharper disable once InconsistentNaming
public class IComparableExtensionsTests
// ReSharper disable once InconsistentNaming
public class IComparableExtensionsTests
{

[Theory]
[InlineData(0, false)]
[InlineData(1, false)]
[InlineData(5, true)]
[InlineData(10, false)]
[InlineData(11, false)]
public void IsBetween_when_called_on_integers_returns_expected_result(int value, bool expectedValue)
{

[Theory]
[InlineData(0, false)]
[InlineData(1, false)]
[InlineData(5, true)]
[InlineData(10, false)]
[InlineData(11, false)]
public void IsBetween_when_called_on_integers_returns_expected_result(int value, bool expectedValue)
{
Assert.Equal(expectedValue, value.IsBetween(1, 10));
}
Assert.Equal(expectedValue, value.IsBetween(1, 10));
}



[Theory]
[InlineData("2010/12/31 23:59:59", false)]
[InlineData("2011/1/1", false)]
[InlineData("2011/7/1", true)]
[InlineData("2011/12/31 23:59:59", false)]
[InlineData("2012/1/1", false)]
public void IsBetween_when_called_on_date_times_returns_expected_result(string value, bool expectedValue)
{
var testValue = DateTime.Parse(value, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal);
Assert.Equal(expectedValue, testValue.IsBetween(new DateTime(2011, 1, 1, 0, 0, 0, DateTimeKind.Utc), new DateTime(2011, 12, 31, 23, 59, 59, DateTimeKind.Utc)));
}
[Theory]
[InlineData("2010/12/31 23:59:59", false)]
[InlineData("2011/1/1", false)]
[InlineData("2011/7/1", true)]
[InlineData("2011/12/31 23:59:59", false)]
[InlineData("2012/1/1", false)]
public void IsBetween_when_called_on_date_times_returns_expected_result(string value, bool expectedValue)
{
var testValue = DateTime.Parse(value, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal);
Assert.Equal(expectedValue, testValue.IsBetween(new DateTime(2011, 1, 1, 0, 0, 0, DateTimeKind.Utc), new DateTime(2011, 12, 31, 23, 59, 59, DateTimeKind.Utc)));
}



[Theory]
[InlineData("2018/11/2", false)]
[InlineData("2018/11/4", true)]
[InlineData("2018/11/6", false)]
public void IsBetween_when_called_on_specific_dates_returns_expected_result(DateTime value, bool expectedValue)
{
var utcValue = DateTime.SpecifyKind(value, DateTimeKind.Utc);
Assert.Equal(expectedValue, utcValue.IsBetween(new DateTime(2018, 11, 2, 0, 0, 0, DateTimeKind.Utc), new DateTime(2018, 11, 6, 0, 0, 0, DateTimeKind.Utc)));
}
[Theory]
[InlineData("2018/11/2", false)]
[InlineData("2018/11/4", true)]
[InlineData("2018/11/6", false)]
public void IsBetween_when_called_on_specific_dates_returns_expected_result(DateTime value, bool expectedValue)
{
var utcValue = DateTime.SpecifyKind(value, DateTimeKind.Utc);
Assert.Equal(expectedValue, utcValue.IsBetween(new DateTime(2018, 11, 2, 0, 0, 0, DateTimeKind.Utc), new DateTime(2018, 11, 6, 0, 0, 0, DateTimeKind.Utc)));
}



[Theory]
[InlineData("aa", false)]
[InlineData("ab", false)]
[InlineData("am", true)]
[InlineData("ay", false)]
[InlineData("az", false)]
public void IsBetween_when_called_on_strings_returns_expected_result(string value, bool expectedValue)
{
Assert.Equal(expectedValue, value.IsBetween("ab", "ay"));
}
[Theory]
[InlineData("aa", false)]
[InlineData("ab", false)]
[InlineData("am", true)]
[InlineData("ay", false)]
[InlineData("az", false)]
public void IsBetween_when_called_on_strings_returns_expected_result(string value, bool expectedValue)
{
Assert.Equal(expectedValue, value.IsBetween("ab", "ay"));
}



[Theory]
[InlineData('a', false)]
[InlineData('b', false)]
[InlineData('m', true)]
[InlineData('y', false)]
[InlineData('z', false)]
public void IsBetween_when_called_on_chars_returns_expected_result(char value, bool expectedValue)
{
Assert.Equal(expectedValue, value.IsBetween('b', 'y'));
}
[Theory]
[InlineData('a', false)]
[InlineData('b', false)]
[InlineData('m', true)]
[InlineData('y', false)]
[InlineData('z', false)]
public void IsBetween_when_called_on_chars_returns_expected_result(char value, bool expectedValue)
{
Assert.Equal(expectedValue, value.IsBetween('b', 'y'));
}



[Fact]
public void IsBetween_when_value_equals_both_bounds_returns_false()
{
Assert.False(5.IsBetween(5, 5));
}
[Fact]
public void IsBetween_when_value_equals_both_bounds_returns_false()
{
Assert.False(5.IsBetween(5, 5));
}



[Fact]
public void IsBetween_when_bounds_are_inverted_returns_false()
{
Assert.False(5.IsBetween(10, 1));
}
[Fact]
public void IsBetween_when_bounds_are_inverted_returns_false()
{
Assert.False(5.IsBetween(10, 1));
}



[Fact]
public void IsBetween_when_value_is_null_throws_argument_null_exception()
{
string? value = null;
[Fact]
public void IsBetween_when_value_is_null_throws_argument_null_exception()
{
string? value = null;

Assert.Throws<ArgumentNullException>(() => value!.IsBetween("a", "z"));
}
Assert.Throws<ArgumentNullException>(() => value!.IsBetween("a", "z"));
}



[Theory]
[InlineData(0, false)]
[InlineData(1, true)]
[InlineData(5, true)]
[InlineData(10, true)]
[InlineData(11, false)]
public void IsInRange_when_called_on_integers_returns_expected_result(int value, bool expectedValue)
{
Assert.Equal(expectedValue, value.IsInRange(1, 10));
}
[Theory]
[InlineData(0, false)]
[InlineData(1, true)]
[InlineData(5, true)]
[InlineData(10, true)]
[InlineData(11, false)]
public void IsInRange_when_called_on_integers_returns_expected_result(int value, bool expectedValue)
{
Assert.Equal(expectedValue, value.IsInRange(1, 10));
}



[Theory]
[InlineData("2010/12/31 23:59:59", false)]
[InlineData("2011/1/1", true)]
[InlineData("2011/7/1", true)]
[InlineData("2011/12/31 23:59:50", true)]
[InlineData("2012/1/1", false)]
public void IsInRange_when_called_on_date_times_returns_expected_result(string value, bool expectedValue)
{
var testValue = DateTime.Parse(value, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal);
Assert.Equal(expectedValue, testValue.IsInRange(new DateTime(2011, 1, 1, 0, 0, 0, DateTimeKind.Utc), new DateTime(2011, 12, 31, 23, 59, 59, DateTimeKind.Utc)));
}
[Theory]
[InlineData("2010/12/31 23:59:59", false)]
[InlineData("2011/1/1", true)]
[InlineData("2011/7/1", true)]
[InlineData("2011/12/31 23:59:50", true)]
[InlineData("2012/1/1", false)]
public void IsInRange_when_called_on_date_times_returns_expected_result(string value, bool expectedValue)
{
var testValue = DateTime.Parse(value, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal);
Assert.Equal(expectedValue, testValue.IsInRange(new DateTime(2011, 1, 1, 0, 0, 0, DateTimeKind.Utc), new DateTime(2011, 12, 31, 23, 59, 59, DateTimeKind.Utc)));
}



[Theory]
[InlineData("2018/11/1", false)]
[InlineData("2018/11/2", true)]
[InlineData("2018/11/4", true)]
[InlineData("2018/11/6", true)]
[InlineData("2018/11/7", false)]
public void IsInRange_when_called_on_specific_dates_returns_expected_result(DateTime value, bool expectedValue)
{
var utcValue = DateTime.SpecifyKind(value, DateTimeKind.Utc);
Assert.Equal(expectedValue, utcValue.IsInRange(new DateTime(2018, 11, 2, 0, 0, 0, DateTimeKind.Utc), new DateTime(2018, 11, 6, 0, 0, 0, DateTimeKind.Utc)));
}
[Theory]
[InlineData("2018/11/1", false)]
[InlineData("2018/11/2", true)]
[InlineData("2018/11/4", true)]
[InlineData("2018/11/6", true)]
[InlineData("2018/11/7", false)]
public void IsInRange_when_called_on_specific_dates_returns_expected_result(DateTime value, bool expectedValue)
{
var utcValue = DateTime.SpecifyKind(value, DateTimeKind.Utc);
Assert.Equal(expectedValue, utcValue.IsInRange(new DateTime(2018, 11, 2, 0, 0, 0, DateTimeKind.Utc), new DateTime(2018, 11, 6, 0, 0, 0, DateTimeKind.Utc)));
}



[Theory]
[InlineData("a", false)]
[InlineData("b", true)]
[InlineData("m", true)]
[InlineData("y", true)]
[InlineData("z", false)]
public void IsInRange_when_called_on_strings_returns_expected_result(string value, bool expectedValue)
{
Assert.Equal(expectedValue, value.IsInRange("b", "y"));
}
[Theory]
[InlineData("a", false)]
[InlineData("b", true)]
[InlineData("m", true)]
[InlineData("y", true)]
[InlineData("z", false)]
public void IsInRange_when_called_on_strings_returns_expected_result(string value, bool expectedValue)
{
Assert.Equal(expectedValue, value.IsInRange("b", "y"));
}



[Theory]
[InlineData('a', false)]
[InlineData('b', true)]
[InlineData('m', true)]
[InlineData('y', true)]
[InlineData('z', false)]
public void IsInRange_when_called_on_chars_returns_expected_result(char value, bool expectedValue)
{
Assert.Equal(expectedValue, value.IsInRange('b', 'y'));
}
[Theory]
[InlineData('a', false)]
[InlineData('b', true)]
[InlineData('m', true)]
[InlineData('y', true)]
[InlineData('z', false)]
public void IsInRange_when_called_on_chars_returns_expected_result(char value, bool expectedValue)
{
Assert.Equal(expectedValue, value.IsInRange('b', 'y'));
}



[Fact]
public void IsInRange_when_value_equals_both_bounds_returns_true()
{
Assert.True(5.IsInRange(5, 5));
}
[Fact]
public void IsInRange_when_value_equals_both_bounds_returns_true()
{
Assert.True(5.IsInRange(5, 5));
}



[Fact]
public void IsInRange_when_bounds_are_inverted_returns_false()
{
Assert.False(5.IsInRange(10, 1));
}
[Fact]
public void IsInRange_when_bounds_are_inverted_returns_false()
{
Assert.False(5.IsInRange(10, 1));
}



[Fact]
public void IsInRange_when_value_is_null_throws_argument_null_exception()
{
string? value = null;
[Fact]
public void IsInRange_when_value_is_null_throws_argument_null_exception()
{
string? value = null;

Assert.Throws<ArgumentNullException>(() => value!.IsInRange("a", "z"));
}
Assert.Throws<ArgumentNullException>(() => value!.IsInRange("a", "z"));
}
}