From 01c02928a3c62efaaea14cb5b0590a13419837e8 Mon Sep 17 00:00:00 2001 From: Paul Martins <50200071+MooVC@users.noreply.github.com> Date: Fri, 31 Oct 2025 17:29:24 +0000 Subject: [PATCH 1/2] Add ForString operator tests for equivalent strings --- ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithIOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithIOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...yOperatorWithIOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...yOperatorWithIOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...EqualityOperatorWithSimpleForArrayIsCalled.cs | 16 ++++++++++++++++ ...equalityOperatorWithSimpleForArrayIsCalled.cs | 16 ++++++++++++++++ ...qualityOperatorWithSimpleForStringIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...qualityOperatorWithSimpleForStringIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithIOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithIOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...yOperatorWithIOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...yOperatorWithIOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...EqualityOperatorWithSimpleForArrayIsCalled.cs | 16 ++++++++++++++++ ...equalityOperatorWithSimpleForArrayIsCalled.cs | 16 ++++++++++++++++ ...qualityOperatorWithSimpleForStringIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...qualityOperatorWithSimpleForStringIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithIOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithIOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...yOperatorWithIOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...yOperatorWithIOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...ityOperatorWithOutterForArrayInnerIsCalled.cs | 16 ++++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...tyOperatorWithOutterForStringInnerIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...EqualityOperatorWithSimpleForArrayIsCalled.cs | 16 ++++++++++++++++ ...equalityOperatorWithSimpleForArrayIsCalled.cs | 16 ++++++++++++++++ ...qualityOperatorWithSimpleForStringIsCalled.cs | 16 ++++++++++++++++ .../WhenEqualityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ ...qualityOperatorWithSimpleForStringIsCalled.cs | 16 ++++++++++++++++ .../WhenInequalityOperatorWithStringIsCalled.cs | 15 +++++++++++++++ 108 files changed, 1692 insertions(+) diff --git a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs index 38010b4..f70b43a 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs index 7c784ff..718da1b 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 711ec60..9db2a9e 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 5eb9f80..59dade7 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index f795216..527d78c 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index a4bb004..d0ecd6e 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenEqualityOperatorWithIOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenEqualityOperatorWithIOutterForArrayInnerIsCalled.cs index 5586f91..db04440 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenEqualityOperatorWithIOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenEqualityOperatorWithIOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + IOutterForArray.Inner left = new(leftValues); + IOutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenInequalityOperatorWithIOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenInequalityOperatorWithIOutterForArrayInnerIsCalled.cs index 47530f3..e0581b8 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenInequalityOperatorWithIOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenInequalityOperatorWithIOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + IOutterForArray.Inner left = new(leftValues); + IOutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs index 1dd8c59..f9def68 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + IOutterForString.Inner left = new(leftValue); + IOutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 5dd53a1..f35cb76 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + IOutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs index c51d7aa..2c98489 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + IOutterForString.Inner left = new(leftValue); + IOutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 1370419..4018ec0 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + IOutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs index 80c3a44..28b9db6 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs index 5d3d149..0a0f2c1 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 43b0192..6683e09 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 1082eb6..0f0caa6 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 10dd2cd..996cdf7 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 2d5156e..e28c355 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs index 6410ebf..d15f44f 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs index b1e37e5..06a865a 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index c2f1a10..36277c0 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 177a507..189801b 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 5041676..3b2dd29 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 2e78713..872b2e0 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs index ec4b94e..a12f5ce 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs index 201b918..6f2ebd8 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 394b16d..68e868f 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 2c12d53..bb7351b 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index b77e253..7141d1e 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 6c45ad0..0b2f17f 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Simple/SimpleForArrayTests/WhenEqualityOperatorWithSimpleForArrayIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForArrayTests/WhenEqualityOperatorWithSimpleForArrayIsCalled.cs index de2188f..d5b488b 100644 --- a/src/Monify.Console.Tests/Classes/Simple/SimpleForArrayTests/WhenEqualityOperatorWithSimpleForArrayIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForArrayTests/WhenEqualityOperatorWithSimpleForArrayIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + SimpleForArray left = new(leftValues); + SimpleForArray right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Simple/SimpleForArrayTests/WhenInequalityOperatorWithSimpleForArrayIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForArrayTests/WhenInequalityOperatorWithSimpleForArrayIsCalled.cs index 2d856a3..5ab87e1 100644 --- a/src/Monify.Console.Tests/Classes/Simple/SimpleForArrayTests/WhenInequalityOperatorWithSimpleForArrayIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForArrayTests/WhenInequalityOperatorWithSimpleForArrayIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + SimpleForArray left = new(leftValues); + SimpleForArray right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs index 8da71be..4041a38 100644 --- a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + SimpleForString left = new(leftValue); + SimpleForString right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs index 88f6e08..f3bf10e 100644 --- a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + SimpleForString subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs index dad703d..16ef5bf 100644 --- a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + SimpleForString left = new(leftValue); + SimpleForString right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs index 6946d82..9efcc67 100644 --- a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + SimpleForString subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs index 6613df2..fd5f10e 100644 --- a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs index 127f7f2..24c2f9f 100644 --- a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 7ae4156..b11563a 100644 --- a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index c5b79ec..68ce248 100644 --- a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index ab0ab55..f6a4822 100644 --- a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index c2ddc23..0dfce74 100644 --- a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenEqualityOperatorWithIOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenEqualityOperatorWithIOutterForArrayInnerIsCalled.cs index 9f4d305..749c493 100644 --- a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenEqualityOperatorWithIOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenEqualityOperatorWithIOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + IOutterForArray.Inner left = new(leftValues); + IOutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenInequalityOperatorWithIOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenInequalityOperatorWithIOutterForArrayInnerIsCalled.cs index 24d831b..a85e597 100644 --- a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenInequalityOperatorWithIOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenInequalityOperatorWithIOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + IOutterForArray.Inner left = new(leftValues); + IOutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs index 0b19345..63c1912 100644 --- a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + IOutterForString.Inner left = new(leftValue); + IOutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 5d618f6..40faa3e 100644 --- a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + IOutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs index 4f93b14..df78506 100644 --- a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + IOutterForString.Inner left = new(leftValue); + IOutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index bed26ae..6ad2afe 100644 --- a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + IOutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs index 0ec2601..f30fde5 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs index 8603901..04fb3d4 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index bbcc5c1..6b1902b 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index be04c5f..eb89e2b 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index cd66cdf..73fb261 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index d102d05..53600a8 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs index b4952d6..08c04f5 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs index f3de426..b091c2d 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 23743cb..9d4f7eb 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index c109fa0..3bb2a5d 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 4ffa318..2d6a9ae 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 25d48d4..c17dcbf 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs index af9bef4..1a67001 100644 --- a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs index 5af43df..dc6c076 100644 --- a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 4bff482..7bed4b0 100644 --- a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index dbcaa22..ef8d5e0 100644 --- a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 15d7039..5e6bbbe 100644 --- a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index be88e00..f327a18 100644 --- a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Simple/SimpleForArrayTests/WhenEqualityOperatorWithSimpleForArrayIsCalled.cs b/src/Monify.Console.Tests/Records/Simple/SimpleForArrayTests/WhenEqualityOperatorWithSimpleForArrayIsCalled.cs index 1c7e33f..7979df8 100644 --- a/src/Monify.Console.Tests/Records/Simple/SimpleForArrayTests/WhenEqualityOperatorWithSimpleForArrayIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Simple/SimpleForArrayTests/WhenEqualityOperatorWithSimpleForArrayIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + SimpleForArray left = new(leftValues); + SimpleForArray right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Simple/SimpleForArrayTests/WhenInequalityOperatorWithSimpleForArrayIsCalled.cs b/src/Monify.Console.Tests/Records/Simple/SimpleForArrayTests/WhenInequalityOperatorWithSimpleForArrayIsCalled.cs index c96365d..d915d9e 100644 --- a/src/Monify.Console.Tests/Records/Simple/SimpleForArrayTests/WhenInequalityOperatorWithSimpleForArrayIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Simple/SimpleForArrayTests/WhenInequalityOperatorWithSimpleForArrayIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + SimpleForArray left = new(leftValues); + SimpleForArray right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs index c3da25d..447438f 100644 --- a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + SimpleForString left = new(leftValue); + SimpleForString right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs index 681f458..7007d6d 100644 --- a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + SimpleForString subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs index 7833ea8..71beadc 100644 --- a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + SimpleForString left = new(leftValue); + SimpleForString right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs index b32138e..9a249cf 100644 --- a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + SimpleForString subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs index 4e54acd..12271d8 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs index f919007..7e4a49a 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 7d092e3..1dc25ab 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index e3f9b19..3f66302 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index db55729..1f4fd26 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 1b378e4..897664e 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenEqualityOperatorWithIOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenEqualityOperatorWithIOutterForArrayInnerIsCalled.cs index ceaf799..1878ecb 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenEqualityOperatorWithIOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenEqualityOperatorWithIOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + IOutterForArray.Inner left = new(leftValues); + IOutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenInequalityOperatorWithIOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenInequalityOperatorWithIOutterForArrayInnerIsCalled.cs index c731d48..63e2a4d 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenInequalityOperatorWithIOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForArrayTests/InnerTests/WhenInequalityOperatorWithIOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + IOutterForArray.Inner left = new(leftValues); + IOutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs index 6b01cd3..c5f50dd 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + IOutterForString.Inner left = new(leftValue); + IOutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index adb0f36..5b33855 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + IOutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs index 005ba1c..4807ad0 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + IOutterForString.Inner left = new(leftValue); + IOutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index de89eec..8ff1bc0 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + IOutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs index 330ab6a..53b1493 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs index d5c206a..9f0b48a 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index aaa3c3f..f3b4fdf 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 00c20ba..459e897 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 7bc8fe3..a9796af 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 3e997e1..c299aeb 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs index 6deeee9..0421871 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs index 0659efc..382524e 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 5b1ee73..01be177 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index b025a0a..f65aebf 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 12803a3..72b4839 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index c331187..002acb3 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs index d4d22fc..2fcfc3d 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForArrayTests/InnerTests/WhenEqualityOperatorWithOutterForArrayInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs index b5e5bfa..5ef82cb 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForArrayTests/InnerTests/WhenInequalityOperatorWithOutterForArrayInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + OutterForArray.Inner left = new(leftValues); + OutterForArray.Inner right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 4356e07..51ce4c1 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 9a5fbb7..b85ae1c 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index d5e5ddf..9fa21fc 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner left = new(leftValue); + OutterForString.Inner right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 27bbbef..7552875 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + OutterForString.Inner subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Simple/SimpleForArrayTests/WhenEqualityOperatorWithSimpleForArrayIsCalled.cs b/src/Monify.Console.Tests/Structs/Simple/SimpleForArrayTests/WhenEqualityOperatorWithSimpleForArrayIsCalled.cs index 0197492..dd41b11 100644 --- a/src/Monify.Console.Tests/Structs/Simple/SimpleForArrayTests/WhenEqualityOperatorWithSimpleForArrayIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Simple/SimpleForArrayTests/WhenEqualityOperatorWithSimpleForArrayIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + SimpleForArray left = new(leftValues); + SimpleForArray right = new(rightValues); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Simple/SimpleForArrayTests/WhenInequalityOperatorWithSimpleForArrayIsCalled.cs b/src/Monify.Console.Tests/Structs/Simple/SimpleForArrayTests/WhenInequalityOperatorWithSimpleForArrayIsCalled.cs index 0a2bd8d..c32c75c 100644 --- a/src/Monify.Console.Tests/Structs/Simple/SimpleForArrayTests/WhenInequalityOperatorWithSimpleForArrayIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Simple/SimpleForArrayTests/WhenInequalityOperatorWithSimpleForArrayIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + int[] leftValues = [1, 2, 3]; + int[] rightValues = [1, 2, 3]; + SimpleForArray left = new(leftValues); + SimpleForArray right = new(rightValues); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs index 301305f..32a36d6 100644 --- a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs @@ -47,6 +47,22 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValuesThenReturnTrue() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + SimpleForString left = new(leftValue); + SimpleForString right = new(rightValue); + + // Act + bool actual = left == right; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValuesThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs index ac03d32..a7efe0c 100644 --- a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnTrue() actual.ShouldBeTrue(); } + [Fact] + public static void GivenEquivalentValueThenReturnTrue() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + SimpleForString subject = new(subjectValue); + + // Act + bool actual = subject == comparisonValue; + + // Assert + actual.ShouldBeTrue(); + } + [Fact] public static void GivenDifferentValueThenReturnFalse() { diff --git a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs index 90061b2..7b7c8aa 100644 --- a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs @@ -19,6 +19,22 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValuesThenReturnFalse() + { + // Arrange + string leftValue = new string(SampleValue.ToCharArray()); + string rightValue = new string(SampleValue.ToCharArray()); + SimpleForString left = new(leftValue); + SimpleForString right = new(rightValue); + + // Act + bool actual = left != right; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValuesThenReturnTrue() { diff --git a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs index b61ca2d..e847792 100644 --- a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -31,6 +31,21 @@ public static void GivenSameValueThenReturnFalse() actual.ShouldBeFalse(); } + [Fact] + public static void GivenEquivalentValueThenReturnFalse() + { + // Arrange + string subjectValue = new string(SampleValue.ToCharArray()); + string comparisonValue = new string(SampleValue.ToCharArray()); + SimpleForString subject = new(subjectValue); + + // Act + bool actual = subject != comparisonValue; + + // Assert + actual.ShouldBeFalse(); + } + [Fact] public static void GivenDifferentValueThenReturnTrue() { From de6abb03445b0c07d67baaf7ea8d099ec7bedcc0 Mon Sep 17 00:00:00 2001 From: Paul Martins Date: Fri, 31 Oct 2025 17:45:51 +0000 Subject: [PATCH 2/2] Applied suggestions --- .../WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- ...WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithSimpleForStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithSimpleForStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- ...WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithSimpleForStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithSimpleForStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- ...WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs | 4 ++-- .../InnerTests/WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithSimpleForStringIsCalled.cs | 4 ++-- .../WhenEqualityOperatorWithStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithSimpleForStringIsCalled.cs | 4 ++-- .../WhenInequalityOperatorWithStringIsCalled.cs | 4 ++-- 72 files changed, 144 insertions(+), 144 deletions(-) diff --git a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 9db2a9e..0ddb777 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 59dade7..e1d3385 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 527d78c..fe2efed 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index d0ecd6e..ee26aca 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs index f9def68..ff86dc6 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); IOutterForString.Inner left = new(leftValue); IOutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index f35cb76..04c7b95 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); IOutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs index 2c98489..a80e8aa 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); IOutterForString.Inner left = new(leftValue); IOutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 4018ec0..ffb23a9 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); IOutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 6683e09..90d374c 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 0f0caa6..0606738 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 996cdf7..c374954 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index e28c355..05b6cf3 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 36277c0..660b73d 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 189801b..3ea812c 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 3b2dd29..9614155 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 872b2e0..2061d82 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 68e868f..8ae112d 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index bb7351b..fe00589 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 7141d1e..ee2fedb 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 0b2f17f..57c4587 100644 --- a/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs index 4041a38..89a88a0 100644 --- a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); SimpleForString left = new(leftValue); SimpleForString right = new(rightValue); diff --git a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs index f3bf10e..3860bb3 100644 --- a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); SimpleForString subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs index 16ef5bf..0ef1770 100644 --- a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); SimpleForString left = new(leftValue); SimpleForString right = new(rightValue); diff --git a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs index 9efcc67..43d941e 100644 --- a/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Classes/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); SimpleForString subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index b11563a..2f89f44 100644 --- a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 68ce248..034dcbd 100644 --- a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index f6a4822..28493d1 100644 --- a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 0dfce74..3bee6bc 100644 --- a/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs index 63c1912..4cd021b 100644 --- a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); IOutterForString.Inner left = new(leftValue); IOutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 40faa3e..cd7557f 100644 --- a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); IOutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs index df78506..01679c6 100644 --- a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); IOutterForString.Inner left = new(leftValue); IOutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 6ad2afe..b3c4168 100644 --- a/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); IOutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 6b1902b..809145d 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index eb89e2b..aa05928 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 73fb261..7cf1ad6 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 53600a8..f5bb89f 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 9d4f7eb..05fcbd0 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 3bb2a5d..74d8cff 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 2d6a9ae..f76a9aa 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index c17dcbf..9530fc5 100644 --- a/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 7bed4b0..e4df1c3 100644 --- a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index ef8d5e0..0e1cdb8 100644 --- a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 5e6bbbe..4237bf8 100644 --- a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index f327a18..cdf7676 100644 --- a/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs index 447438f..052c2a2 100644 --- a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); SimpleForString left = new(leftValue); SimpleForString right = new(rightValue); diff --git a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs index 7007d6d..9280426 100644 --- a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); SimpleForString subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs index 71beadc..850447a 100644 --- a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); SimpleForString left = new(leftValue); SimpleForString right = new(rightValue); diff --git a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs index 9a249cf..3b83ac4 100644 --- a/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Records/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); SimpleForString subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 1dc25ab..b4febe2 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 3f66302..7750f68 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 1f4fd26..8791f45 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 897664e..8ceb7d6 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InClass/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs index c5f50dd..aaa9790 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithIOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); IOutterForString.Inner left = new(leftValue); IOutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 5b33855..d78e596 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); IOutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs index 4807ad0..5ee1063 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithIOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); IOutterForString.Inner left = new(leftValue); IOutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 8ff1bc0..ec640b9 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InInterface/IOutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); IOutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index f3b4fdf..7043cbd 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index 459e897..f93a510 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index a9796af..cb740b2 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index c299aeb..7b00429 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecord/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 01be177..32fed4b 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index f65aebf..b682f35 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 72b4839..26026dc 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 002acb3..4b1961e 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InRecordStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs index 51ce4c1..782fe51 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithOutterForStringInnerIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs index b85ae1c..411cff0 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs index 9fa21fc..2653aec 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithOutterForStringInnerIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); OutterForString.Inner left = new(leftValue); OutterForString.Inner right = new(rightValue); diff --git a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs index 7552875..20ac1cc 100644 --- a/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Nested/InStruct/OutterForStringTests/InnerTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); OutterForString.Inner subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs index 32a36d6..d1e4079 100644 --- a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithSimpleForStringIsCalled.cs @@ -51,8 +51,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValuesThenReturnTrue() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); SimpleForString left = new(leftValue); SimpleForString right = new(rightValue); diff --git a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs index a7efe0c..df85279 100644 --- a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenEqualityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnTrue() public static void GivenEquivalentValueThenReturnTrue() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); SimpleForString subject = new(subjectValue); // Act diff --git a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs index 7b7c8aa..b155cec 100644 --- a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithSimpleForStringIsCalled.cs @@ -23,8 +23,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValuesThenReturnFalse() { // Arrange - string leftValue = new string(SampleValue.ToCharArray()); - string rightValue = new string(SampleValue.ToCharArray()); + string leftValue = new(SampleValue.ToCharArray()); + string rightValue = new(SampleValue.ToCharArray()); SimpleForString left = new(leftValue); SimpleForString right = new(rightValue); diff --git a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs index e847792..604d7ed 100644 --- a/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs +++ b/src/Monify.Console.Tests/Structs/Simple/SimpleForStringTests/WhenInequalityOperatorWithStringIsCalled.cs @@ -35,8 +35,8 @@ public static void GivenSameValueThenReturnFalse() public static void GivenEquivalentValueThenReturnFalse() { // Arrange - string subjectValue = new string(SampleValue.ToCharArray()); - string comparisonValue = new string(SampleValue.ToCharArray()); + string subjectValue = new(SampleValue.ToCharArray()); + string comparisonValue = new(SampleValue.ToCharArray()); SimpleForString subject = new(subjectValue); // Act