Update

Author: BenjaminMichaelis

IntelliTect.TestTools.Console.Tests/ConsoleAssertTests.cs

@@ -145,7 +145,7 @@ public void ConsoleTester_HelloWorld_DontNormalizeCRLF()
     {
         const string view = "Hello World\r\n";
 
-        Assert.ThrowsExactly<Exception>(() =>
+        Assert.ThrowsExactly<ConsoleAssertException>(() =>
         {
             ConsoleAssert.Expect(view, () =>
             {
@@ -160,7 +160,7 @@ public void ConsoleTester_HelloWorld_DontNormalizeCRLF()
     [DataRow("+hello+world+")]
     public void ConsoleTester_OutputIncludesPluses_PlusesAreNotStripped(string consoleInput)
     {
-        Exception exception = Assert.ThrowsExactly<Exception>(() =>
+        ConsoleAssertException exception = Assert.ThrowsExactly<ConsoleAssertException>(() =>
         {
             ConsoleAssert.Expect(consoleInput, () =>
             {
@@ -275,7 +275,7 @@ public void ExpectThrows_WhenNoExceptionIsThrown_ThrowsException()
     {
         const string view = @"Hello World";
 
-        Exception exception = Assert.ThrowsExactly<Exception>(() =>
+        ConsoleAssertException exception = Assert.ThrowsExactly<ConsoleAssertException>(() =>
         {
             ConsoleAssert.ExpectThrows<FormatException>(view, () =>
             {
@@ -292,7 +292,7 @@ public async Task ExpectThrowsAsync_WhenNoExceptionIsThrown_ThrowsException()
     {
         const string view = @"Hello World";
 
-        Exception exception = await Assert.ThrowsExactlyAsync<Exception>(async () =>
+        ConsoleAssertException exception = await Assert.ThrowsExactlyAsync<ConsoleAssertException>(async () =>
         {
             await ConsoleAssert.ExpectThrowsAsync<FormatException>(view, async () =>
             {
@@ -338,4 +338,21 @@ public void ExpectThrows_WithNormalizeOptions_AppliesNormalization()
         Assert.IsNotNull(exception);
         StringAssert.Contains(exception.Message, "Test exception");
     }
-}
+
+    [TestMethod]
+    public void ExpectThrows_WithWrongExpectedOutput_ThrowsConsoleAssertException()
+    {
+        const string view = "Wrong output <<invalid\n>>Error: Invalid input";
+
+        Assert.ThrowsExactly<ConsoleAssertException>(() =>
+        {
+            ConsoleAssert.ExpectThrows<FormatException>(view, () =>
+            {
+                System.Console.Write("Enter a number: ");
+                string input = System.Console.ReadLine();
+                System.Console.Write("Error: Invalid input");
+                int.Parse(input);
+            });
+        });
+    }
+}

IntelliTect.TestTools.Console/ConsoleAssert.cs

@@ -166,7 +166,7 @@ public static void Expect<T>(string expected, Func<string[], T> func, T expected
 
         if (!expectedReturn.Equals(@return))
         {
-            throw new Exception($"The value returned from {nameof(func)} ({@return}) was not the {nameof(expectedReturn)}({expectedReturn}) value.");
+            throw new ConsoleAssertException($"The value returned from {nameof(func)} ({@return}) was not the {nameof(expectedReturn)}({expectedReturn}) value.");
         }
     }
 
@@ -468,7 +468,7 @@ private static void AssertExpectation(string expectedOutput, string output, Func
         bool failTest = !areEquivalentOperator(expectedOutput, output);
         if (failTest)
         {
-            throw new Exception(GetMessageText(expectedOutput, output, equivalentOperatorErrorMessage));
+            throw new ConsoleAssertException(GetMessageText(expectedOutput, output, equivalentOperatorErrorMessage));
         }
     }
 
@@ -739,16 +739,21 @@ public static TException ExpectThrows<TException>(string expected,
         NormalizeOptions normalizeOptions = NormalizeOptions.Default)
         where TException : Exception
     {
-        try
-        {
-            Expect(expected, action, normalizeOptions);
-        }
-        catch (TException ex)
+        (string input, string expectedOutput) = Parse(expected);
+        TException caughtException = null;
+
+        string output = Execute(input, () =>
         {
-            return ex;
-        }
+            try { action(); }
+            catch (TException ex) { caughtException = ex; }
+        });
+
+        if (caughtException is null)
+            throw new ConsoleAssertException($"Expected exception of type {typeof(TException).Name} was not thrown.");
+
+        CompareOutput(output, expectedOutput, normalizeOptions, (l, r) => l == r, "Values are not equal");
 
-        throw new Exception($"Expected exception of type {typeof(TException).Name} was not thrown.");
+        return caughtException;
     }
 
     /// <summary>
@@ -768,15 +773,20 @@ public static async Task<TException> ExpectThrowsAsync<TException>(string expect
         NormalizeOptions normalizeOptions = NormalizeOptions.Default)
         where TException : Exception
     {
-        try
-        {
-            await ExpectAsync(expected, action, normalizeOptions);
-        }
-        catch (TException ex)
+        (string input, string expectedOutput) = Parse(expected);
+        TException caughtException = null;
+
+        string output = await ExecuteAsync(input, async () =>
         {
-            return ex;
-        }
+            try { await action(); }
+            catch (TException ex) { caughtException = ex; }
+        });
+
+        if (caughtException is null)
+            throw new ConsoleAssertException($"Expected exception of type {typeof(TException).Name} was not thrown.");
+
+        CompareOutput(output, expectedOutput, normalizeOptions, (l, r) => l == r, "Values are not equal");
 
-        throw new Exception($"Expected exception of type {typeof(TException).Name} was not thrown.");
+        return caughtException;
     }
-}
+}

IntelliTect.TestTools.Console/ConsoleAssertException.cs

@@ -0,0 +1,14 @@
+namespace IntelliTect.TestTools.Console;
+
+/// <summary>
+/// Exception thrown when a <see cref="ConsoleAssert"/> assertion fails.
+/// </summary>
+public class ConsoleAssertException : Exception
+{
+    /// <inheritdoc />
+    public ConsoleAssertException(string message) : base(message) { }
+
+    /// <inheritdoc />
+    public ConsoleAssertException(string message, Exception innerException)
+        : base(message, innerException) { }
+}