From a6b8faa088853279db1ef69c7a35a380eff662de Mon Sep 17 00:00:00 2001 From: Paul Martins <50200071+MooVC@users.noreply.github.com> Date: Sun, 26 Oct 2025 21:16:44 +0000 Subject: [PATCH 1/2] Add comprehensive tests for SimpleForInt Monify output --- .../Classes/Simple/WhenConstructorIsCalled.cs | 22 +++++++ .../WhenEqualityOperatorWithIntIsCalled.cs | 49 ++++++++++++++ ...qualityOperatorWithSimpleForIntIsCalled.cs | 66 +++++++++++++++++++ .../Simple/WhenEqualsWithIntIsCalled.cs | 36 ++++++++++ .../Simple/WhenEqualsWithObjectIsCalled.cs | 51 ++++++++++++++ .../WhenEqualsWithSimpleForIntIsCalled.cs | 52 +++++++++++++++ .../Classes/Simple/WhenGetHashCodeIsCalled.cs | 40 +++++++++++ .../WhenImplicitOperatorFromIntIsCalled.cs | 20 ++++++ .../WhenImplicitOperatorToIntIsCalled.cs | 37 +++++++++++ .../WhenInequalityOperatorWithIntIsCalled.cs | 49 ++++++++++++++ ...qualityOperatorWithSimpleForIntIsCalled.cs | 38 +++++++++++ .../Classes/Simple/WhenToStringIsCalled.cs | 23 +++++++ 12 files changed, 483 insertions(+) create mode 100644 src/Monify.Console.Tests/Classes/Simple/WhenConstructorIsCalled.cs create mode 100644 src/Monify.Console.Tests/Classes/Simple/WhenEqualityOperatorWithIntIsCalled.cs create mode 100644 src/Monify.Console.Tests/Classes/Simple/WhenEqualityOperatorWithSimpleForIntIsCalled.cs create mode 100644 src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithIntIsCalled.cs create mode 100644 src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithObjectIsCalled.cs create mode 100644 src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithSimpleForIntIsCalled.cs create mode 100644 src/Monify.Console.Tests/Classes/Simple/WhenGetHashCodeIsCalled.cs create mode 100644 src/Monify.Console.Tests/Classes/Simple/WhenImplicitOperatorFromIntIsCalled.cs create mode 100644 src/Monify.Console.Tests/Classes/Simple/WhenImplicitOperatorToIntIsCalled.cs create mode 100644 src/Monify.Console.Tests/Classes/Simple/WhenInequalityOperatorWithIntIsCalled.cs create mode 100644 src/Monify.Console.Tests/Classes/Simple/WhenInequalityOperatorWithSimpleForIntIsCalled.cs create mode 100644 src/Monify.Console.Tests/Classes/Simple/WhenToStringIsCalled.cs diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenConstructorIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/WhenConstructorIsCalled.cs new file mode 100644 index 0000000..36416d3 --- /dev/null +++ b/src/Monify.Console.Tests/Classes/Simple/WhenConstructorIsCalled.cs @@ -0,0 +1,22 @@ +namespace Monify.Console.Classes.Simple.SimpleForIntTests; + +using Shouldly; +using Xunit; + +public static class WhenConstructorIsCalled +{ + private const int SampleValue = 42; + + [Fact] + public static void GivenValueThenValueIsStored() + { + // Arrange + SimpleForInt instance = new(SampleValue); + + // Act + int actual = instance; + + // Assert + actual.ShouldBe(SampleValue); + } +} \ No newline at end of file diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenEqualityOperatorWithIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/WhenEqualityOperatorWithIntIsCalled.cs new file mode 100644 index 0000000..4009635 --- /dev/null +++ b/src/Monify.Console.Tests/Classes/Simple/WhenEqualityOperatorWithIntIsCalled.cs @@ -0,0 +1,49 @@ +namespace Monify.Console.Classes.Simple.SimpleForIntTests; + +using Shouldly; +using Xunit; + +public static class WhenEqualityOperatorWithIntIsCalled +{ + private const int SampleValue = 101; + private const int DifferentValue = 202; + + [Fact] + public static void GivenSubjectIsNullThenReturnFalse() + { + // Arrange + SimpleForInt subject = null!; + + // Act + bool actual = subject == SampleValue; + + // Assert + actual.ShouldBeFalse(); + } + + [Fact] + public static void GivenSameValueThenReturnTrue() + { + // Arrange + SimpleForInt subject = new(SampleValue); + + // Act + bool actual = subject == SampleValue; + + // Assert + actual.ShouldBeTrue(); + } + + [Fact] + public static void GivenDifferentValueThenReturnFalse() + { + // Arrange + SimpleForInt subject = new(SampleValue); + + // Act + bool actual = subject == DifferentValue; + + // Assert + actual.ShouldBeFalse(); + } +} \ No newline at end of file diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenEqualityOperatorWithSimpleForIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/WhenEqualityOperatorWithSimpleForIntIsCalled.cs new file mode 100644 index 0000000..0cfb210 --- /dev/null +++ b/src/Monify.Console.Tests/Classes/Simple/WhenEqualityOperatorWithSimpleForIntIsCalled.cs @@ -0,0 +1,66 @@ +namespace Monify.Console.Classes.Simple.SimpleForIntTests; + +using Shouldly; +using Xunit; + +public static class WhenEqualityOperatorWithSimpleForIntIsCalled +{ + private const int SampleValue = 14; + private const int DifferentValue = 17; + + [Fact] + public static void GivenBothNullThenReturnTrue() + { + // Arrange + SimpleForInt? left = null; + SimpleForInt? right = null; + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + + [Fact] + public static void GivenLeftIsNullThenReturnFalse() + { + // Arrange + SimpleForInt? left = null; + SimpleForInt right = new(SampleValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeFalse(); + } + + [Fact] + public static void GivenSameValueThenReturnTrue() + { + // Arrange + SimpleForInt left = new(SampleValue); + SimpleForInt right = new(SampleValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + + [Fact] + public static void GivenDifferentValuesThenReturnFalse() + { + // Arrange + SimpleForInt left = new(SampleValue); + SimpleForInt right = new(DifferentValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeFalse(); + } +} \ No newline at end of file diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithIntIsCalled.cs new file mode 100644 index 0000000..e1fe1b6 --- /dev/null +++ b/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithIntIsCalled.cs @@ -0,0 +1,36 @@ +namespace Monify.Console.Classes.Simple.SimpleForIntTests; + +using Shouldly; +using Xunit; + +public static class WhenEqualsWithIntIsCalled +{ + private const int SampleValue = 36; + private const int DifferentValue = 12; + + [Fact] + public static void GivenSameValueThenReturnTrue() + { + // Arrange + SimpleForInt subject = new(SampleValue); + + // Act + bool actual = subject.Equals(SampleValue); + + // Assert + actual.ShouldBeTrue(); + } + + [Fact] + public static void GivenDifferentValueThenReturnFalse() + { + // Arrange + SimpleForInt subject = new(SampleValue); + + // Act + bool actual = subject.Equals(DifferentValue); + + // Assert + actual.ShouldBeFalse(); + } +} \ No newline at end of file diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithObjectIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithObjectIsCalled.cs new file mode 100644 index 0000000..9ba84f5 --- /dev/null +++ b/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithObjectIsCalled.cs @@ -0,0 +1,51 @@ +namespace Monify.Console.Classes.Simple.SimpleForIntTests; + +using System; +using Shouldly; +using Xunit; + +public static class WhenEqualsWithObjectIsCalled +{ + private const int SampleValue = 28; + + [Fact] + public static void GivenNullThenReturnFalse() + { + // Arrange + SimpleForInt subject = new(SampleValue); + + // Act + bool actual = subject.Equals((object?)null); + + // Assert + actual.ShouldBeFalse(); + } + + [Fact] + public static void GivenEquivalentSimpleForIntThenReturnTrue() + { + // Arrange + SimpleForInt subject = new(SampleValue); + object other = new SimpleForInt(SampleValue); + + // Act + bool actual = subject.Equals(other); + + // Assert + actual.ShouldBeTrue(); + } + + [Fact] + public static void GivenDifferentTypeThenThrowInvalidCastException() + { + // Arrange + SimpleForInt subject = new(SampleValue); + object other = string.Empty; + + // Act + Action act = () => subject.Equals(other); + + // Assert + Should.Throw(act); + } +} \ No newline at end of file diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithSimpleForIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithSimpleForIntIsCalled.cs new file mode 100644 index 0000000..b819018 --- /dev/null +++ b/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithSimpleForIntIsCalled.cs @@ -0,0 +1,52 @@ +namespace Monify.Console.Classes.Simple.SimpleForIntTests; + +using Shouldly; +using Xunit; + +public static class WhenEqualsWithSimpleForIntIsCalled +{ + private const int SampleValue = 51; + private const int DifferentValue = 5; + + [Fact] + public static void GivenOtherHasSameValueThenReturnTrue() + { + // Arrange + SimpleForInt subject = new(SampleValue); + SimpleForInt other = new(SampleValue); + + // Act + bool actual = subject.Equals(other); + + // Assert + actual.ShouldBeTrue(); + } + + [Fact] + public static void GivenOtherIsNullThenReturnFalse() + { + // Arrange + SimpleForInt subject = new(SampleValue); + SimpleForInt other = null!; + + // Act + bool actual = subject.Equals(other); + + // Assert + actual.ShouldBeFalse(); + } + + [Fact] + public static void GivenOtherHasDifferentValueThenReturnFalse() + { + // Arrange + SimpleForInt subject = new(SampleValue); + SimpleForInt other = new(DifferentValue); + + // Act + bool actual = subject.Equals(other); + + // Assert + actual.ShouldBeFalse(); + } +} \ No newline at end of file diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenGetHashCodeIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/WhenGetHashCodeIsCalled.cs new file mode 100644 index 0000000..b0cdaab --- /dev/null +++ b/src/Monify.Console.Tests/Classes/Simple/WhenGetHashCodeIsCalled.cs @@ -0,0 +1,40 @@ +namespace Monify.Console.Classes.Simple.SimpleForIntTests; + +using Shouldly; +using Xunit; + +public static class WhenGetHashCodeIsCalled +{ + private const int FirstValue = 3; + private const int SecondValue = 4; + + [Fact] + public static void GivenSameValuesThenReturnSameHashCode() + { + // Arrange + SimpleForInt first = new(FirstValue); + SimpleForInt second = new(FirstValue); + + // Act + int firstHash = first.GetHashCode(); + int secondHash = second.GetHashCode(); + + // Assert + firstHash.ShouldBe(secondHash); + } + + [Fact] + public static void GivenDifferentValuesThenReturnDifferentHashCodes() + { + // Arrange + SimpleForInt first = new(FirstValue); + SimpleForInt second = new(SecondValue); + + // Act + int firstHash = first.GetHashCode(); + int secondHash = second.GetHashCode(); + + // Assert + firstHash.ShouldNotBe(secondHash); + } +} \ No newline at end of file diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenImplicitOperatorFromIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/WhenImplicitOperatorFromIntIsCalled.cs new file mode 100644 index 0000000..d76c7b3 --- /dev/null +++ b/src/Monify.Console.Tests/Classes/Simple/WhenImplicitOperatorFromIntIsCalled.cs @@ -0,0 +1,20 @@ +namespace Monify.Console.Classes.Simple.SimpleForIntTests; + +using Shouldly; +using Xunit; + +public static class WhenImplicitOperatorFromIntIsCalled +{ + private const int SampleValue = 77; + + [Fact] + public static void GivenValueThenReturnsEquivalentInstance() + { + // Arrange & Act + SimpleForInt result = SampleValue; + + // Assert + int actual = result; + actual.ShouldBe(SampleValue); + } +} \ No newline at end of file diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenImplicitOperatorToIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/WhenImplicitOperatorToIntIsCalled.cs new file mode 100644 index 0000000..2814a2e --- /dev/null +++ b/src/Monify.Console.Tests/Classes/Simple/WhenImplicitOperatorToIntIsCalled.cs @@ -0,0 +1,37 @@ +namespace Monify.Console.Classes.Simple.SimpleForIntTests; + +using System; +using Shouldly; +using Xunit; + +public static class WhenImplicitOperatorToIntIsCalled +{ + private const int SampleValue = 42; + + [Fact] + public static void GivenNullSubjectThenThrowsArgumentNullException() + { + // Arrange + SimpleForInt? subject = null; + + // Act + Action act = () => _ = (int)subject!; + + // Assert + ArgumentNullException exception = Should.Throw(act); + exception.ParamName.ShouldBe("subject"); + } + + [Fact] + public static void GivenValidSubjectThenReturnsValue() + { + // Arrange + SimpleForInt subject = new(SampleValue); + + // Act + int actual = subject; + + // Assert + actual.ShouldBe(SampleValue); + } +} \ No newline at end of file diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenInequalityOperatorWithIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/WhenInequalityOperatorWithIntIsCalled.cs new file mode 100644 index 0000000..3a57734 --- /dev/null +++ b/src/Monify.Console.Tests/Classes/Simple/WhenInequalityOperatorWithIntIsCalled.cs @@ -0,0 +1,49 @@ +namespace Monify.Console.Classes.Simple.SimpleForIntTests; + +using Shouldly; +using Xunit; + +public static class WhenInequalityOperatorWithIntIsCalled +{ + private const int SampleValue = 7; + private const int DifferentValue = 9; + + [Fact] + public static void GivenSubjectIsNullThenReturnTrue() + { + // Arrange + SimpleForInt subject = null!; + + // Act + bool actual = subject != SampleValue; + + // Assert + actual.ShouldBeTrue(); + } + + [Fact] + public static void GivenSameValueThenReturnFalse() + { + // Arrange + SimpleForInt subject = new(SampleValue); + + // Act + bool actual = subject != SampleValue; + + // Assert + actual.ShouldBeFalse(); + } + + [Fact] + public static void GivenDifferentValueThenReturnTrue() + { + // Arrange + SimpleForInt subject = new(SampleValue); + + // Act + bool actual = subject != DifferentValue; + + // Assert + actual.ShouldBeTrue(); + } +} \ No newline at end of file diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenInequalityOperatorWithSimpleForIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/WhenInequalityOperatorWithSimpleForIntIsCalled.cs new file mode 100644 index 0000000..f59c93d --- /dev/null +++ b/src/Monify.Console.Tests/Classes/Simple/WhenInequalityOperatorWithSimpleForIntIsCalled.cs @@ -0,0 +1,38 @@ +namespace Monify.Console.Classes.Simple.SimpleForIntTests; + +using Shouldly; +using Xunit; + +public static class WhenInequalityOperatorWithSimpleForIntIsCalled +{ + private const int SampleValue = 63; + private const int DifferentValue = 64; + + [Fact] + public static void GivenSameValueThenReturnFalse() + { + // Arrange + SimpleForInt left = new(SampleValue); + SimpleForInt right = new(SampleValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + + [Fact] + public static void GivenDifferentValuesThenReturnTrue() + { + // Arrange + SimpleForInt left = new(SampleValue); + SimpleForInt right = new(DifferentValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeTrue(); + } +} \ No newline at end of file diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenToStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/WhenToStringIsCalled.cs new file mode 100644 index 0000000..31912c7 --- /dev/null +++ b/src/Monify.Console.Tests/Classes/Simple/WhenToStringIsCalled.cs @@ -0,0 +1,23 @@ +namespace Monify.Console.Classes.Simple.SimpleForIntTests; + +using System; +using Shouldly; +using Xunit; + +public static class WhenToStringIsCalled +{ + private const int SampleValue = 91; + + [Fact] + public static void GivenValueThenThrowFormatException() + { + // Arrange + SimpleForInt subject = new(SampleValue); + + // Act + Action act = () => subject.ToString(); + + // Assert + Should.Throw(act); + } +} \ No newline at end of file From e54307b1f0da80074887840696b94d15b28f4bd6 Mon Sep 17 00:00:00 2001 From: Paul Martins Date: Sun, 26 Oct 2025 21:23:21 +0000 Subject: [PATCH 2/2] Corrected tests for SimpleForInt --- .../{ => SimpleForIntTests}/WhenConstructorIsCalled.cs | 3 --- .../WhenEqualityOperatorWithIntIsCalled.cs | 5 +---- .../WhenEqualityOperatorWithSimpleForIntIsCalled.cs | 9 +++------ .../{ => SimpleForIntTests}/WhenEqualsWithIntIsCalled.cs | 3 --- .../WhenEqualsWithObjectIsCalled.cs | 8 ++------ .../WhenEqualsWithSimpleForIntIsCalled.cs | 5 +---- .../{ => SimpleForIntTests}/WhenGetHashCodeIsCalled.cs | 3 --- .../WhenImplicitOperatorFromIntIsCalled.cs | 9 ++++----- .../WhenImplicitOperatorToIntIsCalled.cs | 6 +----- .../WhenInequalityOperatorWithIntIsCalled.cs | 5 +---- .../WhenInequalityOperatorWithSimpleForIntIsCalled.cs | 3 --- .../{ => SimpleForIntTests}/WhenToStringIsCalled.cs | 6 +----- 12 files changed, 14 insertions(+), 51 deletions(-) rename src/Monify.Console.Tests/Classes/Simple/{ => SimpleForIntTests}/WhenConstructorIsCalled.cs (92%) rename src/Monify.Console.Tests/Classes/Simple/{ => SimpleForIntTests}/WhenEqualityOperatorWithIntIsCalled.cs (93%) rename src/Monify.Console.Tests/Classes/Simple/{ => SimpleForIntTests}/WhenEqualityOperatorWithSimpleForIntIsCalled.cs (90%) rename src/Monify.Console.Tests/Classes/Simple/{ => SimpleForIntTests}/WhenEqualsWithIntIsCalled.cs (96%) rename src/Monify.Console.Tests/Classes/Simple/{ => SimpleForIntTests}/WhenEqualsWithObjectIsCalled.cs (86%) rename src/Monify.Console.Tests/Classes/Simple/{ => SimpleForIntTests}/WhenEqualsWithSimpleForIntIsCalled.cs (94%) rename src/Monify.Console.Tests/Classes/Simple/{ => SimpleForIntTests}/WhenGetHashCodeIsCalled.cs (96%) rename src/Monify.Console.Tests/Classes/Simple/{ => SimpleForIntTests}/WhenImplicitOperatorFromIntIsCalled.cs (87%) rename src/Monify.Console.Tests/Classes/Simple/{ => SimpleForIntTests}/WhenImplicitOperatorToIntIsCalled.cs (90%) rename src/Monify.Console.Tests/Classes/Simple/{ => SimpleForIntTests}/WhenInequalityOperatorWithIntIsCalled.cs (93%) rename src/Monify.Console.Tests/Classes/Simple/{ => SimpleForIntTests}/WhenInequalityOperatorWithSimpleForIntIsCalled.cs (96%) rename src/Monify.Console.Tests/Classes/Simple/{ => SimpleForIntTests}/WhenToStringIsCalled.cs (81%) diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenConstructorIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenConstructorIsCalled.cs similarity index 92% rename from src/Monify.Console.Tests/Classes/Simple/WhenConstructorIsCalled.cs rename to src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenConstructorIsCalled.cs index 36416d3..c8f24ec 100644 --- a/src/Monify.Console.Tests/Classes/Simple/WhenConstructorIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenConstructorIsCalled.cs @@ -1,8 +1,5 @@ namespace Monify.Console.Classes.Simple.SimpleForIntTests; -using Shouldly; -using Xunit; - public static class WhenConstructorIsCalled { private const int SampleValue = 42; diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenEqualityOperatorWithIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualityOperatorWithIntIsCalled.cs similarity index 93% rename from src/Monify.Console.Tests/Classes/Simple/WhenEqualityOperatorWithIntIsCalled.cs rename to src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualityOperatorWithIntIsCalled.cs index 4009635..884a359 100644 --- a/src/Monify.Console.Tests/Classes/Simple/WhenEqualityOperatorWithIntIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualityOperatorWithIntIsCalled.cs @@ -1,8 +1,5 @@ namespace Monify.Console.Classes.Simple.SimpleForIntTests; -using Shouldly; -using Xunit; - public static class WhenEqualityOperatorWithIntIsCalled { private const int SampleValue = 101; @@ -12,7 +9,7 @@ public static class WhenEqualityOperatorWithIntIsCalled public static void GivenSubjectIsNullThenReturnFalse() { // Arrange - SimpleForInt subject = null!; + SimpleForInt? subject = default; // Act bool actual = subject == SampleValue; diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenEqualityOperatorWithSimpleForIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualityOperatorWithSimpleForIntIsCalled.cs similarity index 90% rename from src/Monify.Console.Tests/Classes/Simple/WhenEqualityOperatorWithSimpleForIntIsCalled.cs rename to src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualityOperatorWithSimpleForIntIsCalled.cs index 0cfb210..848eb15 100644 --- a/src/Monify.Console.Tests/Classes/Simple/WhenEqualityOperatorWithSimpleForIntIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualityOperatorWithSimpleForIntIsCalled.cs @@ -1,8 +1,5 @@ namespace Monify.Console.Classes.Simple.SimpleForIntTests; -using Shouldly; -using Xunit; - public static class WhenEqualityOperatorWithSimpleForIntIsCalled { private const int SampleValue = 14; @@ -12,8 +9,8 @@ public static class WhenEqualityOperatorWithSimpleForIntIsCalled public static void GivenBothNullThenReturnTrue() { // Arrange - SimpleForInt? left = null; - SimpleForInt? right = null; + SimpleForInt? left = default; + SimpleForInt? right = default; // Act bool actual = left == right; @@ -26,7 +23,7 @@ public static void GivenBothNullThenReturnTrue() public static void GivenLeftIsNullThenReturnFalse() { // Arrange - SimpleForInt? left = null; + SimpleForInt? left = default; SimpleForInt right = new(SampleValue); // Act diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualsWithIntIsCalled.cs similarity index 96% rename from src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithIntIsCalled.cs rename to src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualsWithIntIsCalled.cs index e1fe1b6..bfa1059 100644 --- a/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithIntIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualsWithIntIsCalled.cs @@ -1,8 +1,5 @@ namespace Monify.Console.Classes.Simple.SimpleForIntTests; -using Shouldly; -using Xunit; - public static class WhenEqualsWithIntIsCalled { private const int SampleValue = 36; diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithObjectIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualsWithObjectIsCalled.cs similarity index 86% rename from src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithObjectIsCalled.cs rename to src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualsWithObjectIsCalled.cs index 9ba84f5..c0efa9c 100644 --- a/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithObjectIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualsWithObjectIsCalled.cs @@ -1,9 +1,5 @@ namespace Monify.Console.Classes.Simple.SimpleForIntTests; -using System; -using Shouldly; -using Xunit; - public static class WhenEqualsWithObjectIsCalled { private const int SampleValue = 28; @@ -15,7 +11,7 @@ public static void GivenNullThenReturnFalse() SimpleForInt subject = new(SampleValue); // Act - bool actual = subject.Equals((object?)null); + bool actual = subject.Equals((object?)default); // Assert actual.ShouldBeFalse(); @@ -46,6 +42,6 @@ public static void GivenDifferentTypeThenThrowInvalidCastException() Action act = () => subject.Equals(other); // Assert - Should.Throw(act); + _ = Should.Throw(act); } } \ No newline at end of file diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithSimpleForIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualsWithSimpleForIntIsCalled.cs similarity index 94% rename from src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithSimpleForIntIsCalled.cs rename to src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualsWithSimpleForIntIsCalled.cs index b819018..5200bcc 100644 --- a/src/Monify.Console.Tests/Classes/Simple/WhenEqualsWithSimpleForIntIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenEqualsWithSimpleForIntIsCalled.cs @@ -1,8 +1,5 @@ namespace Monify.Console.Classes.Simple.SimpleForIntTests; -using Shouldly; -using Xunit; - public static class WhenEqualsWithSimpleForIntIsCalled { private const int SampleValue = 51; @@ -27,7 +24,7 @@ public static void GivenOtherIsNullThenReturnFalse() { // Arrange SimpleForInt subject = new(SampleValue); - SimpleForInt other = null!; + SimpleForInt? other = default; // Act bool actual = subject.Equals(other); diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenGetHashCodeIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenGetHashCodeIsCalled.cs similarity index 96% rename from src/Monify.Console.Tests/Classes/Simple/WhenGetHashCodeIsCalled.cs rename to src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenGetHashCodeIsCalled.cs index b0cdaab..b71acbd 100644 --- a/src/Monify.Console.Tests/Classes/Simple/WhenGetHashCodeIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenGetHashCodeIsCalled.cs @@ -1,8 +1,5 @@ namespace Monify.Console.Classes.Simple.SimpleForIntTests; -using Shouldly; -using Xunit; - public static class WhenGetHashCodeIsCalled { private const int FirstValue = 3; diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenImplicitOperatorFromIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenImplicitOperatorFromIntIsCalled.cs similarity index 87% rename from src/Monify.Console.Tests/Classes/Simple/WhenImplicitOperatorFromIntIsCalled.cs rename to src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenImplicitOperatorFromIntIsCalled.cs index d76c7b3..296bbe3 100644 --- a/src/Monify.Console.Tests/Classes/Simple/WhenImplicitOperatorFromIntIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenImplicitOperatorFromIntIsCalled.cs @@ -1,8 +1,5 @@ namespace Monify.Console.Classes.Simple.SimpleForIntTests; -using Shouldly; -using Xunit; - public static class WhenImplicitOperatorFromIntIsCalled { private const int SampleValue = 77; @@ -10,11 +7,13 @@ public static class WhenImplicitOperatorFromIntIsCalled [Fact] public static void GivenValueThenReturnsEquivalentInstance() { - // Arrange & Act + // Arrange SimpleForInt result = SampleValue; - // Assert + // Act int actual = result; + + // Assert actual.ShouldBe(SampleValue); } } \ No newline at end of file diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenImplicitOperatorToIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenImplicitOperatorToIntIsCalled.cs similarity index 90% rename from src/Monify.Console.Tests/Classes/Simple/WhenImplicitOperatorToIntIsCalled.cs rename to src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenImplicitOperatorToIntIsCalled.cs index 2814a2e..42906e9 100644 --- a/src/Monify.Console.Tests/Classes/Simple/WhenImplicitOperatorToIntIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenImplicitOperatorToIntIsCalled.cs @@ -1,9 +1,5 @@ namespace Monify.Console.Classes.Simple.SimpleForIntTests; -using System; -using Shouldly; -using Xunit; - public static class WhenImplicitOperatorToIntIsCalled { private const int SampleValue = 42; @@ -12,7 +8,7 @@ public static class WhenImplicitOperatorToIntIsCalled public static void GivenNullSubjectThenThrowsArgumentNullException() { // Arrange - SimpleForInt? subject = null; + SimpleForInt? subject = default; // Act Action act = () => _ = (int)subject!; diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenInequalityOperatorWithIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenInequalityOperatorWithIntIsCalled.cs similarity index 93% rename from src/Monify.Console.Tests/Classes/Simple/WhenInequalityOperatorWithIntIsCalled.cs rename to src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenInequalityOperatorWithIntIsCalled.cs index 3a57734..59868ec 100644 --- a/src/Monify.Console.Tests/Classes/Simple/WhenInequalityOperatorWithIntIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenInequalityOperatorWithIntIsCalled.cs @@ -1,8 +1,5 @@ namespace Monify.Console.Classes.Simple.SimpleForIntTests; -using Shouldly; -using Xunit; - public static class WhenInequalityOperatorWithIntIsCalled { private const int SampleValue = 7; @@ -12,7 +9,7 @@ public static class WhenInequalityOperatorWithIntIsCalled public static void GivenSubjectIsNullThenReturnTrue() { // Arrange - SimpleForInt subject = null!; + SimpleForInt? subject = default; // Act bool actual = subject != SampleValue; diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenInequalityOperatorWithSimpleForIntIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenInequalityOperatorWithSimpleForIntIsCalled.cs similarity index 96% rename from src/Monify.Console.Tests/Classes/Simple/WhenInequalityOperatorWithSimpleForIntIsCalled.cs rename to src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenInequalityOperatorWithSimpleForIntIsCalled.cs index f59c93d..7d17868 100644 --- a/src/Monify.Console.Tests/Classes/Simple/WhenInequalityOperatorWithSimpleForIntIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenInequalityOperatorWithSimpleForIntIsCalled.cs @@ -1,8 +1,5 @@ namespace Monify.Console.Classes.Simple.SimpleForIntTests; -using Shouldly; -using Xunit; - public static class WhenInequalityOperatorWithSimpleForIntIsCalled { private const int SampleValue = 63; diff --git a/src/Monify.Console.Tests/Classes/Simple/WhenToStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenToStringIsCalled.cs similarity index 81% rename from src/Monify.Console.Tests/Classes/Simple/WhenToStringIsCalled.cs rename to src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenToStringIsCalled.cs index 31912c7..6a42a34 100644 --- a/src/Monify.Console.Tests/Classes/Simple/WhenToStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForIntTests/WhenToStringIsCalled.cs @@ -1,9 +1,5 @@ namespace Monify.Console.Classes.Simple.SimpleForIntTests; -using System; -using Shouldly; -using Xunit; - public static class WhenToStringIsCalled { private const int SampleValue = 91; @@ -18,6 +14,6 @@ public static void GivenValueThenThrowFormatException() Action act = () => subject.ToString(); // Assert - Should.Throw(act); + _ = Should.Throw(act); } } \ No newline at end of file