refactor: Consolidate initialisation logic

TUnit.Assertions.Tests/AssertConditions/BecauseTests.cs

@@ -1,4 +1,4 @@
-namespace TUnit.Assertions.Tests.AssertConditions;
+namespace TUnit.Assertions.Tests.AssertConditions;
 
 public class BecauseTests
 {
@@ -68,7 +68,7 @@ at Assert.That(variable).IsFalse()
         };
 
         var exception = await Assert.ThrowsAsync<AssertionException>(action);
-        await Assert.That(exception.Message).IsEqualTo(expectedMessage);
+        await Assert.That(exception.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage.NormalizeLineEndings());
     }
 
     [Test]
@@ -91,7 +91,7 @@ await Assert.That(variable).IsTrue().Because(because)
         };
 
         var exception = await Assert.ThrowsAsync<AssertionException>(action);
-        await Assert.That(exception.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
+        await Assert.That(exception.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage.NormalizeLineEndings());
     }
 
     [Test]

TUnit.Assertions.Tests/Assertions/Delegates/Throws.ExactlyTests.cs

@@ -13,15 +13,15 @@ public async Task Fails_For_Code_With_Other_Exceptions()
                                   but threw TUnit.Assertions.Tests.Assertions.Delegates.Throws+OtherException
 
                                   at Assert.That(action).ThrowsExactly<CustomException>()
-                                  """;
+                                  """.NormalizeLineEndings();
             Exception exception = CreateOtherException();
             Action action = () => throw exception;
 
             var sut = async ()
                 => await Assert.That(action).ThrowsExactly<CustomException>();
 
-            await Assert.That(sut).ThrowsException()
-                .WithMessage(expectedMessage);
+            var thrownException = await Assert.That(sut).ThrowsException();
+            await Assert.That(thrownException.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
         }
 
         [Test]
@@ -32,15 +32,15 @@ public async Task Fails_For_Code_With_Subtype_Exceptions()
                                   but wrong exception type: SubCustomException instead of exactly CustomException
 
                                   at Assert.That(action).ThrowsExactly<CustomException>()
-                                  """;
+                                  """.NormalizeLineEndings();
             Exception exception = CreateSubCustomException();
             Action action = () => throw exception;
 
             var sut = async ()
                 => await Assert.That(action).ThrowsExactly<CustomException>();
 
-            await Assert.That(sut).ThrowsException()
-                .WithMessage(expectedMessage);
+            var thrownException = await Assert.That(sut).ThrowsException();
+            await Assert.That(thrownException.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
         }
 
         [Test]
@@ -51,14 +51,14 @@ public async Task Fails_For_Code_Without_Exceptions()
                                   but no exception was thrown
 
                                   at Assert.That(action).ThrowsExactly<CustomException>()
-                                  """;
+                                  """.NormalizeLineEndings();
             var action = () => { };
 
             var sut = async ()
                 => await Assert.That(action).ThrowsExactly<CustomException>();
 
-            await Assert.That(sut).ThrowsException()
-                .WithMessage(expectedMessage);
+            var thrownException = await Assert.That(sut).ThrowsException();
+            await Assert.That(thrownException.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
         }
 
         [Test]
@@ -117,10 +117,11 @@ public async Task Conversion_To_Value_Assertion_Builder_On_Casted_Exception_Type
                 await Assert.That((object)ex).IsAssignableTo<CustomException>();
             });
 
-            await Assert.That(assertionException).HasMessageStartingWith("""
-                                                                         Expected to throw exactly Exception
-                                                                         but wrong exception type: CustomException instead of exactly Exception
-                                                                         """);
+            var expectedPrefix = """
+                Expected to throw exactly Exception
+                but wrong exception type: CustomException instead of exactly Exception
+                """.NormalizeLineEndings();
+            await Assert.That(assertionException.Message.NormalizeLineEndings()).StartsWith(expectedPrefix);
         }
 
         [Test]

TUnit.Assertions.Tests/Assertions/Delegates/Throws.ExceptionTests.cs

@@ -14,14 +14,14 @@ public async Task Fails_For_Code_Without_Exceptions()
                                   but no exception was thrown
 
                                   at Assert.That(action).ThrowsException()
-                                  """;
+                                  """.NormalizeLineEndings();
             var action = () => { };
 
             var sut = async ()
                 => await Assert.That(action).ThrowsException();
 
-            await Assert.That(sut).ThrowsException()
-                .WithMessage(expectedMessage);
+            var thrownException = await Assert.That(sut).ThrowsException();
+            await Assert.That(thrownException.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
         }
 
         [Test]

TUnit.Assertions.Tests/Assertions/Delegates/Throws.NothingTests.cs

@@ -12,15 +12,15 @@ public async Task Fails_For_Code_With_Exceptions()
                                     but threw TUnit.Assertions.Tests.Assertions.Delegates.Throws+CustomException: {nameof(Fails_For_Code_With_Exceptions)}
 
                                     at Assert.That(action).ThrowsNothing()
-                                    """;
+                                    """.NormalizeLineEndings();
             Exception exception = CreateCustomException();
             Action action = () => throw exception;
 
             var sut = async ()
                 => await Assert.That(action).ThrowsNothing();
 
-            await Assert.That(sut).ThrowsException()
-                .WithMessage(expectedMessage);
+            var thrownException = await Assert.That(sut).ThrowsException();
+            await Assert.That(thrownException.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
         }
 
         [Test]

TUnit.Assertions.Tests/Assertions/Delegates/Throws.OfTypeTests.cs

@@ -13,15 +13,15 @@ public async Task Fails_For_Code_With_Other_Exceptions()
                                   but threw TUnit.Assertions.Tests.Assertions.Delegates.Throws+OtherException
 
                                   at Assert.That(action).Throws<CustomException>()
-                                  """;
+                                  """.NormalizeLineEndings();
             Exception exception = CreateOtherException();
             Action action = () => throw exception;
 
             var sut = async ()
                 => await Assert.That(action).Throws<CustomException>();
 
-            await Assert.That(sut).ThrowsException()
-                .WithMessage(expectedMessage);
+            var thrownException = await Assert.That(sut).ThrowsException();
+            await Assert.That(thrownException.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
         }
 
         [Test]
@@ -32,15 +32,15 @@ public async Task Fails_For_Code_With_Supertype_Exceptions()
                                   but threw TUnit.Assertions.Tests.Assertions.Delegates.Throws+CustomException
 
                                   at Assert.That(action).Throws<SubCustomException>()
-                                  """;
+                                  """.NormalizeLineEndings();
             Exception exception = CreateCustomException();
             Action action = () => throw exception;
 
             var sut = async ()
                 => await Assert.That(action).Throws<SubCustomException>();
 
-            await Assert.That(sut).ThrowsException()
-                .WithMessage(expectedMessage);
+            var thrownException = await Assert.That(sut).ThrowsException();
+            await Assert.That(thrownException.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
         }
 
         [Test]
@@ -51,14 +51,14 @@ public async Task Fails_For_Code_Without_Exceptions()
                                   but no exception was thrown
 
                                   at Assert.That(action).Throws<CustomException>()
-                                  """;
+                                  """.NormalizeLineEndings();
             var action = () => { };
 
             var sut = async ()
                 => await Assert.That(action).Throws<CustomException>();
 
-            await Assert.That(sut).ThrowsException()
-                .WithMessage(expectedMessage);
+            var thrownException = await Assert.That(sut).ThrowsException();
+            await Assert.That(thrownException.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
         }
 
         [Test]

TUnit.Assertions.Tests/Assertions/Delegates/Throws.WithInnerExceptionTests.cs

@@ -15,7 +15,7 @@ Expected exception message to equal "bar"
                                   but exception message was "some different inner message"
 
                                   at Assert.That(action).ThrowsException().WithInnerException().WithMessage("bar")
-                                  """;
+                                  """.NormalizeLineEndings();
             Exception exception = CreateCustomException(outerMessage,
                 CreateCustomException("some different inner message"));
             Action action = () => throw exception;
@@ -24,8 +24,8 @@ at Assert.That(action).ThrowsException().WithInnerException().WithMessage("bar")
                 => await Assert.That(action).ThrowsException()
                 .WithInnerException().WithMessage(expectedInnerMessage);
 
-            await Assert.That(sut).ThrowsException()
-                .WithMessage(expectedMessage);
+            var thrownException = await Assert.That(sut).ThrowsException();
+            await Assert.That(thrownException.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
         }
 
         [Test]

TUnit.Assertions.Tests/Assertions/Delegates/Throws.WithMessageMatchingTests.cs

@@ -42,15 +42,15 @@ Expected exception message to match pattern "bar"
                                   but exception message "foo" does not match pattern "bar"
 
                                   at Assert.That(action).ThrowsExactly<CustomException>().WithMessageMatching("bar")
-                                  """;
+                                  """.NormalizeLineEndings();
             Exception exception = CreateCustomException(message1);
             Action action = () => throw exception;
 
             var sut = async ()
                 => await Assert.That(action).ThrowsExactly<CustomException>().WithMessageMatching(message2);
 
-            await Assert.That(sut).ThrowsException()
-                .WithMessage(expectedMessage);
+            var thrownException = await Assert.That(sut).ThrowsException();
+            await Assert.That(thrownException.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
         }
 
         [Test]

TUnit.Assertions.Tests/Assertions/Delegates/Throws.WithMessageTests.cs

@@ -15,15 +15,15 @@ Expected exception message to equal "bar"
                                   but exception message was "foo"
 
                                   at Assert.That(action).ThrowsExactly<CustomException>().WithMessage("bar")
-                                  """;
+                                  """.NormalizeLineEndings();
             Exception exception = CreateCustomException(message1);
             Action action = () => throw exception;
 
             var sut = async ()
                 => await Assert.That(action).ThrowsExactly<CustomException>().WithMessage(message2);
 
-            await Assert.That(sut).ThrowsException()
-                .WithMessage(expectedMessage);
+            var thrownException = await Assert.That(sut).ThrowsException();
+            await Assert.That(thrownException.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
         }
 
         [Test]

TUnit.Assertions.Tests/Assertions/Delegates/Throws.WithParameterNameTests.cs

@@ -15,15 +15,15 @@ public async Task Fails_For_Different_Parameter_Name()
                                   but ArgumentException parameter name was "foo"
 
                                   at Assert.That(action).ThrowsExactly<ArgumentException>().WithParameterName("bar")
-                                  """;
+                                  """.NormalizeLineEndings();
             ArgumentException exception = new(string.Empty, paramName1);
             Action action = () => throw exception;
 
             var sut = async ()
                 => await Assert.That(action).ThrowsExactly<ArgumentException>().WithParameterName(paramName2);
 
-            await Assert.That(sut).ThrowsException()
-                .WithMessage(expectedMessage);
+            var thrownException = await Assert.That(sut).ThrowsException();
+            await Assert.That(thrownException.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
         }
 
         [Test]

TUnit.Assertions.Tests/Bugs/Tests2117.cs

@@ -28,12 +28,13 @@ at Assert.That(a).IsEquivalentTo(b)
         """)]
     public async Task IsEquivalent_Fail(int[] a, int[] b, CollectionOrdering? collectionOrdering, string expectedError)
     {
-        await Assert.That(async () =>
+        var exception = await Assert.That(async () =>
                 await (collectionOrdering is null
                     ? Assert.That(a).IsEquivalentTo(b)
                     : Assert.That(a).IsEquivalentTo(b, collectionOrdering.Value))
-            ).Throws<AssertionException>()
-            .WithMessage(expectedError);
+            ).Throws<AssertionException>();
+
+        await Assert.That(exception.Message.NormalizeLineEndings()).IsEqualTo(expectedError.NormalizeLineEndings());
     }
 
     [Test]
@@ -60,11 +61,12 @@ at Assert.That(a).IsNotEquivalentTo(b)
         """)]
     public async Task IsNotEquivalent_Fail(int[] a, int[] b, CollectionOrdering? collectionOrdering, string expectedError)
     {
-        await Assert.That(async () =>
+        var exception = await Assert.That(async () =>
                 await (collectionOrdering is null
                     ? Assert.That(a).IsNotEquivalentTo(b)
                     : Assert.That(a).IsNotEquivalentTo(b, collectionOrdering.Value))
-            ).Throws<AssertionException>()
-            .WithMessage(expectedError);
+            ).Throws<AssertionException>();
+
+        await Assert.That(exception.Message.NormalizeLineEndings()).IsEqualTo(expectedError.NormalizeLineEndings());
     }
 }

TUnit.Assertions.Tests/Helpers/StringDifferenceTests.cs

@@ -10,15 +10,15 @@ Expected to be equal to "some text"
                               but found ""
 
                               at Assert.That(actual).IsEqualTo(expected)
-                              """;
+                              """.NormalizeLineEndings();
         var actual = "";
         var expected = "some text";
 
         var sut = async ()
             => await Assert.That(actual).IsEqualTo(expected);
 
-        await Assert.That(sut).ThrowsException()
-            .WithMessage(expectedMessage);
+        var exception = await Assert.That(sut).ThrowsException();
+        await Assert.That(exception.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
     }
 
     [Test]
@@ -29,15 +29,15 @@ Expected to be equal to ""
                               but found "actual text"
 
                               at Assert.That(actual).IsEqualTo(expected)
-                              """;
+                              """.NormalizeLineEndings();
         var actual = "actual text";
         var expected = "";
 
         var sut = async ()
             => await Assert.That(actual).IsEqualTo(expected);
 
-        await Assert.That(sut).ThrowsException()
-            .WithMessage(expectedMessage);
+        var exception = await Assert.That(sut).ThrowsException();
+        await Assert.That(exception.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
     }
 
     [Test]
@@ -48,15 +48,15 @@ Expected to be equal to "some text"
                               but found "some"
 
                               at Assert.That(actual).IsEqualTo(expected)
-                              """;
+                              """.NormalizeLineEndings();
         var actual = "some";
         var expected = "some text";
 
         var sut = async ()
             => await Assert.That(actual).IsEqualTo(expected);
 
-        await Assert.That(sut).ThrowsException()
-            .WithMessage(expectedMessage);
+        var exception = await Assert.That(sut).ThrowsException();
+        await Assert.That(exception.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
     }
 
     [Test]
@@ -67,14 +67,14 @@ Expected to be equal to "some"
                               but found "some text"
 
                               at Assert.That(actual).IsEqualTo(expected)
-                              """;
+                              """.NormalizeLineEndings();
         var actual = "some text";
         var expected = "some";
 
         var sut = async ()
             => await Assert.That(actual).IsEqualTo(expected);
 
-        await Assert.That(sut).ThrowsException()
-            .WithMessage(expectedMessage);
+        var exception = await Assert.That(sut).ThrowsException();
+        await Assert.That(exception.Message.NormalizeLineEndings()).IsEqualTo(expectedMessage);
     }
 }