Message

artifacts\obj\IdentitySample.PasskeyUI\Release\net11.0\Microsoft.CodeAnalysis.Razor.Compiler\Microsoft.NET.Sdk.Razor.SourceGenerators.RazorSourceGenerator\Components\Pages\Home_razor.g.cs (1)

191statusMessage = $"Error: Could not validate credential: {attestationResult.Failure.Message}";

IIS.FunctionalTests (3)

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

243logger.LogError($"Could not read file content. Exception message {ex.Message}");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\IISFunctionalTestBase.cs (1)

46e => Logger.LogError($"Failed to remove app_offline : {e.Message}"),

src\Servers\IIS\IIS\test\Common.FunctionalTests\WindowsAuthTests.cs (1)

105Assert.Fail($"'TokenImpersonationLevel.{impersonationLevel}' failed with: {ex.Message}");

IIS.LongTests (4)

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

243logger.LogError($"Could not read file content. Exception message {ex.Message}");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\IISFunctionalTestBase.cs (1)

46e => Logger.LogError($"Failed to remove app_offline : {e.Message}"),

src\Servers\IIS\IIS\test\Common.LongTests\ShutdownTests.cs (2)

426e => Logger.LogError($"Failed to create app_offline : {e.Message}"), 604e => Logger.LogError($"Failed to touch web.config : {e.Message}"),

IIS.NewHandler.FunctionalTests (4)

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

243logger.LogError($"Could not read file content. Exception message {ex.Message}");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\IISFunctionalTestBase.cs (1)

46e => Logger.LogError($"Failed to remove app_offline : {e.Message}"),

src\Servers\IIS\IIS\test\Common.LongTests\ShutdownTests.cs (2)

426e => Logger.LogError($"Failed to create app_offline : {e.Message}"), 604e => Logger.LogError($"Failed to touch web.config : {e.Message}"),

IIS.ShadowCopy.Tests (3)

ShadowCopyTests.cs (1)

426Console.WriteLine($@"Failed to delete directory {directoryPath}: {e.Message}");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

243logger.LogError($"Could not read file content. Exception message {ex.Message}");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\IISFunctionalTestBase.cs (1)

46e => Logger.LogError($"Failed to remove app_offline : {e.Message}"),

IIS.Tests (7)

ClientDisconnectTests.cs (2)

134Assert.Equal("The client has disconnected", exception.Message); 275Assert.Equal("The client has disconnected", exception.Message);

MaxRequestBodySizeTests.cs (5)

56Assert.Equal(CoreStrings.BadRequest_RequestBodyTooLarge, exception.Message); 99Assert.Equal(CoreStrings.BadRequest_RequestBodyTooLarge, exception.Message); 309Assert.Equal(CoreStrings.BadRequest_RequestBodyTooLarge, exception.Message); 345Assert.Equal(CoreStrings.BadRequest_RequestBodyTooLarge, requestRejectedEx1.Message); 346Assert.Equal(CoreStrings.BadRequest_RequestBodyTooLarge, requestRejectedEx2.Message);

IISExpress.FunctionalTests (5)

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

243logger.LogError($"Could not read file content. Exception message {ex.Message}");

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\IISFunctionalTestBase.cs (1)

46e => Logger.LogError($"Failed to remove app_offline : {e.Message}"),

src\Servers\IIS\IIS\test\Common.FunctionalTests\WindowsAuthTests.cs (1)

105Assert.Fail($"'TokenImpersonationLevel.{impersonationLevel}' failed with: {ex.Message}");

src\Servers\IIS\IIS\test\Common.LongTests\ShutdownTests.cs (2)

426e => Logger.LogError($"Failed to create app_offline : {e.Message}"), 604e => Logger.LogError($"Failed to touch web.config : {e.Message}"),

illink (2)

Linker\Driver.cs (2)

125Console.Error.WriteLine("Cannot read response file due to '{0}'", e.Message); 961Context.LogError(null, DiagnosticId.FailedToResolveMetadataElement, re.Message);

Infrastructure.Common (2)

xunit\ConditionAttribute.cs (1)

92exc.Message));

xunit\WcfTestCase.cs (1)

86e.Message, DisplayName, item.Message, item.Payload.Count));

Infrastructure.IntegrationTests (1)

OSAndFrameworkTests.4.1.1.cs (1)

84Assert.Fail($"Creating endpoint address with serviceUri {serviceUri} threw exeception \"{e.Message}\"");

Infrastructure.Tests (1)

PowerShellScripts\PowerShellCommand.cs (1)

310catch (InvalidOperationException ie) when (ie.Message.Contains("No process is associated with this object"))

InMemory.FunctionalTests (88)

BadHttpRequestTests.cs (1)

356Assert.Equal(expectedExceptionMessage, loggedException.Message);

Http2\Http2StreamTests.cs (19)

1165Assert.Equal(expectedError.Message, thrownEx.Message); 1200Assert.Equal(expectedError.Message, thrownEx.Message); 1236Assert.Equal(expectedError.Message, thrownEx.Message); 1272Assert.Equal(expectedError.Message, thrownEx.Message); 1350Assert.Contains(LogMessages, m => m.Exception?.Message.Contains("Response Content-Length mismatch: too many bytes written (12 of 11).") ?? false); 1423Assert.Contains(LogMessages, m => m.Exception?.Message.Contains(CoreStrings.FormatTooFewBytesWritten(0, 11)) ?? false); 3111Assert.Contains(LogMessages, m => (m.Exception?.Message.Contains("App Faulted") ?? false) && m.LogLevel == LogLevel.Error); 3443Assert.Equal(CoreStrings.ConnectionAbortedByApplication, thrownEx.Message); 3470Assert.Equal("The request was aborted", thrownEx.Message); 3472Assert.Equal(CoreStrings.ConnectionAbortedByApplication, thrownEx.InnerException.Message); 4868Assert.Equal(CoreStrings.FormatTooFewBytesWritten(0, 25), ex.Message); 4991Assert.Equal("Writing is not allowed after writer was completed.", ex.Message); 5050Assert.Equal("Writing is not allowed after writer was completed.", ex.Message); 5316Assert.Equal(CoreStrings.FormatTooFewBytesWritten(11, 25), ex.Message); 5387Assert.Equal(CoreStrings.FormatTooFewBytesWritten(11, 25), ex.Message);

Http2\Http2TestBase.cs (2)

1326Assert.Contains(expectedErrorMessage, expected => message.Exception.Message.Contains(expected)); 1346Assert.Contains(LogMessages, m => m.Exception?.Message.Contains(expectedErrorMessage) ?? false);

Http2\Http2TimeoutTests.cs (12)

Http2\Http2WebSocketTests.cs (4)

457Assert.Equal(CoreStrings.FormatConnectResponseCanNotHaveBody(200), ex.Message); 459Assert.Equal(CoreStrings.FormatConnectResponseCanNotHaveBody(200), ex.Message); 466Assert.Equal(CoreStrings.FormatConnectResponseCanNotHaveBody(200), ex.Message); 468Assert.Equal(CoreStrings.FormatConnectResponseCanNotHaveBody(200), ex.Message);

Http3\Http3StreamTests.cs (8)

1245Assert.Equal(CoreStrings.FormatTooFewBytesWritten(0, 25), ex.Message); 1348Assert.Equal("Writing is not allowed after writer was completed.", ex.Message); 1400Assert.Equal("Writing is not allowed after writer was completed.", ex.Message); 1607Assert.Equal(CoreStrings.FormatTooFewBytesWritten(11, 25), ex.Message); 1665Assert.Equal(CoreStrings.FormatTooFewBytesWritten(11, 25), ex.Message); 2081Assert.Equal("The request trailers are not available yet. They may not be available until the full request body is read.", ex.Message); 2575Assert.Equal("The application completed without reading the entire request body.", requestStream.AbortReadException.Message); 2892Assert.Equal("The application completed without reading the entire request body.", requestStream.AbortReadException.Message);

Http3\Http3TestBase.cs (2)

133Assert.Contains(LogMessages, m => m.Exception?.Message.Contains(expectedErrorMessage) ?? false); 143Assert.Contains(expectedErrorMessage, expected => message.Exception.Message.Contains(expected));

HttpsConnectionMiddlewareTests.cs (3)

903Assert.Equal("Client stream needs to be drained before renegotiation.", ex.Message); 1087Assert.Equal("Client stream needs to be drained before renegotiation.", ioe.Message); 1355Assert.Equal(CoreStrings.FormatInvalidServerCertificateEku(cert.Thumbprint), ex.Message);

HttpsTests.cs (1)

578Assert.Equal("HTTP/3 requires HTTPS.", ex.InnerException.InnerException.Message);

MaxRequestBodySizeTests.cs (10)

RequestTests.cs (4)

1699Assert.Equal(CoreStrings.SynchronousReadsDisallowed, ioEx.Message); 1702Assert.Equal(CoreStrings.SynchronousReadsDisallowed, ioEx2.Message); 1792Assert.Equal(CoreStrings.SynchronousReadsDisallowed, ioEx.Message); 1795Assert.Equal(CoreStrings.SynchronousReadsDisallowed, ioEx2.Message);

ResponseDrainingTests.cs (1)

74Assert.Equal(CoreStrings.ConnectionTimedBecauseResponseMininumDataRateNotSatisfied, transportConnection.AbortReason.Message);

ResponseTests.cs (15)

704Assert.Equal(CoreStrings.FormatHeaderNotAllowedOnResponse("Content-Length", statusCode), ex.Message); 782Assert.Equal(CoreStrings.NonzeroContentLengthNotAllowedOn205, ex.Message); 820Assert.Equal(CoreStrings.FormatWritingToResponseBodyNotSupported(statusCode), ex.Message); 862Assert.Equal(CoreStrings.FormatWritingToResponseBodyNotSupported(205), ex.Message); 986logMessage.Exception.Message); 1024logMessage.Exception.Message); 1064logMessage.Exception.Message); 1099logMessage.Exception.Message); 1151ex.Message.Equals(CoreStrings.FormatTooFewBytesWritten(12, 13), StringComparison.Ordinal)); 1208ex.Message.Equals(CoreStrings.FormatTooFewBytesWritten(12, 13), StringComparison.Ordinal)); 1733expectedResponse = ex.Message; 1735httpContext.Response.ContentLength = ex.Message.Length; 1736await httpContext.Response.WriteAsync(ex.Message); 3613Assert.Equal(CoreStrings.SynchronousWritesDisallowed, ioEx.Message); 3709Assert.Equal(CoreStrings.SynchronousWritesDisallowed, ioEx.Message);

TestTransport\InMemoryTransportConnection.cs (1)

55_logger.LogDebug(@"Connection id ""{ConnectionId}"" closing because: ""{Message}""", ConnectionId, abortReason?.Message);

UpgradeTests.cs (5)

32Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, ex.Message); 35Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, ex.Message); 155Assert.Equal(CoreStrings.UpgradeCannotBeCalledMultipleTimes, ex.Message); 297Assert.Equal(CoreStrings.CannotUpgradeNonUpgradableRequest, ex.Message); 348Assert.Equal(CoreStrings.UpgradedConnectionLimitReached, exception.Message);

InProcessWebSite (2)

Startup.WebSockets.cs (2)

102if (ex.Message != "Upgrade requires HTTP/1.1." 103&& ex.Message != "Cannot upgrade a non-upgradable request. Check IHttpUpgradeFeature.IsUpgradableRequest to determine if a request can be upgraded.")

InteractiveHost.UnitTests (1)

InteractiveHostDesktopTests.cs (1)

980Assert.True(error.StartsWith($"{new Exception().GetType()}: {new Exception().Message}"));

Interop.FunctionalTests (9)

Http3\Http3RequestTests.cs (4)

523Assert.Equal("The client reset the request stream.", serverEx.Message); 589Assert.Equal("The connection was aborted by the application.", serverEx.Message); 1202Assert.Equal("The client reset the request stream.", serverEx.Message); 2238Assert.Equal("The connection was aborted because the server is shutting down and request processing didn't complete within the time specified by HostOptions.ShutdownTimeout.", rootException.Message);

Http3\Http3TlsTests.cs (1)

283Assert.Equal("The OnAuthenticate callback is not supported with HTTP/3.", exception.Message);

HttpClientHttp2InteropTests.cs (4)

600Assert.Equal("The HTTP/2 server reset the stream. HTTP/2 error code 'CANCEL' (0x8). (HttpProtocolError)", exception?.InnerException?.Message); 629Assert.Equal("The HTTP/2 server reset the stream. HTTP/2 error code 'CANCEL' (0x8). (HttpProtocolError)", exception?.InnerException?.Message); 1371Assert.Equal("The HTTP request headers length exceeded the server limit of 32768 bytes.", ex.Message); 1402Assert.Equal("The HTTP response headers length exceeded the set limit of 65536 bytes.", ex.InnerException?.InnerException?.Message);

InteropTests (3)

InteropTests.cs (1)

97_output.WriteLine($"Attempt {attempt} failed: {ex.Message}");

src\Shared\Process\ProcessExtensions.cs (2)

73catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory")) 89catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory"))

Metrics (14)

Program.cs (2)

254Console.WriteLine(ex.Message); 293Console.Write(ex.Message);

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Metrics.Legacy (14)

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

src\RoslynAnalyzers\Tools\Metrics\Program.cs (2)

254Console.WriteLine(ex.Message); 293Console.Write(ex.Message);

Microsoft.Agents.AI.ProjectTemplates.Tests (1)

test\ProjectTemplates\Infrastructure\ProcessExtensions.cs (1)

17catch (InvalidOperationException ex) when (ex.Message.Contains("No process is associated with this object"))

Microsoft.Analyzers.Local.Tests (2)

Json\JsonParseExceptionTest.cs (1)

18Assert.False(string.IsNullOrEmpty(ex.Message));

Json\JsonScannerTest.cs (1)

35Assert.Contains("'1'", ex.Message);

Microsoft.AspNetCore.Antiforgery.Test (13)

AntiforgeryApplicationBuilderExtensionsTest.cs (1)

47exception.Message);

DefaultAntiforgeryTest.cs (10)

42exception.Message); 63exception.Message); 84exception.Message); 105exception.Message); 126exception.Message); 796Assert.Equal("my-message", exception.Message); 860Assert.Equal("The required antiforgery cookie \"cookie-name\" is not present.", exception.Message); 884Assert.Equal("The required antiforgery form field \"form-field-name\" is not present.", exception.Message); 910Assert.Equal("The required antiforgery header value \"header-name\" is not present.", exception.Message); 939exception.Message);

DefaultAntiforgeryTokenGeneratorTest.cs (1)

107exception.Message);

DefaultAntiforgeryTokenSerializerTest.cs (1)

88Assert.Equal(@"The antiforgery token could not be decrypted.", ex.Message);

Microsoft.AspNetCore.App.Analyzers.Test (4)

RouteEmbeddedLanguage\RoutePatternParserTests.cs (4)

170!Regex.IsMatch(ex.Message, "^While processing template '(.*?)', a replacement value for the token '(.*?)' could not be found.")) 174throw new Exception($"Parsing '{token.ValueText}' throws RoutePattern error '{ex.Message}'. No diagnostics.", ex); 183if (!tree.Diagnostics.Any(d => ex.Message.Contains(d.Message))) 186$"Parsing '{token.ValueText}' throws RoutePattern error '{ex.Message}'. Error not found in diagnostics: " + Environment.NewLine +

Microsoft.AspNetCore.Authentication (2)

AuthenticationHandler.cs (1)

239Logger.AuthenticationSchemeNotAuthenticatedWithFailure(Scheme.Name, result.Failure.Message);

RemoteAuthenticationHandler.cs (1)

115Logger.RemoteAuthenticationError(exception.Message);

Microsoft.AspNetCore.Authentication.Core.Test (13)

AuthenticationSchemeProviderTests.cs (1)

155Assert.Contains("Scheme already exists: signin", error.Message);

AuthenticationServiceTests.cs (12)

24Assert.Contains("base", ex.Message); 63Assert.Contains("base", ex.Message); 78Assert.Contains("base", ex.Message); 125Assert.Contains("uber", ex.Message); 126Assert.Contains("signin", ex.Message); 129Assert.Contains("uber", ex.Message); 130Assert.Contains("signin", ex.Message); 148Assert.Contains("uber", ex.Message); 149Assert.Contains("signout", ex.Message); 169Assert.Contains("cannot be used for SignOutAsync", ex.Message); 171Assert.Contains("cannot be used for SignInAsync", ex.Message); 226Assert.Contains("cannot be used for SignInAsync", ex.Message);

Microsoft.AspNetCore.Authentication.Negotiate.Test (11)

EventTests.cs (6)

81Assert.Equal("InvalidBlob", context.Exception.Message); 90Assert.Equal("InvalidBlob", ex.Message); 129Assert.Equal("A test other error occurred", context.Exception.Message); 138Assert.Equal("A test other error occurred", ex.Message); 180Assert.Equal("A test credential error occurred", context.Exception.Message); 230Assert.Equal("A test client error occurred", context.Exception.Message);

NegotiateHandlerTests.cs (4)

37Assert.Equal("Negotiate authentication requires a server that supports IConnectionItemsFeature like Kestrel.", ex.Message); 102Assert.Equal("An anonymous request was received in between authentication handshake requests.", ex.Message); 112Assert.Equal("Stage1Complete", ex.Message); 330Assert.Equal("A test other error occurred", ex.Message);

ServerDeferralTests.cs (1)

30+ " Enable Windows Authentication for the server and the Negotiate Authentication handler will defer to it.", ex.Message);

Microsoft.AspNetCore.Authentication.Test (72)

AuthenticationMetricsTest.cs (5)

117Assert.Equal("An error occurred during authentication", ex.Message); 169Assert.Equal("An error occurred during challenge", ex.Message); 220Assert.Equal("An error occurred during forbid", ex.Message); 271Assert.Equal("An error occurred during sign in", ex.Message); 322Assert.Equal("An error occurred during sign out", ex.Message);

GoogleTests.cs (11)

379Assert.Equal("The oauth state was missing or invalid.", error.GetBaseException().Message); 414Assert.Equal("Access was denied by the resource owner or by the remote server.", error.GetBaseException().Message); 478ctx.Response.Redirect("/error?FailureMessage=" + UrlEncoder.Default.Encode(ctx.Failure.Message)); 514ctx.Response.Redirect("/error?FailureMessage=" + UrlEncoder.Default.Encode(ctx.Failure.Message)); 532Assert.Equal("itfailed;Description=whyitfailed;Uri=https://example.com/fail", error.GetBaseException().Message); 615ctx.Response.Redirect("/error?FailureMessage=" + UrlEncoder.Default.Encode(ctx.Failure.Message)); 642Assert.Equal("OAuth token endpoint failure: Status: BadRequest;Headers: ;Body: {\"Error\":\"Error\"};", error.GetBaseException().Message); 668ctx.Response.Redirect("/error?FailureMessage=" + UrlEncoder.Default.Encode(ctx.Failure.Message)); 694Assert.Equal("Failed to retrieve access token.", error.GetBaseException().Message); 832Assert.Equal("The oauth state was missing or invalid.", error.GetBaseException().Message); 847ctx.Response.Redirect("/error?FailureMessage=" + UrlEncoder.Default.Encode(ctx.Failure.Message));

JwtBearerTests.cs (3)

618Assert.Equal("Authentication was aborted from user code.", exception.InnerException.Message); 690Assert.Equal("Authentication was aborted from user code.", exception.InnerException.Message); 762Assert.Equal("Authentication was aborted from user code.", exception.InnerException.Message);

JwtBearerTests_Handler.cs (3)

580Assert.Equal("Authentication was aborted from user code.", exception.InnerException.Message); 646Assert.Equal("Authentication was aborted from user code.", exception.InnerException.Message); 712Assert.Equal("Authentication was aborted from user code.", exception.InnerException.Message);

OAuthTests.cs (3)

378Assert.Equal("Access was denied by the resource owner or by the remote server.", context.Failure.Message); 414Assert.Contains("custom_error", context.Failure.Message); 507Assert.StartsWith("OAuth token endpoint failure:", context.Failure.Message);

OpenIdConnect\OpenIdConnectAuthenticateTests.cs (1)

87ctx.Response.Redirect("/error?FailureMessage=" + UrlEncoder.Default.Encode(ctx.Failure.Message));

OpenIdConnect\OpenIdConnectChallengeTests.cs (3)

471Assert.Equal("Cannot redirect to the authorization endpoint, the configuration may be missing or invalid.", exception.Message); 757Assert.Equal("Pushed authorization is required by the OpenIdConnectOptions.PushedAuthorizationBehavior, but no pushed authorization endpoint is available.", exception.Message); 780Assert.Equal("Pushed authorization is required by the OpenId Connect provider, but disabled by the OpenIdConnectOptions.PushedAuthorizationBehavior.", exception.Message);

OpenIdConnect\OpenIdConnectConfigurationTests.cs (4)

480ex => Assert.Contains("cannot be set to itself", ex.Message)); 505ex => Assert.Equal("Provide Authority, MetadataAddress, Configuration, or ConfigurationManager to OpenIdConnectOptions", ex.Message) 520ex => Assert.Equal("The MetadataAddress or Authority must use HTTPS unless disabled for development by setting RequireHttpsMetadata=false.", ex.Message) 535ex => Assert.Equal("The MetadataAddress or Authority must use HTTPS unless disabled for development by setting RequireHttpsMetadata=false.", ex.Message)

OpenIdConnect\OpenIdConnectEventTests.cs (14)

72Assert.Equal("Authentication was aborted from user code.", exception.InnerException.Message); 141Assert.Equal("Authentication was aborted from user code.", exception.InnerException.Message); 250Assert.Equal("Authentication was aborted from user code.", exception.InnerException.Message); 356Assert.Equal("Authentication was aborted from user code.", exception.InnerException.Message); 464Assert.Equal("Authentication was aborted from user code.", exception.InnerException.Message); 574Assert.Equal("Authentication was aborted from user code.", exception.InnerException.Message); 655Assert.Equal("TestException", context.Exception.Message); 687Assert.Equal("TestException", context.Exception.Message); 698Assert.Equal("Authentication was aborted from user code.", exception.InnerException.Message); 720Assert.Equal("TestException", context.Exception.Message); 754Assert.Equal("TestException", context.Exception.Message); 848Assert.Equal("TestException", context.Exception.Message); 853Assert.Equal("TestException", context.Failure.Message); 885Assert.Equal("TestException", context.Failure.Message);

OpenIdConnect\OpenIdConnectEventTests_Handler.cs (14)

OpenIdConnect\OpenIdConnectTests.cs (1)

305Assert.Equal("Cannot redirect to the end session endpoint, the configuration may be missing or invalid.", exception.Message);

RemoteAuthenticationTests.cs (3)

70Assert.Contains("cannot be set to itself", error.Message); 83Assert.Contains("cannot be set to itself", error.Message); 98Assert.Contains("cannot be set to itself", error.Message);

TwitterTests.cs (3)

127Assert.Equal("Invalid state cookie.", error.GetBaseException().Message); 310Assert.Equal(expectedErrorMessage, exception.Message); 354Assert.Equal("Access was denied by the resource owner or by the remote server.", context.Failure.Message);

WsFederation\WsFederationTest.cs (2)

73Assert.Equal("Provide MetadataAddress, Configuration, or ConfigurationManager to WsFederationOptions", exception.Message); 154Assert.Contains("Unsolicited logins are not allowed.", exception.InnerException.Message);

WsFederation\WsFederationTest_Handler.cs (2)

64Assert.Equal("Provide MetadataAddress, Configuration, or ConfigurationManager to WsFederationOptions", exception.Message); 145Assert.Contains("Unsolicited logins are not allowed.", exception.InnerException.Message);

Microsoft.AspNetCore.Authorization.Test (3)

AuthorizationAppBuilderExtensionsTests.cs (1)

61ex.Message);

AuthorizationMetricsTest.cs (1)

160Assert.Equal("An error occurred in the authorization handler", ex.Message);

DefaultAuthorizationServiceTests.cs (1)

341Assert.Equal("No policy found: BogusPolicy.", exception.Message);

Microsoft.AspNetCore.Components (1)

Reflection\ComponentProperties.cs (1)

182$"type '{target.GetType().FullName}'. The error was: {ex.Message}", ex);

Microsoft.AspNetCore.Components.Authorization.Tests (3)

AuthorizeViewTest.cs (2)

246Assert.Equal("Do not specify both 'Authorized' and 'ChildContent'.", ex.Message); 493Assert.Equal("The authorization data specifies an authentication scheme with value 'test scheme'. Authentication schemes cannot be specified for components.", ex.Message);

CascadingAuthenticationStateTest.cs (1)

29Assert.Contains($"There is no registered service of type '{typeof(AuthenticationStateProvider).FullName}'.", ex.Message);

Microsoft.AspNetCore.Components.Endpoints (2)

DependencyInjection\PrerenderingErrorBoundaryLogger.cs (1)

25_exceptionCaughtByErrorBoundary(_logger, exception.Message, exception);

FormMapping\FormDataReader.cs (1)

94var errorMessage = FormattableStringFactory.Create(exception.Message);

Microsoft.AspNetCore.Components.Endpoints.Tests (19)

EndpointHtmlRendererTest.cs (6)

930Assert.Equal("Threw an exception synchronously", exception.Message); 950Assert.Equal("Threw an exception asynchronously", exception.Message); 973exception.Message); 1011exception.Message); 1078Assert.Equal(expectedError, exception.Message); 1117Assert.Equal(expectedError.ReplaceLineEndings(), exception.Message.ReplaceLineEndings());

RazorComponentResultTest.cs (4)

255Assert.Contains("A navigation command was attempted during prerendering after the server already started sending the response", ex.Message); 290Assert.Contains("Test message", ex.Message); 305Assert.Contains("Test message", ex.Message); 328Assert.Contains("Test message with markup", ex.Message);

SSRRenderModeBoundaryTest.cs (8)

38Assert.Contains($"A component of type '{typeof(TestComponent)}' has render mode '{nameof(ServerRenderModeSubclass)}'", ex.Message); 39Assert.Contains($"add a call to 'AddInteractiveServerRenderMode'", ex.Message); 52Assert.Contains($"A component of type '{typeof(TestComponent)}' has render mode '{nameof(WebAssemblyRenderModeSubclass)}'", ex.Message); 53Assert.Contains($"add a call to 'AddInteractiveWebAssemblyRenderMode'", ex.Message); 66Assert.Contains($"A component of type '{typeof(TestComponent)}' has render mode '{nameof(AutoRenderModeSubclass)}'", ex.Message); 67Assert.Contains($"add a call to 'AddInteractiveServerRenderMode'", ex.Message); 80Assert.Contains($"A component of type '{typeof(TestComponent)}' has render mode '{nameof(AutoRenderModeSubclass)}'", ex.Message); 81Assert.Contains($"add a call to 'AddInteractiveWebAssemblyRenderMode'", ex.Message);

TypeNameHashTest.cs (1)

76Assert.Equal($"Cannot compute a hash for a type without a {nameof(Type.FullName)}.", ex.Message);

Microsoft.AspNetCore.Components.Server (8)

Circuits\CircuitHost.cs (1)

1019exception.Message,

Circuits\CircuitRegistry.cs (2)

441=> UnhandledExceptionDisposingCircuitHost(logger, exception.Message, exception); 447=> ExceptionDisposingTokenSource(logger, exception.Message, exception);

Circuits\RemoteErrorBoundaryLogger.cs (1)

27Log.ExceptionCaughtByErrorBoundary(_logger, exception.Message, exception);

Circuits\RemoteRenderer.cs (2)

391=> UnhandledExceptionRenderingComponent(logger, exception.Message, exception); 403=> SendBatchDataFailed(logger, exception.Message, exception);

src\SignalR\common\Protocols.MessagePack\src\Protocol\MessagePackHubProtocolWorker.cs (1)

197error = $"Error trying to deserialize result to {itemType.Name}. {ex.Message}";

src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\MessagePackReader.cs (1)

933private static EndOfStreamException ThrowNotEnoughBytesException(Exception innerException) => throw new EndOfStreamException(new EndOfStreamException().Message, innerException);

Microsoft.AspNetCore.Components.Server.Tests (25)

Circuits\CircuitHostTest.cs (2)

633Assert.Equal("Cannot update components with mismatching types.", exception.Message); 670Assert.Equal("Cannot update components with mismatching keys.", exception.Message);

Circuits\RemoteJSDataStreamTest.cs (13)

115Assert.Equal("An error occurred while reading the remote stream: some error", ex.Message); 129Assert.Equal("The incoming data chunk cannot be empty.", ex.Message); 134Assert.Equal("The incoming data chunk cannot be empty.", ex.Message); 148Assert.Equal("The incoming data chunk exceeded the permitted length.", ex.Message); 153Assert.Equal("The incoming data chunk exceeded the permitted length.", ex.Message); 168Assert.Equal("The incoming data stream declared a length 100, but 110 bytes were sent.", ex.Message); 173Assert.Equal("The incoming data stream declared a length 100, but 110 bytes were sent.", ex.Message); 192Assert.Equal("Out of sequence chunk received, expected 5, but received 7.", ex.Message); 197Assert.Equal("Out of sequence chunk received, expected 5, but received 7.", ex.Message); 208Assert.Equal("Did not receive any data in the allotted time.", ex.Message); 233Assert.Equal("Did not receive any data in the allotted time.", ex.Message); 249Assert.Equal("Did not receive any data in the allotted time.", ex.Message); 282Assert.Equal("Did not receive any data in the allotted time.", ex.Message);

Circuits\RemoteRendererTest.cs (7)

432exception.Message); 451Assert.Equal("Exceeded the maximum number of allowed server interactive root components.", ex.Message); 467Assert.Equal("A root component with SSR component ID 0 already exists.", ex.Message); 488Assert.Equal("An invalid component marker key was provided.", ex.Message); 522Assert.Equal($"No root component exists with SSR component ID 1.", ex.Message); 542Assert.Equal("Cannot update components with mismatching keys.", ex.Message); 617Assert.Equal($"No root component exists with SSR component ID 1.", ex.Message);

ProtectedBrowserStorageTest.cs (1)

234Assert.Contains("The value is not protected with the expected purpose", innerException.Message);

src\SignalR\common\SignalR.Common\test\Internal\Protocol\MessagePackHubProtocolTestBase.cs (2)

366Assert.Equal(testData.ErrorMessage, exception.Message); 399Assert.Equal(testData.ErrorMessage, bindingFailure.BindingFailure.SourceException.Message);

Microsoft.AspNetCore.Components.Tests (89)

CascadingParameterStateTest.cs (1)

400Assert.StartsWith($"'{typeof(SupplyParameterWithSingleDeliveryAttribute)}' is flagged with SingleDelivery", ex.Message);

CascadingParameterTest.cs (4)

326Assert.Equal("The value of IsFixed cannot be changed dynamically.", ex.Message); 351Assert.Equal("The value of IsFixed cannot be changed dynamically.", ex.Message); 385Assert.Equal($"The {nameof(ParameterView)} instance can no longer be read because it has expired. {nameof(ParameterView)} can only be read synchronously and must not be stored for later use.", ex.Message); 567Assert.Contains("The current thread is not associated with the Dispatcher", ex.Message);

ComponentFactoryTest.cs (4)

72Assert.Equal($"The component activator returned a null value for a component of type {componentType.FullName}.", ex.Message); 230Assert.Equal($"The component type '{componentType}' has a fixed rendermode of '{typeof(TestRenderMode)}', so it is not valid to specify any rendermode when using this component.", ex.Message); 456Assert.Contains("There is no registered service of type", ex.Message); 473Assert.Contains("registered keyed service", ex.Message);

DependencyInjectionTest.cs (3)

51$"has no setter.", ex.Message); 64$"of type '{typeof(IMyService).FullName}'.", ex.Message); 80$"of type '{typeof(IMyService).FullName}' with key '{HasKeyedInjectableProperty.ServiceKey}'.", ex.Message);

DynamicComponentTest.cs (2)

25ex.Message); 40ex.Message);

EventCallbackFactoryBinderExtensionsTest.cs (1)

610ex.Message);

NavigationManagerTest.cs (8)

144Assert.StartsWith("Cannot have empty query parameter names.", exception.Message); 197Assert.StartsWith("Cannot format query parameters with values of type", exception.Message); 213Assert.StartsWith("Cannot have empty query parameter names.", exception.Message); 761Assert.Equal(exceptionMessage, ex.Message); 792Assert.Equal(exceptionMessage, ex.Message); 818Assert.Equal(exceptionMessage, ex.Message); 844Assert.StartsWith("To support navigation locks", ex.Message); 866Assert.StartsWith("To support navigation locks", ex.Message);

ParameterViewTest.Assignment.cs (17)

165ex.Message); 187ex.Message); 208ex.Message); 244ex.Message); 263ex.Message); 283ex.Message); 389ex.Message); 413ex.Message); 434ex.Message); 452ex.Message); 497ex.Message); 518$"type '{typeof(HasInstanceProperties).FullName}'. The error was: {ex.InnerException.Message}", 519ex.Message); 539$"type '{typeof(HasPropertyWhoseSetterThrows).FullName}'. The error was: {ex.InnerException.Message}", 540ex.Message); 558ex.Message); 581ex.Message);

ParameterViewTest.cs (1)

343Assert.Equal($"The {nameof(ParameterView)} instance can no longer be read because it has expired. {nameof(ParameterView)} can only be read synchronously and must not be stored for later use.", ex.Message);

PersistentState\ComponentStatePersistenceManagerTest.cs (1)

419Assert.Equal("State already initialized.", exception.Message);

PersistentValueProviderComponentSubscriptionTests.cs (4)

664Assert.Contains("A public property", exception.Message); 665Assert.Contains("with a public getter wasn't found", exception.Message); 687Assert.Contains("A public property", exception.Message); 688Assert.Contains("with a public getter wasn't found", exception.Message);

RendererTest.cs (10)

665Assert.Contains("declares more than one parameter", ex.Message); 688Assert.Contains($"must inherit from {typeof(EventArgs).FullName}", ex.Message); 721Assert.Equal("Error", exception.Message); 2926Assert.Equal("The render handle is not yet assigned.", ex.Message); 4433Assert.Contains("Cannot start a batch when one is already in progress.", ex.Message); 4466Assert.Equal($"The {nameof(ParameterView)} instance can no longer be read because it has expired. {nameof(ParameterView)} can only be read synchronously and must not be stored for later use.", ex.Message); 4539Assert.StartsWith($"Render output is invalid for component of type '{typeof(TestComponent).FullName}'. A frame of type 'Element' was left unclosed.", ex.Message); 4886Assert.Equal("The specified component is not a root component", ex.Message); 5079Assert.Contains($"Cannot supply a component of type '{typeof(ComponentWithUnknownRenderMode)}' because the current platform does not support the render mode '{typeof(ComponentWithUnknownRenderMode.UnknownRenderMode)}'.", ex.Message); 5097Assert.Contains($"Cannot supply a component of type '{typeof(TestComponent)}' because the current platform does not support the render mode '{typeof(ComponentWithUnknownRenderMode.UnknownRenderMode)}'.", ex.Message);

Rendering\RenderTreeBuilderTest.cs (9)

1751Assert.Equal("Cannot set a key outside the scope of a component or element.", ex.Message); 1767Assert.Equal($"Cannot set a key on a frame of type {RenderTreeFrameType.Region}.", ex.Message); 2050Assert.StartsWith($"Render output is invalid for component of type '{typeof(TestComponent).FullName}'. A frame of type 'Element' was left unclosed.", ex.Message); 2065Assert.StartsWith($"Render output is invalid for component of type '{typeof(TestComponent).FullName}'. A frame of type 'Component' was left unclosed.", ex.Message); 2080Assert.StartsWith($"Render output is invalid for component of type '{typeof(TestComponent).FullName}'. A frame of type 'Region' was left unclosed.", ex.Message); 2140Assert.Equal($"The enclosing frame is not of the required type '{nameof(RenderTreeFrameType.Component)}'.", ex.Message); 2179Assert.Equal($"Component parameters may only be added immediately after frames of type {RenderTreeFrameType.Component}", ex.Message); 2215Assert.Equal($"Named events may only be added as children of frames of type {RenderTreeFrameType.Element}", ex.Message); 2276Assert.Equal($"Attributes may only be added immediately after frames of type {RenderTreeFrameType.Element} or {RenderTreeFrameType.Component}", ex.Message);

RenderTreeDiffBuilderTest.cs (3)

399Assert.Equal("More than one sibling of element 'el' has the same key value, 'key1'. Key values must be unique.", ex.Message); 416Assert.Equal("More than one sibling of element 'el' has the same key value, 'key1'. Key values must be unique.", ex.Message); 433Assert.Equal("More than one sibling of element 'el' has the same key value, 'key1'. Key values must be unique.", ex.Message);

RouteViewTest.cs (1)

41Assert.Equal($"The {nameof(RouteView)} component requires a non-null value for the parameter {nameof(RouteView.RouteData)}.", ex.Message);

Routing\QueryParameterValueSupplierTest.cs (4)

176Assert.Equal($"Cannot parse the value '{value.Replace('+', ' ')}' as type '{targetType}' for '{key}'.", ex.Message); 201Assert.Equal($"Cannot parse the value '{invalidValue.Replace('+', ' ')}' as type '{targetType}' for '{key}'.", ex.Message); 218Assert.Equal($"Cannot parse the value '' as type '{targetType}' for '{key}'.", ex.Message); 284Assert.Equal($"Cannot parse the value '' as type '{targetType}' for '{key}'.", ex.Message);

Routing\RouterTest.cs (3)

301Assert.Contains("Setting NotFound and NotFoundPage properties simultaneously is not supported", exception.Message); 302Assert.Contains("Use either NotFound or NotFoundPage", exception.Message); 488Assert.Contains("No component found for route '/nonexistent-route'", exception.Message);

Routing\RouteTableFactoryTests.cs (2)

852exception.Message.Contains("The following routes are ambiguous"); 1048Assert.Equal(expectedMessage, exception.Message);

Routing\TemplateParserTests.cs (10)

132Assert.Equal(expectedMessage, ex.Message); 150Assert.Equal(expectedMessage, ex.Message); 165Assert.Equal(expectedMessage, ex.Message); 175Assert.Equal(expectedMessage, ex.Message); 185Assert.Equal(expectedMessage, ex.Message); 195Assert.Equal(expectedMessage, ex.Message); 205Assert.Equal(expectedMessage, ex.Message); 218Assert.Equal(expectedMessage, ex.Message); 228Assert.Equal(expectedMessage, ex.Message); 238Assert.Equal(expectedMessage, ex.Message);

StackObjectPoolTest.cs (1)

100Assert.Equal("There are no outstanding instances to return.", ex.Message);

Microsoft.AspNetCore.Components.Web.Tests (25)

Forms\BrowserFileTest.cs (1)

29Assert.Equal("Supplied file with size 100 bytes exceeds the maximum of 80 bytes.", ex.Message);

Forms\DisplayNameTest.cs (2)

32Assert.Contains("For", ex.Message); 33Assert.Contains("parameter", ex.Message);

Forms\EditFormTest.cs (2)

44Assert.StartsWith($"{nameof(EditForm)} requires a {nameof(EditForm.Model)} parameter, or an {nameof(EditContext)} parameter, but not both.", ex.Message); 58Assert.StartsWith($"{nameof(EditForm)} requires either a {nameof(EditForm.Model)} parameter, or an {nameof(EditContext)} parameter, please provide one of these.", ex.Message);

Forms\InputBaseTest.cs (2)

22Assert.StartsWith($"{typeof(TestInputComponent<string>)} does not support changing the EditContext dynamically", ex.Message); 34Assert.Contains($"{typeof(TestInputComponent<string>)} requires a value for the 'ValueExpression' parameter. Normally this is provided automatically when using 'bind-Value'.", ex.Message);

Forms\InputFileChangeEventArgsTest.cs (3)

31Assert.StartsWith("No file was supplied", ex.Message); 39Assert.StartsWith("More than one file was supplied", ex.Message); 63Assert.Equal($"The maximum number of files accepted is 1, but 2 were supplied.", ex.Message);

Forms\InputRadioTest.cs (1)

24Assert.Contains($"must have an ancestor", ex.Message);

Forms\LabelTest.cs (1)

229Assert.Contains("For", exception.Message);

Forms\Mapping\FormMappingScopeTest.cs (3)

92Assert.Equal($"The FormMappingScope component requires a nonempty Name parameter value.", exception.Message); 107Assert.Equal($"The FormMappingScope component requires a nonempty Name parameter value.", exception.Message); 131Assert.Equal("FormMappingScope 'Name' can't change after initialization.", exception.Message);

HtmlRendering\HtmlRendererTest.cs (6)

30Assert.Contains("The current thread is not associated with the Dispatcher", ex.Message); 43Assert.Contains("The current thread is not associated with the Dispatcher", ex.Message); 901Assert.Equal("sync", ex.Message); 921Assert.Equal("async", ex.Message); 942Assert.Equal("sync", ex.Message); 967Assert.Equal("async", ex.Message);

Virtualization\VirtualizeTest.cs (4)

31Assert.Contains("requires a positive value for parameter", ex.Message); 50Assert.Contains("can only accept one item source from its parameters", ex.Message); 69Assert.Contains("parameters to be specified and non-null", ex.Message); 99Assert.Equal("Thrown from items provider.", ex.Message);

Microsoft.AspNetCore.Components.WebAssembly (3)

Rendering\WebAssemblyRenderer.cs (2)

204Log.UnhandledExceptionRenderingComponent(_logger, innerException.Message, innerException); 209Log.UnhandledExceptionRenderingComponent(_logger, exception.Message, exception);

src\Components\Shared\src\TransmitDataStreamToJS.cs (1)

35await runtime.InvokeVoidAsync(methodIdentifier, streamId, Array.Empty<byte>(), 0, ex.Message);

Microsoft.AspNetCore.Components.WebAssembly.Tests (5)

Hosting\WebAssemblyCultureProviderTest.cs (1)

58ex.Message);

Hosting\WebAssemblyHostTest.cs (1)

57Assert.Equal("The host has already started.", ex.Message);

PullFromJSDataStreamTest.cs (3)

73Assert.Equal("Failed to read the requested number of bytes from the stream.", ex.Message); 87Assert.Equal("Failed to read the requested number of bytes from the stream.", ex.Message); 101Assert.Equal("Failed to read the requested number of bytes from the stream.", ex.Message);

Microsoft.AspNetCore.Components.WebView (2)

IpcSender.cs (1)

88var message = IpcCommon.Serialize(IpcCommon.OutgoingMessageType.NotifyUnhandledException, exception.Message, exception.StackTrace);

src\Components\Shared\src\TransmitDataStreamToJS.cs (1)

35await runtime.InvokeVoidAsync(methodIdentifier, streamId, Array.Empty<byte>(), 0, ex.Message);

Microsoft.AspNetCore.Components.WebView.Test (1)

WebViewManagerTests.cs (1)

110Assert.Equal($"There is already a root component with selector '{arbitraryComponentSelector}'.", ex.Message);

Microsoft.AspNetCore.Components.WebViewE2E.Test (2)

BasicBlazorHybridTest.cs (2)

56Console.WriteLine($"Exception {ex.GetType().FullName} while creating window: {ex.Message}"); 138Console.WriteLine("EXCEPTION DURING TEST: " + ex.Message);

Microsoft.AspNetCore.Cors.Test (1)

CorsPolicyBuilderTests.cs (1)

345Assert.Equal(Resources.InsecureConfiguration, ex.Message);

Microsoft.AspNetCore.DataProtection.Abstractions.Tests (1)

DataProtectionCommonExtensionsTests.cs (1)

117Assert.Equal(Resources.FormatDataProtectionExtensions_NoService(typeof(IDataProtectionProvider).FullName), ex.Message);

Microsoft.AspNetCore.DataProtection.Extensions.Tests (4)

TimeLimitedDataProtectorTests.cs (4)

109Assert.Equal(ExtResources.FormatTimeLimitedDataProtector_PayloadExpired(expectedExpiration), ex.Message); 130Assert.Equal(ExtResources.TimeLimitedDataProtector_PayloadInvalid, ex.Message); 147Assert.Equal(Resources.CryptCommon_GenericError, ex.Message); 148Assert.Equal("How exceptional!", ex.InnerException.Message);

Microsoft.AspNetCore.DataProtection.Tests (21)

ActivatorTests.cs (1)

64Assert.Equal(Resources.FormatTypeExtensions_BadCast(typeof(IDisposable).AssemblyQualifiedName, typeof(ClassWithParameterlessCtor).AssemblyQualifiedName), ex.Message);

AuthenticatedEncryption\ConfigurationModel\ManagedAuthenticatedEncryptorDescriptorDeserializerTests.cs (1)

128Assert.Equal($"Algorithm type {typeof(CustomAlgorithmNoConstructor).FullName} doesn't have a public parameterless constructor. If the app is published with trimming then the constructor may have been trimmed. Ensure the type's assembly is excluded from trimming.", ex.Message);

KeyManagement\KeyRingBasedDataProtectorTests.cs (13)

161Assert.Equal(Resources.ProtectionProvider_BadMagicHeader, ex.Message); 179Assert.Equal(Resources.ProtectionProvider_BadMagicHeader, ex.Message); 197Assert.Equal(Resources.ProtectionProvider_BadVersion, ex.Message); 228Assert.Equal(Error.Common_KeyNotFound(notFoundKeyId).Message, ex.Message); 281Assert.Equal(Error.Common_KeyNotFound(notFoundKeyId).Message, ex.Message); 317Assert.Equal(Error.Common_KeyNotFound(notFoundKeyId).Message, ex.Message); 415Assert.Equal(Error.Common_KeyRevoked(keyId).Message, ex.Message); 755Assert.Equal(Resources.ProtectionProvider_BadMagicHeader, ex.Message); 776Assert.Equal(Resources.ProtectionProvider_BadMagicHeader, ex.Message);

KeyManagement\KeyRingProviderTests.cs (1)

267Assert.Equal(Resources.KeyRingProvider_NoDefaultKey_AutoGenerateDisabled, exception.Message);

RegistryPolicyResolverTests.cs (1)

67Assert.Equal($"Unable to load type '{typeName}'. If the app is published with trimming then this type may have been trimmed. Ensure the type's assembly is excluded from trimming.", ex.Message);

TypeForwardingActivatorTests.cs (1)

40Assert.Contains("Microsoft.AspNet.DataProtection.Test", exception.Message);

XmlEncryption\EncryptedXmlDecryptorTests.cs (3)

26Assert.Equal("Unable to retrieve the decryption key.", ex.Message); 44Assert.Equal("Unable to retrieve the decryption key.", ex.Message); 62Assert.Equal("Unable to retrieve the decryption key.", ex.Message);

Microsoft.AspNetCore.DeveloperCertificates.XPlat (14)

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (3)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (11)

Microsoft.AspNetCore.DeveloperCertificates.XPlat.Tests (1)

CertificateManagerTests.cs (1)

105Output.WriteLine(e.Message);

Microsoft.AspNetCore.Diagnostics (4)

DeveloperExceptionPage\DeveloperExceptionPageMiddlewareImpl.cs (1)

254Detail = errorContext.Exception.Message,

DeveloperExceptionPage\Views\ErrorPage.Designer.cs (3)

360Output.Write(HtmlEncodeAndReplaceLineBreaks(errorDetail.Error.Message)); 477Write(ex!.Message); 575Write(errorDetail.Error.Message);

Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore (1)

Views\DatabaseErrorPage.Designer.cs (1)

168Write(ex.Message);

Microsoft.AspNetCore.Diagnostics.HealthChecks.Tests (8)

HealthCheckEndpointRouteBuilderExtensionsTest.cs (1)

44ex.Message);

HealthCheckMiddlewareTests.cs (7)

39ex.Message); 939Assert.Contains($"{nameof(HealthStatus)}.{nameof(HealthStatus.Healthy)}", exception.Message); 940Assert.Contains($"{nameof(HealthStatus)}.{nameof(HealthStatus.Degraded)}", exception.Message); 941Assert.Contains($"{nameof(HealthStatus)}.{nameof(HealthStatus.Unhealthy)}", exception.Message); 956Assert.DoesNotContain($"{nameof(HealthStatus)}.{nameof(HealthStatus.Healthy)}", exception.Message); 957Assert.Contains($"{nameof(HealthStatus)}.{nameof(HealthStatus.Degraded)}", exception.Message); 958Assert.Contains($"{nameof(HealthStatus)}.{nameof(HealthStatus.Unhealthy)}", exception.Message);

Microsoft.AspNetCore.Diagnostics.Middleware.Tests (4)

Logging\AcceptanceTests.cs (3)

656Assert.Equal("Test exception", ex.Message); 697Assert.Equal("Test exception", originalException!.Message); 731Assert.Equal("Test exception", originalException!.Message);

Logging\LoggingOptionsValidationTests.cs (1)

31Assert.Equal($"Unsupported value '{mode}' for enum type 'IncomingPathLoggingMode'", ex.Message);

Microsoft.AspNetCore.Diagnostics.Tests (11)

DeveloperExceptionPageMiddlewareTest.cs (4)

39context.ProblemDetails.Extensions.Add("OriginalExceptionMessage", context.Exception.Message); 87context.ProblemDetails.Extensions.Add("OriginalExceptionMessage", feature?.Error.Message); 146context.ProblemDetails.Extensions.Add("OriginalExceptionMessage", feature?.Error.Message); 653return context.HttpContext.Response.WriteAsync(context.Exception.Message);

ExceptionHandlerMiddlewareTest.cs (2)

47context.ProblemDetails.Extensions.Add("OriginalExceptionMessage", context.Exception.Message); 591Assert.Equal("Test exception", feature.Error.Message);

ExceptionHandlerTest.cs (5)

90Assert.Equal("Something bad happened", exception.Message); 403Assert.Equal("Something bad happened", exception.Message); 533exception.Message); 565"If the exception handler is expected to return 404 status responses then set AllowStatusCode404Response to true.", exception.Message); 570Assert.Equal("Something bad happened.", exception.InnerException.Message);

Microsoft.AspNetCore.Grpc.JsonTranscoding (3)

Internal\CommonGrpcProtocolHelpers.cs (2)

14return ex.InnerException == null ? $"{ex.GetType().Name}: {ex.Message}" : BuildErrorMessage(ex); 35sb.Append(current.Message);

Internal\JsonRequestHelpers.cs (1)

314throw new RpcException(new Status(StatusCode.InvalidArgument, ex.Message, ex));

Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests (27)

ConverterTests\JsonConverterReadTests.cs (5)

323AssertReadJsonError<HelloRequest.Types.DataTypes>(json, ex => Assert.Equal(@"Error converting value ""INVALID"" to enum type Transcoding.HelloRequest+Types+DataTypes+Types+NestedEnum.", ex.Message), descriptorRegistry: serviceDescriptorRegistry, deserializeOld: false); 597AssertReadJsonError<HelloRequest>(json, ex => Assert.Equal("Multiple values specified for oneof oneof_test", ex.Message.TrimEnd('.'))); 608AssertReadJsonError<HelloRequest>(json, ex => Assert.Equal("Multiple values specified for oneof oneof_test", ex.Message.TrimEnd('.')), deserializeOld: false, settings: new GrpcJsonSettings { PropertyNameCaseInsensitive = true }); 725AssertReadJsonError<NullValueContainer>(json, ex => Assert.Equal("Invalid enum value: MONKEY for enum type: google.protobuf.NullValue", ex.Message)); 833AssertReadJsonError<FieldNameCaseMessage>(json, ex => Assert.Equal("The JSON property name for 'Transcoding.FieldNameCaseMessage.A' collides with another property.", ex.Message), deserializeOld: false, settings: new GrpcJsonSettings { PropertyNameCaseInsensitive = true });

HttpRoutePatternParserTests.cs (1)

323Assert.Equal(errorMessage, ex.InnerException!.Message);

JsonTranscodingServiceMethodProviderTests.cs (17)

ServerStreamingServerCallHandlerTests.cs (2)

122Assert.Equal("Exception!", exceptionWrite.Exception.Message); 201Assert.Equal("Exception!", exceptionWrite.Exception.Message);

UnaryServerCallHandlerTests.cs (2)

1059Assert.Equal("Error!", exceptionWrite.Exception.Message); 1089Assert.Equal("Error!", exceptionWrite.Exception.Message);

Microsoft.AspNetCore.HeaderPropagation.Tests (3)

HeaderPropagationIntegrationTest.cs (3)

73captured.Message); 95exception.Message); 167exception.Message);

Microsoft.AspNetCore.Hosting (5)

Internal\HostingApplicationDiagnostics.cs (1)

544activity.SetStatus(ActivityStatusCode.Error, exception.Message);

Internal\HostingLoggerExtensions.cs (1)

35message = message + Environment.NewLine + ex.Message;

src\Shared\ErrorPage\ErrorPage.Designer.cs (3)

307Output.Write(HtmlEncodeAndReplaceLineBreaks(errorDetail.Error!.Message)); 417Write(ex.Message); 475Write(errorDetail.Error!.Message);

Microsoft.AspNetCore.Hosting.Tests (24)

ConfigureBuilderTests.cs (2)

30+ $" 'service' of method '{methodInfo.Name}' on type '{methodInfo.DeclaringType.FullName}'.", ex.Message); 34Assert.Equal("Service instantiation failed", ex.InnerException.Message);

StartupManagerTests.cs (5)

81Assert.Equal(expectedMessage, exception.Message); 368Assert.Equal("A public method named 'ConfigureBoom' or 'Configure' could not be found in the 'Microsoft.AspNetCore.Hosting.Fakes.StartupBoom' type.", ex.Message); 417Assert.Equal("Having multiple overloads of method 'Configure' is not supported.", ex.Message); 432Assert.Equal("A public method named 'ConfigurePrivateConfigure' or 'Configure' could not be found in the 'Microsoft.AspNetCore.Hosting.Fakes.StartupPrivateConfigure' type.", ex.Message); 446Assert.Equal("Having multiple overloads of method 'ConfigureServices' is not supported.", ex.Message);

WebHostBuilderTests.cs (15)

80Assert.Equal("The specified factory returned null startup instance.", ex.Message); 427Assert.Equal("A public method named 'ConfigureProduction' or 'Configure' could not be found in the 'Microsoft.AspNetCore.Hosting.Fakes.StartupBoom' type.", exception.Message); 459Assert.Equal("A public method named 'ConfigureProduction' or 'Configure' could not be found in the 'Microsoft.AspNetCore.Hosting.Fakes.StartupBoom' type.", exception.Message); 724Assert.Contains("No application configured.", ex.Message); 846Assert.Equal("WebHostBuilder allows creation only of a single instance of WebHost", ex.Message); 1010Assert.Equal("Microsoft.AspNetCore.Hosting.IStartup isn't supported", exception.Message); 1026Assert.Equal("Building this implementation of IWebHostBuilder is not supported.", exception.Message); 1042Assert.Equal($"ConfigureServices returning an {typeof(IServiceProvider)} isn't supported.", exception.Message); 1234Assert.Contains(sink.Writes, w => w.Exception?.Message == "Startup exception"); 1258Assert.Contains(testSink.Writes, w => w.Exception?.Message == "Startup exception"); 1317Assert.Contains("No application configured.", exception.Message); 1359Assert.Equal("Hosted Service throws in StartAsync", startEx.Message); 1365Assert.Equal("Hosted Service throws in StopAsync", stopEx.Message); 1384Assert.Equal("Hosted Service throws in StartAsync", startEx.Message); 1391Assert.Equal("Hosted Service throws in StopAsync", stopEx.Message);

WebHostTests.cs (2)

30Assert.Equal("No service for type 'Microsoft.AspNetCore.Hosting.Server.IServer' has been registered.", ex.Message); 993Assert.Contains("ConfigureServices", ex.Message);

Microsoft.AspNetCore.Http.Abstractions.Tests (17)

RouteValueDictionaryTests.cs (1)

358Assert.Equal(message, exception.Message, ignoreCase: true);

UseExtensionsTests.cs (1)

74Assert.Equal("From Use", ex.Message);

UseMiddlewareTest.cs (15)

Microsoft.AspNetCore.Http.Connections.Client (1)

HttpConnection.cs (1)

420transportExceptions.Add(new TransportFailedException(transportType.ToString(), ex.Message, ex));

Microsoft.AspNetCore.Http.Connections.Tests (6)

HttpConnectionManagerTests.cs (4)

135Assert.Equal("Reading is not allowed after reader was completed.", exception.Message); 138Assert.Equal("Reading is not allowed after reader was completed.", exception.Message); 326Assert.Equal("Error", exception.Message); 329Assert.Equal("Error", exception.Message);

NegotiateProtocolTests.cs (2)

64Assert.Equal(expectedMessage, exception.InnerException.Message); 84Assert.Equal("Detected a connection attempt to an ASP.NET SignalR Server. This client only supports connecting to an ASP.NET Core SignalR Server. See https://aka.ms/signalr-core-differences for details.", exception.InnerException.Message);

Microsoft.AspNetCore.Http.Extensions (1)

src\Components\Endpoints\src\FormMapping\FormDataReader.cs (1)

94var errorMessage = FormattableStringFactory.Create(exception.Message);

Microsoft.AspNetCore.Http.Results.Tests (6)

LocalRedirectResultTests.cs (2)

96exception.Message); 117exception.Message);

ResultsTests.cs (2)

1052Assert.Equal(ex.Message, $"Unable to obtain the JsonTypeInfo for type 'Microsoft.AspNetCore.Http.HttpResults.ResultsTests+Todo' from the context '{typeof(StringJsonContext).FullName}'."); 1059Assert.Equal(ex.Message, $"Unable to obtain the JsonTypeInfo for type 'Microsoft.AspNetCore.Http.HttpResults.ResultsTests+Todo' from the context '{typeof(StringJsonContext).FullName}'.");

src\Shared\ResultsTests\PhysicalFileResultTestBase.cs (1)

387Assert.Equal(expectedMessage, ex.Message);

TypedResultsTests.cs (1)

906Assert.Equal(ex.Message, $"Unable to obtain the JsonTypeInfo for type 'System.String' from the context '{typeof(ObjectJsonContext).FullName}'.");

Microsoft.AspNetCore.Http.Tests (8)

ApplicationBuilderTests.cs (1)

75Assert.Equal(expected, ex.Message);

DefaultHttpContextTests.cs (1)

24Assert.Equal("Session has not been configured for this application or request.", exception.Message);

Features\FormFeatureTests.cs (6)

43Assert.Equal("Form value count limit 1 exceeded.", exception.Message); 469Assert.Equal("Form value count limit 2 exceeded.", exception.Message); 493Assert.Equal("Form value count limit 2 exceeded.", exception.Message); 517Assert.Equal("Form value count limit 2 exceeded.", exception.Message); 541Assert.Equal("Form value count limit 2 exceeded.", exception.Message); 610Assert.Equal("Form section has invalid Content-Disposition value: " + InvalidContentDispositionValue, exception.Message);

Microsoft.AspNetCore.HttpLogging.Tests (2)

HttpLoggingServicesExtensionsTests.cs (2)

34Assert.Equal("Unable to find the required services. Please add all the required services by calling 'IServiceCollection.AddHttpLogging' in the application startup code.", ex.Message); 46Assert.Equal("Unable to find the required services. Please add all the required services by calling 'IServiceCollection.AddW3CLogging' in the application startup code.", ex.Message);

Microsoft.AspNetCore.HttpOverrides.Tests (1)

IPNetworkTest.cs (1)

98Assert.Equal("An invalid IP address or prefix length was specified.", ex.Message);

Microsoft.AspNetCore.HttpsPolicy.Tests (1)

HttpsRedirectionMiddlewareTests.cs (1)

314"Set the desired port explicitly on HttpsRedirectionOptions.HttpsPort.", ex.Message);

Microsoft.AspNetCore.Identity (5)

PasskeyExceptionExtensions.cs (1)

76=> new($"An exception occurred while parsing the attestation object: {ex.Message}", ex);

PasskeyHandler.cs (2)

180return PasskeyAttestationResult.Fail(new PasskeyException($"An unexpected error occurred during passkey attestation: {ex.Message}", ex)); 204return PasskeyAssertionResult.Fail<TUser>(new PasskeyException($"An unexpected error occurred during passkey assertion: {ex.Message}", ex));

SignInManager.cs (2)

579Logger.LogDebug(EventIds.PasskeyAttestationFailed, "Passkey attestation failed: {message}", result.Failure.Message); 623Logger.LogDebug(EventIds.PasskeyAssertionFailed, "Passkey assertion failed: {message}", result.Failure.Message);

Microsoft.AspNetCore.Identity.EntityFrameworkCore.Test (3)

UserStoreEncryptPersonalDataTest.cs (1)

292Assert.Equal("[ProtectedPersonalData] only works strings by default.", e.Message);

UserStoreWithGenericsTest.cs (2)

84Assert.Contains("AddEntityFrameworkStores", e.Message); 93Assert.Contains("AddEntityFrameworkStores", e.Message);

Microsoft.AspNetCore.Identity.Specification.Tests (4)

UserManagerSpecificationTests.cs (4)

1692Assert.Equal(error, ex.Message); 1695Assert.Equal(error, ex.Message); 1698Assert.Equal(error, ex.Message); 1701Assert.Equal(error, ex.Message);

Microsoft.AspNetCore.Identity.Test (141)

Passkeys\PasskeyHandlerAssertionTest.cs (65)

Passkeys\PasskeyHandlerAttestationTest.cs (69)

PasswordHasherTest.cs (2)

33Assert.Equal("The provided PasswordHasherCompatibilityMode is invalid.", ex.Message); 46Assert.Equal("The iteration count must be a positive integer.", ex.Message);

UserManagerTest.cs (5)

687Assert.Contains(Extensions.Identity.Core.Resources.NullSecurityStamp, ex.Message); 714Assert.Contains(Extensions.Identity.Core.Resources.NullSecurityStamp, ex.Message); 1144Assert.Contains("Store does not implement IProtectedUserStore", e.Message); 1155Assert.Contains("No IPersonalDataProtector service was registered", e.Message); 1336Assert.Equal(expectedMessage, error.Message);

Microsoft.AspNetCore.InternalTesting (2)

ExceptionAssertions.cs (2)

260Assert.Equal(expectedMessage, exception.Message); 264Assert.Contains(expectedMessage, exception.Message);

Microsoft.AspNetCore.InternalTesting.Tests (11)

EventSourceValidatorTests.cs (4)

37Assert.Contains("Duplicate EventId 1", ex.Message); 38Assert.Contains("EventAlpha", ex.Message); 39Assert.Contains("EventBeta", ex.Message); 49Assert.Contains("does not derive from EventSource", ex.Message);

LogValuesAssertTest.cs (4)

122Assert.Contains(GetString(expectedValues), equalException.Message); 123Assert.Contains(GetString(actualValues), equalException.Message); 210Assert.Contains(GetString(expectedValues), equalException.Message); 211Assert.Contains(GetString(actualValues), equalException.Message);

TaskExtensionsTest.cs (2)

73Assert.Equal(message, exception.Message); 86Assert.Equal(message, exception.Message);

TestPathUtilitiesTest.cs (1)

19Assert.Equal($"Solution file NotTesting.slnf could not be found in {AppContext.BaseDirectory} or its parent directories.", exception.Message);

Microsoft.AspNetCore.JsonPatch (2)

JsonPatchDocument.cs (1)

175errorReporter(new JsonPatchError(objectToApplyTo, op, jsonPatchException.Message));

JsonPatchDocumentOfT.cs (1)

611errorReporter(new JsonPatchError(objectToApplyTo, op, jsonPatchException.Message));

Microsoft.AspNetCore.JsonPatch.SystemTextJson (2)

JsonPatchDocument.cs (1)

178errorReporter(new JsonPatchError(objectToApplyTo, op, jsonPatchException.Message));

JsonPatchDocumentOfT.cs (1)

614errorReporter(new JsonPatchError(objectToApplyTo, op, jsonPatchException.Message));

Microsoft.AspNetCore.JsonPatch.SystemTextJson.Tests (14)

IntegrationTests\AnonymousObjectIntegrationTest.cs (6)

29exception.Message); 52exception.Message); 75exception.Message); 99exception.Message); 123exception.Message); 164exception.Message);

IntegrationTests\DictionaryIntegrationTest.cs (1)

174Assert.Equal("The current value 'James' at path 'Name' is not equal to the test value 'Mike'.", exception.Message);

IntegrationTests\ListIntegrationTest.cs (3)

50exception.Message); 166Assert.Equal($"The index value provided by path segment '{position}' is out of bounds of the array size.", exception.Message); 251Assert.Equal("The index value provided by path segment '-1' is out of bounds of the array size.", exception.Message);

IntegrationTests\SimpleObjectIntegrationTest.cs (1)

167Assert.Equal("For operation 'move', the target location specified by path '/Object/goodbye' was not found.", ex.Message);

JsonPatchDocumentGetPathTest.cs (1)

103Assert.Equal("The expression '(p.IntegerValue >= 4)' is not supported. Supported expressions include member access and indexer expressions.", exception.Message);

JsonPatchDocumentTest.cs (2)

31exception.Message); 49exception.Message);

Microsoft.AspNetCore.JsonPatch.Tests (25)

IntegrationTests\AnonymousObjectIntegrationTest.cs (7)

28exception.Message); 52exception.Message); 75exception.Message); 98exception.Message); 122exception.Message); 146exception.Message); 187exception.Message);

IntegrationTests\DictionaryIntegrationTest.cs (1)

174Assert.Equal("The current value 'James' at path 'Name' is not equal to the test value 'Mike'.", exception.Message);

IntegrationTests\DynamicObjectIntegrationTest.cs (3)

66Assert.Equal("The target location specified by path segment 'OtherProperty' was not found.", exception.Message); 166Assert.Equal("The target location specified by path segment 'Simpleobject' was not found.", exception.Message); 231Assert.Equal("The current value '1' at position '0' is not equal to the test value '2'.", exception.Message);

IntegrationTests\ExpandoObjectIntegrationTest.cs (5)

154exception.Message); 175exception.Message); 278Assert.Equal("The target location specified by path segment 'NonExisting' was not found.", exception.Message); 318Assert.Equal("The target location specified by path segment 'test' was not found.", exception.Message); 360Assert.Equal("The target location specified by path segment 'test' was not found.", exception.Message);

IntegrationTests\ListIntegrationTest.cs (3)

IntegrationTests\SimpleObjectIntegrationTest.cs (1)

167Assert.Equal("For operation 'move', the target location specified by path '/Object/goodbye' was not found.", ex.Message);

JsonPatchDocumentGetPathTest.cs (1)

103Assert.Equal("The expression '(p.IntegerValue >= 4)' is not supported. Supported expressions include member access and indexer expressions.", exception.Message);

JsonPatchDocumentTest.cs (4)

27exception.Message); 45exception.Message); 142Assert.Equal("The JSON patch document was malformed and could not be parsed.", exception.Message); 159Assert.Equal("The JSON patch document was malformed and could not be parsed.", exception.Message);

Microsoft.AspNetCore.Mvc.Abstractions (4)

ModelBinding\ModelStateDictionary.cs (4)

213&& !string.IsNullOrEmpty(exception.Message)) 216return TryAddModelError(key, exception.Message); 306&& !string.IsNullOrEmpty(exception.Message)) 309return TryAddModelError(key, exception.Message);

Microsoft.AspNetCore.Mvc.Abstractions.Test (13)

ModelBinding\ModelStateDictionaryTest.cs (13)

Microsoft.AspNetCore.Mvc.Core (10)

ApplicationModels\ApplicationModelFactory.cs (1)

167ex.Message);

Formatters\SystemTextJsonInputFormatter.cs (1)

152=> JsonInputException(logger, exception.Message);

ModelBinding\Binders\DictionaryModelBinder.cs (1)

174bindingContext.ModelState.AddModelError(bindingContext.ModelName, ex.Message);

ModelBinding\FormFileValueProviderFactory.cs (2)

43throw new ValueProviderException(Resources.FormatFailedToReadRequestForm(ex.Message), ex); 49throw new ValueProviderException(Resources.FormatFailedToReadRequestForm(ex.Message), ex);

ModelBinding\FormValueProviderFactory.cs (2)

45throw new ValueProviderException(Resources.FormatFailedToReadRequestForm(ex.Message), ex); 51throw new ValueProviderException(Resources.FormatFailedToReadRequestForm(ex.Message), ex);

ModelBinding\JQueryFormValueProviderFactory.cs (2)

45throw new ValueProviderException(Resources.FormatFailedToReadRequestForm(ex.Message), ex); 51throw new ValueProviderException(Resources.FormatFailedToReadRequestForm(ex.Message), ex);

Routing\AttributeRoute.cs (1)

203routeInfo.ErrorMessage = ex.Message;

Microsoft.AspNetCore.Mvc.Core.Test (101)

ApplicationModels\ApiBehaviorApplicationModelProviderTest.cs (1)

37Assert.Equal(expected, ex.Message);

ApplicationModels\AttributeRouteModelTests.cs (2)

174Assert.Equal(expected, ex.Message); 201Assert.Equal(expected, ex.Message);

ApplicationModels\ControllerActionDescriptorProviderTests.cs (20)

ApplicationModels\InferParameterBindingInfoConventionTest.cs (3)

68Assert.Equal(expected, ex.Message); 87Assert.Equal(expected, ex.Message); 106Assert.Equal(expected, ex.Message);

ApplicationParts\RelatedAssemblyPartTest.cs (1)

37Assert.Equal(expected, ex.Message);

Authorization\AuthorizeFilterTest.cs (2)

65Assert.Equal(expected, ex.Message); 81Assert.Equal(expected, ex.Message);

Builder\MvcApplicationBuilderExtensionsTest.cs (2)

31exception.Message); 85Assert.Equal(expected, ex.Message);

ConsumesAttributeTests.cs (3)

29Assert.Equal(expectedMessage, exception.Message); 48ex.Message); 74ex.Message);

Controllers\DefaultControllerFactoryTest.cs (1)

183exception.Message);

Controllers\ServiceBasedControllerActivatorTest.cs (1)

69Assert.Equal(expected, ex.Message);

Filters\MiddlewareFilterBuilderTest.cs (3)

101Assert.Equal($"Feature '{typeof(IMiddlewareFilterFeature)}' is not present.", exception.Message); 216Assert.Equal("Error!!!", exception.Message); 284Assert.Equal("Error!!!", exception.Message);

Filters\MiddlewareFilterConfigurationProviderTest.cs (3)

27Assert.Equal($"Unable to create an instance of type '{configurationType}'. The type specified in configurationType must not be abstract and must have a parameterless constructor.", exception.Message); 74Assert.Equal(expected, exception.Message); 90Assert.Equal(expected, exception.Message);

Filters\MiddlewareFilterTest.cs (1)

161Assert.Equal(expectedMessage, exception.Message);

Filters\ResponseCacheFilterExecutorTest.cs (2)

61ex.Message); 429Assert.Equal("'VaryByQueryKeys' requires the response cache middleware.", exception.Message);

Formatters\SystemTextJsonOutputFormatterTest.cs (1)

266Assert.Equal("JsonSerializerOptions instance must specify a TypeInfoResolver setting before being marked as read-only.", exception.Message);

Infrastructure\ActionMethodExecutorTest.cs (1)

436Assert.Equal($"Cannot return null from an action method with a return type of '{typeof(CustomConvertibleFromAction)}'.", ex.Message);

Infrastructure\ActionSelectorTest.cs (1)

844Assert.Equal(expectedMessage, ex.Message);

Infrastructure\AsyncEnumerableReaderTest.cs (1)

186Assert.Equal(expected, ex.Message);

Infrastructure\ControllerActionInvokerTest.cs (1)

1542Assert.Equal(expectedMessage, exception.Message);

Infrastructure\JsonResultExecutorTestBase.cs (3)

219Assert.Equal("Property Age has not been implemented", ex.Message); 224Assert.Equal("Property Age has not been implemented", expectedException.Message); 306Assert.StartsWith("Property 'JsonResult.SerializerSettings' must be an instance of type", ex.Message);

Infrastructure\ObjectResultExecutorTest.cs (2)

320Assert.Equal(expected, exception.Message); 358Assert.Equal(expectedMessage, exception.Message);

LocalRedirectResultTest.cs (2)

103exception.Message); 125exception.Message);

ModelBinding\Binders\BodyModelBinderProviderTest.cs (1)

53Assert.Equal(expected, exception.Message);

ModelBinding\Binders\BodyModelBinderTests.cs (5)

244Assert.Equal("Unsupported content type ''.", bindingContext.ModelState[bindingContext.BinderModelName].Errors[0].Exception.Message); 459Assert.Equal("Unable to read input stream!!", exception.Message); 502var errorMessage = Assert.Single(entry.Value.Errors).Exception.Message; 528Assert.Equal("Unable to read input stream!!", exception.Message); 558var errorMessage = Assert.Single(entry.Value.Errors).Exception.Message;

ModelBinding\Binders\ComplexObjectModelBinderTest.cs (2)

1058bindingContext.ModelState["foo"].Errors[0].Exception.Message); 1081bindingContext.ModelState["foo.NameNoAttribute"].Errors[0].Exception.Message);

ModelBinding\Binders\ComplexTypeModelBinderTest.cs (6)

546exception.Message); 565Assert.Equal(expectedMessage, exception.Message); 588exception.Message); 1020Assert.DoesNotContain(exception.Message, unexpectedMessage); 1220bindingContext.ModelState["foo"].Errors[0].Exception.Message); 1243bindingContext.ModelState["foo.NameNoAttribute"].Errors[0].Exception.Message);

ModelBinding\Binders\FormCollectionModelBinderProviderTest.cs (1)

24exception.Message);

ModelBinding\Metadata\DefaultModelMetadataTest.cs (2)

102var key = ModelMetadataIdentity.ForProperty(typeof(Exception).GetProperty(nameof(Exception.Message)), typeof(string), typeof(Exception)); 463var prop1 = typeof(Exception).GetProperty(nameof(Exception.Message));

ModelBinding\Metadata\ModelAttributesTest.cs (1)

301Assert.Equal("Only one ModelMetadataType attribute is permitted per type.", exception.Message);

ModelBinding\ModelBinderFactoryTest.cs (2)

35Assert.Equal(expected, exception.Message); 59exception.Message);

ModelBinding\ModelBindingHelperTest.cs (7)

363ex.Message); 402ex.Message); 421ex.Message); 437ex.Message); 453ex.Message); 1251Assert.Equal(expectedMessage, ex.Message); 1267Assert.Equal(expectedMessage, ex.Message);

ModelBinding\Validation\DefaultComplexObjectValidationStrategyTest.cs (1)

183Assert.Contains("'Age'", exception.Message);

ModelBinding\Validation\DefaultObjectValidatorTests.cs (1)

1280Assert.Equal(expected, ex.Message);

ProducesAttributeTests.cs (2)

103ex.Message); 128ex.Message);

ProducesResponseTypeAttributeTests.cs (1)

46ex.Message);

ResponseCacheAttributeTest.cs (2)

56Assert.Equal("The 'HelloWorld' cache profile is not defined.", ex.Message); 320exception.Message);

Routing\ActionEndpointFactoryTest.cs (1)

218exception.Message);

Routing\AttributeRouteTest.cs (1)

536Assert.Equal(expectedErrorMessage, exception.Message);

Routing\AttributeRoutingTest.cs (4)

45Assert.Equal(expectedMessage, ex.Message); 72Assert.Equal(expectedMessage, ex.Message); 106Assert.Equal(expectedMessage, ex.Message); 144Assert.Equal(expectedMessage, ex.Message);

Routing\KnownRouteValueConstraintTests.cs (1)

201ex.Message);

Routing\UrlHelperExtensionsTest.cs (1)

554ex.Message);

Routing\UrlHelperTestBase.cs (1)

1095Assert.Equal(expectedMessage, ex.Message);

src\Shared\ResultsTests\PhysicalFileResultTestBase.cs (1)

387Assert.Equal(expectedMessage, ex.Message);

Microsoft.AspNetCore.Mvc.Core.TestCommon (1)

CommonResourceInvokerTest.cs (1)

1696Assert.Equal(message, exception.Message);

Microsoft.AspNetCore.Mvc.Formatters.Xml.Test (10)

XmlAssertTest.cs (4)

21Assert.Contains(input1, equalException.Message); 22Assert.Contains(input2, equalException.Message); 114Assert.Contains(exceptionMessageForExpected, equalException.Message); 115Assert.Contains(exceptionMessageForActual, equalException.Message);

XmlDataContractSerializerInputFormatterTest.cs (4)

495Assert.Contains("utf-8", ex.Message); 496Assert.Contains("utf-16LE", ex.Message); 524Assert.Contains("utf-16LE", ex.Message); 525Assert.Contains("utf-8", ex.Message);

XmlSerializerInputFormatterTest.cs (2)

515Assert.Equal(expectedMessage, ex.Message); 545Assert.Equal(expectedMessage, ex.Message);

Microsoft.AspNetCore.Mvc.FunctionalTests (6)

AntiforgeryMiddlewareTest.cs (2)

65Assert.Equal("Cannot apply [ValidateAntiForgeryTokenAttribute] and [RequireAntiforgeryTokenAttribute] at the same time.", exception.Message); 135Assert.Equal("The maximum number of bytes have been read.", exception.Message);

ApplicationModelTest.cs (1)

165Assert.Equal("No route matches the supplied values.", ex.Message);

SimpleWithWebApplicationBuilderExceptionTests.cs (1)

30Assert.Equal("This application failed to start", ex.Message);

TagHelpersTest.cs (1)

81Assert.Equal("Should be visible", exception.InnerException.InnerException.Message);

TestingInfrastructureTests.cs (1)

49ex.Message);

Microsoft.AspNetCore.Mvc.IntegrationTests (22)

ActionParametersIntegrationTest.cs (6)

414exception.Message); 478exception.Message); 502exception.Message); 525exception.Message); 564exception.Message); 597exception.Message);

ArrayModelBinderIntegrationTest.cs (1)

401Assert.Equal(expectedMessage, exception.Message);

CollectionModelBinderIntegrationTest.cs (3)

998Assert.Equal(expectedMessage, exception.Message); 1084Assert.Equal(expectedMessage, exception.Message); 1122Assert.Equal(expectedMessage, exception.Message);

ComplexRecordIntegrationTest.cs (3)

3326Assert.Equal(expectedMessage, exception.Message); 3396Assert.Equal(expectedMessage, exception.Message); 3430Assert.Equal(expectedMessage, exception.Message);

ComplexTypeIntegrationTestBase.cs (3)

3561Assert.Equal(expectedMessage, exception.Message); 3647Assert.Equal(expectedMessage, exception.Message); 3699Assert.Equal(expectedMessage, exception.Message);

DictionaryModelBinderIntegrationTest.cs (1)

1227Assert.Equal(expectedMessage, exception.Message);

ServicesModelBinderIntegrationTest.cs (1)

181Assert.Contains(typeof(IActionResult).FullName, exception.Message);

TryUpdateModelIntegrationTest.cs (1)

1160Assert.Equal($"TryUpdateModelAsync cannot update a record type model. If a '{model.GetType()}' must be updated, include it in an object type.", ex.Message);

ValidationWithRecordIntegrationTests.cs (3)

2329Assert.Equal(expected, ex.Message); 2368Assert.Equal(expected, ex.Message); 2409Assert.Equal(expected, ex.Message);

Microsoft.AspNetCore.Mvc.Localization.Test (1)

HtmlLocalizerTest.cs (1)

153Assert.StartsWith("Input string was not in a correct format.", exception.Message);

Microsoft.AspNetCore.Mvc.NewtonsoftJson (1)

NewtonsoftJsonInputFormatter.cs (1)

431return new InputFormatterException(exception.Message, exception);

Microsoft.AspNetCore.Mvc.NewtonsoftJson.Test (8)

BsonTempDataSerializerTest.cs (2)

38exception.Message); 66exception.Message);

DependencyInjection\MvcNewtonsoftJsonOptionsExtensionsTest.cs (2)

223Assert.Equal(expectedMessage, actual: exception.Message); 237Assert.Equal(expectedMessage, actual: exception.Message);

src\Mvc\Mvc.Core\test\Infrastructure\AsyncEnumerableReaderTest.cs (1)

186Assert.Equal(expected, ex.Message);

src\Mvc\Mvc.Core\test\Infrastructure\JsonResultExecutorTestBase.cs (3)

Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation.Test (1)

RuntimeCompilationFileProviderTest.cs (1)

28Assert.Equal(expected, exception.Message);

Microsoft.AspNetCore.Mvc.Razor.Test (26)

ApplicationParts\RazorCompiledItemFeatureProviderTest.cs (1)

108Assert.Equal(expected, ex.Message);

RazorPageTest.cs (13)

134ex.Message); 184Assert.Equal("There is no active writing scope to end.", ex.Message); 263Assert.Equal("Nesting of TagHelper attribute writing scopes is not supported.", ex.Message); 411Assert.Equal("Section 'qux' is already defined.", ex.Message); 451ex.Message); 473Assert.Equal(message, ex.Message); 582ex.Message); 606ex.Message); 630ex.Message); 649ex.Message); 666Assert.Equal($"RenderBody has not been called for the page at '{path}'. To ignore call IgnoreBody().", ex.Message); 708ex.Message); 897Assert.Equal(expected, ex.Message);

RazorViewTest.cs (11)

552Assert.Equal(expected, ex.Message); 595Assert.Equal(expected, ex.Message); 640Assert.Equal(expected, ex.Message); 749ex.Message); 948ex.Message); 1017ex.Message); 1051ex.Message); 1235Assert.Equal(expectedMessage, exception.Message); 1289Assert.Equal(expectedMessage, exception.Message); 1501Assert.Equal(expected, ex.Message); 1548Assert.Equal(expected, ex.Message);

TagHelpers\UrlResolutionTagHelperTest.cs (1)

382Assert.Equal(expectedExceptionMessage, exception.Message, StringComparer.Ordinal);

Microsoft.AspNetCore.Mvc.RazorPages.Test (11)

ApplicationModels\DefaultPageApplicationModelProviderTest.cs (4)

32ex.Message); 73ex.Message); 96ex.Message); 121ex.Message);

ApplicationModels\TempDataFilterPageApplicationModelProviderTest.cs (2)

41Assert.Equal(expected, ex.Message); 58Assert.Equal(expected, ex.Message);

Infrastructure\DefaultPageFactoryProviderTest.cs (1)

38ex.Message);

Infrastructure\DefaultPageHandlerMethodSelectorTest.cs (2)

666Assert.Equal(message, ex.Message); 726Assert.Equal(message, ex.Message);

Infrastructure\ExecutorFactoryTest.cs (1)

179Assert.Equal($"Unsupported handler method return type '{methodInfo.ReturnType}'.", ex.Message);

Infrastructure\ServiceBasedPageModelActivatorProviderTest.cs (1)

118Assert.Equal(expected, ex.Message);

Microsoft.AspNetCore.Mvc.TagHelpers.Test (20)

AnchorTagHelperTest.cs (4)

527Assert.Equal(expectedErrorMessage, ex.Message); 567Assert.Equal(expectedErrorMessage, ex.Message); 605Assert.Equal(expectedErrorMessage, ex.Message); 643Assert.Equal(expectedErrorMessage, ex.Message);

ComponentTagHelperTest.cs (1)

58Assert.Equal("A value for the 'render-mode' attribute must be supplied to the 'component' tag helper.", ex.Message);

FormActionTagHelperTest.cs (5)

549Assert.Equal(expectedErrorMessage, ex.Message); 589Assert.Equal(expectedErrorMessage, ex.Message); 627Assert.Equal(expectedErrorMessage, ex.Message); 665Assert.Equal(expectedErrorMessage, ex.Message); 703Assert.Equal(expectedErrorMessage, ex.Message);

FormTagHelperTest.cs (4)

1047Assert.Equal(expectedErrorMessage, ex.Message); 1083Assert.Equal(expectedErrorMessage, ex.Message); 1117Assert.Equal(expectedErrorMessage, ex.Message); 1151Assert.Equal(expectedErrorMessage, ex.Message);

InputTagHelperTest.cs (2)

150Assert.Equal(expected, ex.Message); 197Assert.Equal(expected, ex.Message);

PartialTagHelperTest.cs (4)

123Assert.Equal(expectedMessage, exception.Message); 145Assert.Equal(expectedMessage, exception.Message); 602Assert.Equal(expected, exception.Message); 745Assert.Equal(expected, exception.Message);

Microsoft.AspNetCore.Mvc.ViewFeatures (2)

Filters\AntiforgeryMiddlewareAuthorizationFilter.cs (1)

24Log.AntiforgeryTokenInvalid(_logger, antiforgeryValidationFeature.Error!.Message, antiforgeryValidationFeature.Error!);

Filters\ValidateAntiforgeryTokenAuthorizationFilter.cs (1)

41Log.AntiforgeryTokenInvalid(_logger, exception.Message, exception);

Microsoft.AspNetCore.Mvc.ViewFeatures.Test (59)

DefaultEditorTemplatesTest.cs (1)

1315Assert.Equal(expectedMessage, ex.Message);

DefaultHtmlGeneratorTest.cs (1)

532exception.Message);

Filters\AntiforgeryApplicationModelProviderTest.cs (1)

139exception.Message);

Filters\TempDataApplicationModelProviderTest.cs (2)

43Assert.Equal(expected, ex.Message); 60Assert.Equal(expected, ex.Message);

Infrastructure\DefaultTempDataSerializerTest.cs (1)

52Assert.Equal($"The '{testProvider.GetType()}' cannot serialize an object of type '{value.GetType()}'.", ex.Message);

PartialViewResultTest.cs (4)

57Assert.Equal(expected, ex.Message); 94Assert.Equal(expected, ex.Message); 132Assert.Equal(expected, ex.Message); 172Assert.Equal(expected, ex.Message);

RemoteAttributeTest.cs (1)

150Assert.Equal("No URL for remote validation could be found.", exception.Message);

Rendering\HtmlHelperCheckboxTest.cs (1)

83Assert.Contains("Boolean", ex.Message);

Rendering\HtmlHelperDisplayNameExtensionsTest.cs (2)

170exception.Message); 185exception.Message);

Rendering\HtmlHelperLabelExtensionsTest.cs (1)

433exception.Message);

Rendering\HtmlHelperPartialExtensionsTest.cs (6)

422Assert.Equal(expected, exception.Message); 451Assert.Equal(expected, exception.Message); 482Assert.Equal(expected, exception.Message); 511Assert.Equal(expected, exception.Message); 540Assert.Equal(expected, exception.Message); 571Assert.Equal(expected, exception.Message);

ViewComponentResultTest.cs (4)

66Assert.Equal(expected, ex.Message); 116Assert.Equal(expected, exception.Message); 139Assert.Equal(expected, exception.Message); 164Assert.Equal(expected, exception.Message);

ViewComponents\DefaultViewComponentDescriptorProviderTest.cs (5)

23Assert.Equal(expected, ex.Message); 39Assert.Equal(expected, ex.Message); 54Assert.Equal(expected, ex.Message); 68Assert.Equal(expected, ex.Message); 81Assert.Equal(expected, ex.Message);

ViewComponents\DefaultViewComponentSelectorTest.cs (2)

107Assert.Equal(expected, ex.Message); 128Assert.Equal(expected, ex.Message);

ViewComponents\ViewViewComponentResultTest.cs (5)

176Assert.Equal(expected, ex.Message); 214Assert.Equal(expected, ex.Message); 254Assert.Equal(expected, ex.Message); 415Assert.Equal(expected, ex.Message); 444Assert.Equal(expected, ex.Message);

ViewDataDictionaryOfTModelTest.cs (10)

ViewDataDictionaryTest.cs (2)

145exception.Message); 406exception.Message);

ViewDataOfTTest.cs (2)

19Assert.Equal("The model item passed is null, but this ViewDataDictionary instance requires a non-null model item of type 'System.Int32'.", ex.Message); 31Assert.Equal("The model item passed into the ViewDataDictionary is of type 'System.DateTime', but this ViewDataDictionary instance requires a model item of type 'System.String'.", ex.Message);

ViewEngines\CompositeViewEngineTest.cs (3)

46Assert.Equal(expected, exception.Message); 174Assert.Equal(expected, exception.Message); 313Assert.Equal(expected, exception.Message);

ViewExecutorTest.cs (1)

115Assert.Equal("This should be raw!", exception.Message);

ViewResultTest.cs (4)

67Assert.Equal(expected, ex.Message); 104Assert.Equal(expected, ex.Message); 144Assert.Equal(expected, ex.Message); 184Assert.Equal(expected, ex.Message);

Microsoft.AspNetCore.OpenApi.Tests (3)

Integration\OpenApiDocumentIntegrationTests.cs (1)

143context.CreateError(ruleName, ex.Message);

Services\OpenApiGeneratorTests.cs (1)

77Assert.Equal("Encountered a parameter of type 'System.Runtime.CompilerServices.Closure' without a name. Parameters must have a name.", ex.Message);

Transformers\Implementations\OpenApiSchemaReferenceTransformerTests.cs (1)

424Assert.Equal("The depth of the generated JSON schema exceeds the JsonSerializerOptions.MaxDepth setting.", exception.Message);

Microsoft.AspNetCore.OutputCaching.Tests (1)

OutputCacheTests.cs (1)

1028throw new InvalidOperationException($"Client {id} failed; payload '{s}', failure: {ex.Message}", ex);

Microsoft.AspNetCore.RateLimiting.Tests (1)

RateLimitingApplicationBuilderExtensionsTests.cs (1)

35Assert.Equal("Unable to find the required services. Please add all the required services by calling 'IServiceCollection.AddRateLimiter' in the application startup code.", ex.Message);

Microsoft.AspNetCore.Razor.Runtime.Test (1)

Runtime\TagHelpers\TagHelperScopeManagerTest.cs (1)

220Assert.Equal(expectedError, ex.Message);

Microsoft.AspNetCore.RequestDecompression.Tests (1)

SizeLimitedStreamTests.cs (1)

100Assert.Equal("The maximum number of bytes have been read.", exception.Message);

Microsoft.AspNetCore.Rewrite.Tests (13)

ApacheModRewrite\ConditionPatternParserTest.cs (1)

98Assert.Equal(expected, ex.Message);

ApacheModRewrite\CookieActionFactoryTest.cs (2)

77Assert.Equal(Resources.FormatError_InvalidChangeCookieFlag(flagValue), ex.Message); 88Assert.Equal(Resources.FormatError_CouldNotParseInteger(badInt), ex.Message);

ApacheModRewrite\FlagParserTest.cs (1)

55Assert.Equal(expected, ex.Message);

ApacheModRewrite\FormatExceptionTests.cs (1)

32Assert.Equal(expected, ex.Message);

ApacheModRewrite\RewriteTokenizerTest.cs (2)

82Assert.Equal(@"Invalid escaper character in string: \", ex.Message); 89Assert.Equal("Mismatched number of quotes: \"", ex.Message);

ApacheModRewrite\RuleBuilderTest.cs (1)

21Assert.Equal(Resources.Error_ChangeEnvironmentNotSupported, ex.Message);

ApacheModRewrite\TestStringParserTests.cs (1)

121Assert.Equal(expected, ex.Message);

IISUrlRewrite\FormatExceptionHandlingTests.cs (1)

64Assert.Equal(expected, ex.Message);

IISUrlRewrite\InvalidUrlRewriteFormatExceptionHandlingTests.cs (1)

216Assert.Equal(expected, ex.Message);

PatternSegments\DateTimeSegmentTests.cs (1)

38Assert.Equal(expected, ex.Message);

UrlMatches\IntegerMatchTests.cs (1)

15Assert.Equal(ex.Message, Resources.Error_IntegerMatch_FormatExceptionMessage);

Microsoft.AspNetCore.Routing (1)

Template\TemplateParser.cs (1)

30throw new ArgumentException(ex.Message, nameof(routeTemplate), ex);

Microsoft.AspNetCore.Routing.FunctionalTests (8)

EndpointRoutingIntegrationTest.cs (4)

153Assert.Equal(AuthErrorMessage, ex.Message); 214Assert.Equal(AuthErrorMessage, ex.Message); 245Assert.Equal(AuthErrorMessage, ex.Message); 344Assert.Equal(CORSErrorMessage, ex.Message);

MinimalFormTests.cs (4)

214exception.Message); 246exception.Message); 429Assert.Equal("This form is being accessed with an invalid anti-forgery token. Validate the `IAntiforgeryValidationFeature` on the request before reading from the form.", exception.Message); 488Assert.Equal("The maximum number of bytes have been read.", exception.Message);

Microsoft.AspNetCore.Routing.Tests (59)

Builder\EndpointRoutingApplicationBuilderExtensionsTest.cs (4)

35ex.Message); 52ex.Message); 126ex.Message); 147ex.Message);

Builder\GroupTest.cs (2)

130Assert.Equal("The route parameter name 'id' appears more than one time in the route template.", ex.Message); 313ex.Message);

Builder\RouteHandlerEndpointRouteBuilderExtensionsTest.cs (8)

217Assert.Contains("Body was inferred but the method does not allow inferred body parameters.", ex.Message); 218Assert.Contains("Did you mean to register the \"Body (Inferred)\" parameter(s) as a Service or apply the [FromServices] or [FromBody] attribute?", ex.Message); 228Assert.Contains("Body was inferred but the method does not allow inferred body parameters.", ex.Message); 229Assert.Contains("Did you mean to register the \"Body (Inferred)\" parameter(s) as a Service or apply the [FromServices] or [FromBody] attribute?", ex.Message); 256Assert.Contains("Body was inferred but the method does not allow inferred body parameters.", ex.Message); 257Assert.Contains("Did you mean to register the \"Body (Inferred)\" parameter(s) as a Service or apply the [FromServices] or [FromBody] attribute?", ex.Message); 597Assert.Equal("'id' is not a route parameter.", ex.Message); 655Assert.Equal("'value' is not a route parameter.", ex.Message);

Builder\RoutingBuilderExtensionsTest.cs (3)

32exception.Message); 49ex.Message); 66ex.Message);

DefaultInlineConstraintResolverTest.cs (5)

53ex.Message); 292Assert.Equal("System.String must implement Microsoft.AspNetCore.Routing.IParameterPolicy", ex.Message); 322ex.Message); 337ex.Message); 363ex.Message);

DefaultParameterPolicyFactoryTest.cs (4)

28exception.Message); 49exception.Message); 336+ "Multiple constructors were found with the following number of parameters: 2.", exception.Message); 377Assert.Equal($"No service for type '{typeof(ITestService).FullName}' has been registered.", inner.Message);

EndpointMiddlewareTest.cs (4)

121Assert.Equal(expected, ex.Message); 150Assert.Equal(expected, ex.Message); 247Assert.Equal(expected, ex.Message); 345Assert.Equal(expected, ex.Message);

EndpointNameAddressSchemeTest.cs (1)

183""), ex.Message);

Matching\CandidateSetTest.cs (1)

329.TrimStart(), ex.Message);

Matching\DataSourceDependentMatcherTest.cs (3)

165Assert.Equal(expectedError, exception.Message); 203Assert.Equal(expectedError, exception.Message); 233Assert.Equal(expectedError, exception.InnerException.Message);

Matching\DefaultEndpointSelectorTest.cs (1)

166"test: /test2" + Environment.NewLine + "test: /test3", ex.Message);

Patterns\RoutePatternFactoryTest.cs (9)

87ex.Message); 133ex.Message); 399ex.Message); 618exception.Message); 760Assert.Equal("The route parameter name 'ID' appears more than one time in the route template.", ex.Message); 806Assert.Equal("MapGroup cannot build a pattern for '/a/b' because the 'RoutePattern.ParameterPolicies' dictionary key 'X' has multiple values.", ex.Message); 818Assert.Equal("MapGroup cannot build a pattern for '/a/{x=foo}/b' because the 'RoutePattern.Defaults' dictionary key 'X' has multiple values.", ex.Message); 831Assert.Equal("MapGroup cannot build a pattern for '/a/b' because the 'RoutePattern.RequiredValues' dictionary key 'X' has multiple values.", ex.Message); 843Assert.Equal("MapGroup cannot build a pattern for '/a/{x:string}/b' because the 'RoutePattern.ParameterPolicies' dictionary key 'X' has multiple values.", ex.Message);

RouteBuilderTest.cs (1)

49exception.Message);

RouteCollectionTest.cs (2)

306ex.Message); 326Assert.Equal("The supplied route name 'Ambiguous' is ambiguous and matched more than one route.", ex.Message);

RouteTest.cs (3)

42Assert.Equal(expected, exception.Message); 48Assert.Equal(expected, exception.InnerException.Message); 1623Assert.Equal(expectedMessage, exception.InnerException.Message);

Template\RoutePrecedenceTestsBase.cs (2)

108Assert.Equal("Route exceeds the maximum number of allowed segments of 28 and is unable to be processed.", ex.Message); 121Assert.Equal("Route exceeds the maximum number of allowed segments of 28 and is unable to be processed.", ex.Message);

TemplateParserDefaultValuesTests.cs (6)

68Assert.Equal(message, ex.Message); 74Assert.Equal(message, ex.InnerException.Message); 93Assert.Equal(message, ex.Message); 97Assert.Equal(message, ex.InnerException.Message); 119Assert.Equal(message, ex.Message); 123Assert.Equal(message, ex.InnerException.Message);

Microsoft.AspNetCore.Server.HttpSys (2)

ValidationHelper.cs (2)

18return exception.Message; 20return exception.Message + " (" + ExceptionMessage(exception.InnerException) + ")";

Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (18)

Listener\ServerTests.cs (1)

141Assert.Contains($"The prefix '{address1}' is already registered.", exception.Message);

OpaqueUpgradeTests.cs (3)

273Assert.Equal("The response status code was incorrect: HTTP/1.1 200 OK", ex.Message); 355Assert.Equal("Upgrade requires HTTP/1.1.", ex.Message); 359Assert.EndsWith("HTTP/1.1 500 Internal Server Error", ex.Message);

RequestBodyLimitTests.cs (14)

Microsoft.AspNetCore.Server.IIS (4)

Core\IISHttpContext.Log.cs (1)

23=> ConnectionBadRequest(logger, connectionId, ex.Message, ex);

src\Shared\ErrorPage\ErrorPage.Designer.cs (3)

307Output.Write(HtmlEncodeAndReplaceLineBreaks(errorDetail.Error!.Message)); 417Write(ex.Message); 475Write(errorDetail.Error!.Message);

Microsoft.AspNetCore.Server.IntegrationTesting (5)

Common\RetryHelper.cs (1)

58logger.LogWarning("Failed to complete the request : {0}.", exception.Message);

Deployers\ApplicationDeployer.cs (1)

158Logger.LogWarning("User cleanup code failed with exception : {exception}", exception.Message);

PublishedApplication.cs (1)

24e => _logger.LogWarning($"Failed to delete directory : {e.Message}"),

src\Shared\Process\ProcessExtensions.cs (2)

73catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory")) 89catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory"))

Microsoft.AspNetCore.Server.IntegrationTesting.IIS (1)

IISExpressDeployer.cs (1)

426Logger.LogWarning("Failed to delete '{config}'. Exception : {exception}", DeploymentParameters.ServerConfigLocation, exception.Message);

Microsoft.AspNetCore.Server.Kestrel.Core (39)

Internal\Http2\Http2Connection.cs (3)

348AbortStream(_incomingFrame.StreamId, new IOException(ex.Message, ex)); 1649throw new Http2ConnectionErrorException(bre.Message, Http2ErrorCode.PROTOCOL_ERROR, ConnectionEndReason.MaxRequestHeaderCountExceeded); 1654throw new Http2ConnectionErrorException(bre.Message, Http2ErrorCode.PROTOCOL_ERROR, ConnectionEndReason.InvalidRequestHeaders);

Internal\Http2\Http2FrameWriter.cs (2)

559_http2Connection.Abort(new ConnectionAbortedException(ex.Message, ex), Http2ErrorCode.INTERNAL_ERROR, ConnectionEndReason.ErrorWritingHeaders); 600_http2Connection.Abort(new ConnectionAbortedException(ex.Message, ex), Http2ErrorCode.INTERNAL_ERROR, ConnectionEndReason.ErrorWritingHeaders);

Internal\Http3\Http3Connection.cs (5)

178session.Value.Abort(new ConnectionAbortedException(ex.Message, ex.InnerException), errorCode); 182session.Value.Abort(new ConnectionAbortedException(ex.Message), errorCode); 456Log.Http3StreamAbort(CoreStrings.FormatUnidentifiedStream(ex.StreamId), Http3ErrorCode.StreamCreationError, new(ex.Message)); 746Abort(new ConnectionAbortedException(connectionError.Message, connectionError), connectionError.ErrorCode, ConnectionEndReason.ClosedCriticalStream); 875Abort(new ConnectionAbortedException(ex.Message, ex), ex.ErrorCode, ex.Reason);

Internal\Http3\Http3ControlStream.cs (1)

240Abort(new ConnectionAbortedException(ex.Message), ex.ErrorCode);

Internal\Http3\Http3FrameWriter.cs (5)

321_connectionContext.Abort(new ConnectionAbortedException(ex.Message, ex)); 322_http3Stream.Abort(new ConnectionAbortedException(ex.Message, ex), Http3ErrorCode.InternalError); 376_connectionContext.Abort(new ConnectionAbortedException(ex.Message, ex)); 377_http3Stream.Abort(new ConnectionAbortedException(ex.Message, ex), Http3ErrorCode.InternalError); 378throw new InvalidOperationException(ex.Message, ex); // Report the error to the user if this was the first write.

Internal\Http3\Http3Stream.cs (4)

180abortReason = new ConnectionAbortedException(exception.Message, exception); 365throw new Http3StreamErrorException(bre.Message, Http3ErrorCode.MessageError); 671Abort(new ConnectionAbortedException(ex.Message, ex), ex.ErrorCode); 836throw new Http3StreamErrorException(ex.Message, Http3ErrorCode.InternalError);

Internal\Infrastructure\KestrelTrace.BadRequests.cs (1)

13BadRequestsLog.ConnectionBadRequest(_badRequestsLogger, connectionId, ex.Message, ex);

Internal\WebTransport\WebTransportSession.cs (2)

109stream.Value.Abort(new ConnectionAbortedException(exception.Message, exception.InnerException)); 113stream.Value.Abort(new ConnectionAbortedException(exception.Message));

LocalhostListenOptions.cs (2)

51context.Logger.LogInformation(0, CoreStrings.NetworkInterfaceBindingFailed, GetDisplayName(), "IPv4 loopback", ex.Message); 65context.Logger.LogInformation(0, CoreStrings.NetworkInterfaceBindingFailed, GetDisplayName(), "IPv6 loopback", ex.Message);

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (3)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (11)

Microsoft.AspNetCore.Server.Kestrel.Core.Tests (93)

BodyControlTests.cs (2)

45Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, writeEx.Message); 71Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, writeEx.Message);

ConnectionContextTests.cs (1)

24Assert.Equal("The connection was aborted by the application via ConnectionContext.Abort().", ex.Message);

ConnectionDispatcherTests.cs (1)

69Assert.Equal("Unexpected error listening", critical.Exception.Message);

DiagnosticMemoryPoolTests.cs (11)

23Assert.Equal("Object is being disposed twice", exception.Message); 34Assert.Equal("Block is being returned to disposed pool", exception.Message); 44Assert.Equal("Block is being disposed twice", exception.Message); 58Assert.Equal("Block is backed by disposed slab", exception.Message); 71Assert.Equal("Block is backed by disposed slab", exception.Message); 91Assert.Equal("Block is backed by disposed slab", ode.Message); 106Assert.Equal("Block is backed by disposed slab", exception.Message); 195Assert.Equal("Block is backed by disposed slab", exception.Message); 212Assert.Contains("Block is backed by disposed slab", exception.Message); 213Assert.Contains("ExceptionsContainStackTraceWhenEnabled", exception.Message); 219Assert.Contains("Memory pool with active blocks is being disposed, 0 of 1 returned", exception.Message);

Http1\Http1ConnectionTests.cs (13)

HttpConnectionTests.cs (1)

45.Verify(c => c.Abort(It.Is<ConnectionAbortedException>(ex => ex.Message == CoreStrings.ConnectionTimedBecauseResponseMininumDataRateNotSatisfied)),

HttpParserTests.cs (16)

HttpRequestStreamTests.cs (2)

121Assert.Equal("Synchronous operations are disallowed. Call ReadAsync or set AllowSynchronousIO to true instead.", ioEx.Message); 124Assert.Equal("Synchronous operations are disallowed. Call ReadAsync or set AllowSynchronousIO to true instead.", ioEx2.Message);

HttpResponseHeadersTests.cs (3)

320Assert.Equal(CoreStrings.FormatInvalidContentLength_InvalidNumber(contentLength), exception.Message); 331Assert.Equal(CoreStrings.FormatInvalidContentLength_InvalidNumber(contentLength), exception.Message); 341Assert.Equal(CoreStrings.FormatInvalidContentLength_InvalidNumber(contentLength), exception.Message);

HttpResponseStreamTests.cs (1)

124Assert.Equal("Synchronous operations are disallowed. Call WriteAsync or set AllowSynchronousIO to true instead.", ioEx.Message);

KestrelServerTests.cs (8)

57Assert.Contains("Invalid url", exception.Message); 88Assert.Equal(CoreStrings.NoCertSpecifiedNoDevelopmentCertificateFound, ex.Message); 130exception.Message); 236exception.Message); 263exception.Message); 326Assert.Equal(CoreStrings.TransportNotFound, exception.Message); 354Assert.Equal("No registered IConnectionListenerFactory supports endpoint IPEndPoint: 127.0.0.1:0", exception.Message); 395Assert.Equal("No registered IMultiplexedConnectionListenerFactory supports endpoint IPEndPoint: 127.0.0.1:0", exception.Message);

MessageBodyTests.cs (4)

381Assert.Equal(CoreStrings.BadRequest_BadChunkSizeData, ex.Message); 405Assert.Equal(CoreStrings.BadRequest_BadChunkSizeData, ex.Message); 553Assert.Equal(CoreStrings.FormatBadRequest_FinalTransferCodingNotChunked("chunked, not-chunked"), ex.Message); 587Assert.Equal(CoreStrings.FormatBadRequest_LengthRequiredHttp10(((IHttpRequestFeature)input.Http1Connection).Method), ex.Message);

SniOptionsSelectorTests.cs (3)

346Assert.Equal(CoreStrings.FormatSniNotConfiguredForServerName("example.org", "TestEndpointName"), authExWithServerName.Message); 349Assert.Equal(CoreStrings.FormatSniNotConfiguredToAllowNoServerName("TestEndpointName"), authExWithoutServerName.Message); 522Assert.Equal(CoreStrings.NoCertSpecifiedNoDevelopmentCertificateFound, ex.Message);

src\Shared\test\Shared.Tests\runtime\Http2\HPackDecoderTest.cs (17)

src\Shared\test\Shared.Tests\runtime\Http2\HuffmanDecodingTests.cs (3)

272Assert.Equal(SR.net_http_hpack_huffman_decode_failed, exception.Message); 289Assert.Equal(SR.net_http_hpack_huffman_decode_failed, exception.Message); 334Assert.Equal(SR.net_http_hpack_huffman_decode_failed, exception.Message);

src\Shared\test\Shared.Tests\runtime\Http3\QPackDecoderTest.cs (3)

295Assert.Equal(SR.Format(SR.net_http_headers_exceeded_length, 10), exception.Message); 315Assert.Equal(SR.Format(SR.net_http_headers_exceeded_length, 10), exception.Message); 339Assert.Equal(SR.net_http_hpack_incomplete_header_block, exception.Message);

ThrowingWasUpgradedWriteOnlyStreamTests.cs (4)

22Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, Assert.Throws<InvalidOperationException>(() => stream.Write(new byte[1], 0, 1)).Message); 23Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, (await Assert.ThrowsAsync<InvalidOperationException>(() => stream.WriteAsync(new byte[1], 0, 1))).Message); 24Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, Assert.Throws<InvalidOperationException>(() => stream.Flush()).Message); 25Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, (await Assert.ThrowsAsync<InvalidOperationException>(() => stream.FlushAsync())).Message);

Microsoft.AspNetCore.Server.Kestrel.Tests (8)

ConfigurationReaderTests.cs (1)

310Assert.Equal(CoreStrings.FormatSniNameCannotBeEmpty("End1"), end1Ex.Message);

HttpsConfigurationTests.cs (1)

81Assert.Contains("Call UseKestrelHttpsConfiguration()", ex.Message);

KestrelConfigurationLoaderTests.cs (6)

682Assert.StartsWith("Error getting private key from", ex.Message); 1051Assert.Equal(CoreStrings.FormatEndpointHasUnusedHttpsConfig("End1", "Certificate"), ex.Message); 1060Assert.Equal(CoreStrings.FormatEndpointHasUnusedHttpsConfig("End1", "Certificate"), ex.Message); 1069Assert.Equal(CoreStrings.FormatEndpointHasUnusedHttpsConfig("End1", "ClientCertificateMode"), ex.Message); 1078Assert.Equal(CoreStrings.FormatEndpointHasUnusedHttpsConfig("End1", "SslProtocols"), ex.Message); 1087Assert.Equal(CoreStrings.FormatEndpointHasUnusedHttpsConfig("End1", "Sni"), ex.Message);

Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes (1)

Internal\NamedPipeConnection.cs (1)

227NamedPipeLog.ConnectionDisconnect(_log, this, _shutdownReason.Message);

Microsoft.AspNetCore.Server.Kestrel.Transport.Quic (13)

Internal\QuicConnectionContext.cs (2)

87QuicLog.ConnectionAbort(_log, this, resolvedErrorCode, abortReason.Message); 145throw new ConnectionResetException(ex.Message, ex);

Internal\QuicConnectionListener.cs (1)

132throw new AddressInUseException(e.Message, e);

Internal\QuicStreamContext.cs (8)

280error = new ConnectionResetException(ex.Message, ex); 290error = new ConnectionResetException(ex.Message, ex); 295error = new ConnectionAbortedException(ex.Message, ex); 441shutdownReason = new ConnectionResetException(ex.Message, ex); 451shutdownReason = new ConnectionResetException(ex.Message, ex); 458shutdownReason = new ConnectionResetException(ex.Message, ex); 505QuicLog.StreamAbort(_log, this, resolvedErrorCode, abortReason.Message); 529QuicLog.StreamShutdownWrite(_log, this, _shutdownReason.Message);

Internal\QuicStreamContext.FeatureCollection.cs (2)

70QuicLog.StreamAbortRead(_log, this, errorCode, abortReason.Message); 92QuicLog.StreamAbortWrite(_log, this, errorCode, abortReason.Message);

Microsoft.AspNetCore.Server.Kestrel.Transport.Quic.Tests (8)

QuicConnectionContextTests.cs (2)

427Assert.Equal("Stream aborted by peer (258).", ex.Message); 476Assert.Equal("Stream aborted by peer (258).", serverEx.Message);

QuicConnectionListenerTests.cs (2)

91Assert.Contains("RemoteCertificateChainErrors", ex.Message); 258Assert.Equal("Authentication failed because the remote party sent a TLS alert: 'UserCanceled'.", ex.Message);

QuicStreamContextTests.cs (1)

528Assert.Equal("Test reason", serverEx.Message);

QuicTransportFactoryTests.cs (2)

35Assert.Equal("Couldn't find HTTPS configuration for QUIC transport.", ex.Message); 52Assert.Equal("No application protocols specified for QUIC transport.", ex.Message);

WebHostTests.cs (1)

412Assert.Equal("No registered IMultiplexedConnectionListenerFactory supports endpoint UnixDomainSocketEndPoint: /test-path", ex.Message);

Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets (2)

Internal\SocketConnection.cs (2)

387SocketsLog.ConnectionWriteRst(_logger, this, shutdownReason.Message); 394SocketsLog.ConnectionWriteFin(_logger, this, _shutdownReason.Message);

Microsoft.AspNetCore.Shared.Tests (53)

CommandLineApplicationTests.cs (14)

ObjectMethodExecutorTest.cs (2)

374Assert.Equal("Test exception", exception.InnerException.Message); 407Assert.Equal("Test exception", exception.InnerException.Message);

runtime\Http2\HPackDecoderTest.cs (17)

runtime\Http2\HuffmanDecodingTests.cs (3)

runtime\Http3\QPackDecoderTest.cs (3)

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (3)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (11)

Microsoft.AspNetCore.SignalR.Client.Core (1)

HubConnection.cs (1)

1435await SendWithLock(connectionState, CompletionMessage.WithError(invocation.InvocationId!, resultException.Message), cancellationToken: default).ConfigureAwait(false);

Microsoft.AspNetCore.SignalR.Client.FunctionalTests (25)

HubConnectionTests.cs (24)

HubConnectionTests.Tracing.cs (1)

513Assert.Equal("An unexpected error occurred invoking 'StreamException' on the server. InvalidOperationException: Error occurred while streaming.", ex.Message);

Microsoft.AspNetCore.SignalR.Client.Tests (33)

HttpConnectionFactoryTests.cs (2)

55Assert.Equal("The provided EndPoint must be of type UriEndPoint.", ex.Message); 73Assert.Equal("If HttpConnectionOptions.Url was set, it must match the UriEndPoint.Uri passed to ConnectAsync.", ex.Message);

HttpConnectionTests.cs (1)

68Assert.Equal("The ConnectionId is set internally and should not be set by user code.", exception.Message);

HttpConnectionTests.Negotiate.cs (3)

327Assert.Equal("Negotiate redirection limit exceeded.", exception.Message); 600Assert.Equal("Test error.", exception.Message); 618Assert.Equal(expectedExceptionMessage, exception.Message);

HttpConnectionTests.Transport.cs (1)

263Assert.Equal($"Cannot access the {nameof(Transport)} pipe before the connection has started.", exception.Message);

HubConnectionBuilderTests.cs (3)

23Assert.Equal("Cannot create HubConnection instance. An IConnectionFactory was not configured.", ex.Message); 33Assert.Equal("Cannot create HubConnection instance. An EndPoint was not configured.", ex.Message); 70Assert.Equal("HubConnectionBuilder allows creation only of a single instance of HubConnection.", ex.Message);

HubConnectionTests.ConnectionLifecycle.cs (6)

200Assert.Equal($"The '{name}' method cannot be called if the connection is not active", ex.Message); 378Assert.Equal($"The '{nameof(HubConnection.SendCoreAsync)}' method cannot be called if the connection is not active", ex.Message); 413Assert.Equal($"The '{nameof(HubConnection.SendCoreAsync)}' method cannot be called if the connection is not active", ex.Message); 451Assert.Equal($"The '{nameof(HubConnection.SendCoreAsync)}' method cannot be called if the connection is not active", ex.Message); 481Assert.Equal($"The '{methodName}' method cannot be called if the connection is not active", ex.Message); 630Assert.Equal("Connection terminated while reading a message.", exception.Message);

HubConnectionTests.cs (2)

370Assert.Equal($"Server timeout ({hubConnection.ServerTimeout.TotalMilliseconds:0.00}ms) elapsed without receiving a message from the server.", exception.Message); 424Assert.Equal($"Server timeout ({hubConnection.ServerTimeout.TotalMilliseconds:0.00}ms) elapsed without receiving a message from the server.", exception.Message);

HubConnectionTests.Protocol.cs (7)

85Assert.Equal("Expected a handshake response from the server.", ex.Message); 192Assert.Equal("The server closed the connection with the following error: Error!", closeException.Message); 307Assert.Equal("An error occurred", ex.Message); 330Assert.Equal("Server provided a result in a completion response to a streamed invocation.", ex.Message); 353Assert.Equal("An error occurred", ex.Message); 376Assert.Equal("Streaming hub methods must be invoked with the 'HubConnection.StreamAsChannelAsync' method.", ex.Message); 746Assert.Equal("'Result' already has a value returning handler. Multiple return values are not supported.", ex.Message);

HubConnectionTests.Reconnect.cs (4)

358Assert.Contains($"after {reconnectingCount} failed attempts", closeError.Message); 538Assert.Equal(expectedMessage, reconnectingException.Message); 540Assert.Equal(expectedMessage, retryContexts[0].RetryReason.Message); 611Assert.Equal("The server closed the connection with the following error: Error!", closeError.Message);

LongPollingTransportTests.cs (3)

172Assert.Contains(" 500 ", exception.Message); 216Assert.Contains(" 500 ", exception.Message); 310Assert.Contains(" 500 ", exception.Message);

ServerSentEventsTransportTests.cs (1)

215Assert.Contains("500", exception.Message);

Microsoft.AspNetCore.SignalR.Common (4)

Protocol\HubMethodInvocationMessage.cs (4)

108args = $"Error: {ex.Message}"; 117streamIds = $"Error: {ex.Message}"; 163args = $"Error: {ex.Message}"; 172streamIds = $"Error: {ex.Message}";

Microsoft.AspNetCore.SignalR.Common.Tests (10)

Internal\Formatters\BinaryMessageParserTests.cs (1)

73Assert.Equal("Messages over 2GB in size are not supported.", ex.Message);

Internal\Protocol\HandshakeProtocolTests.cs (2)

94Assert.Equal(expectedMessage, exception.Message); 110Assert.Equal(expectedMessage, exception.Message);

Internal\Protocol\JsonHubProtocolTests.cs (1)

55Assert.Equal(expectedMessage, ex.Message);

Internal\Protocol\JsonHubProtocolTestsBase.cs (3)

197Assert.Equal(expectedMessage, ex.Message); 258Assert.Equal(expectedMessage, bindingFailure.BindingFailure.SourceException.Message); 270Assert.Equal("Error reading JSON.", ex.Message);

Internal\Protocol\MessagePackHubProtocolTestBase.cs (2)

366Assert.Equal(testData.ErrorMessage, exception.Message); 399Assert.Equal(testData.ErrorMessage, bindingFailure.BindingFailure.SourceException.Message);

Internal\Protocol\NewtonsoftJsonHubProtocolTests.cs (1)

53Assert.Equal(expectedMessage, ex.Message);

Microsoft.AspNetCore.SignalR.Core (1)

Internal\ErrorMessageHelper.cs (1)

12return $"{message} {exception.GetType().Name}: {exception.Message}";

Microsoft.AspNetCore.SignalR.Protocols.Json (2)

Protocol\JsonHubProtocol.cs (2)

250error = $"Error trying to deserialize result to {returnType.Name}. {ex.Message}"; 447error = $"Error trying to deserialize result to {returnType.Name}. {ex.Message}";

Microsoft.AspNetCore.SignalR.Protocols.MessagePack (1)

Protocol\MessagePackHubProtocolWorker.cs (1)

197error = $"Error trying to deserialize result to {itemType.Name}. {ex.Message}";

Microsoft.AspNetCore.SignalR.Protocols.NewtonsoftJson (2)

Protocol\NewtonsoftJsonHubProtocol.cs (2)

240error = $"Error trying to deserialize result to {returnType.Name}. {ex.Message}"; 443error = $"Error trying to deserialize result to {returnType.Name}. {ex.Message}";

Microsoft.AspNetCore.SignalR.Specification.Tests (7)

HubLifetimeManagerTestBase.cs (3)

224Assert.Equal("Error from client", ex.Message); 254Assert.Equal($"Connection ID '{connection2.ConnectionId}' is not valid for invocation ID '{invocation.InvocationId}'.", ex.Message); 338Assert.Equal($"Connection '{connection1.ConnectionId}' disconnected.", ex.Message);

ScaleoutHubLifetimeManagerTests.cs (4)

525Assert.Equal("Error from client", ex.Message); 576Assert.Equal("Connection disconnected.", ex.Message); 627Assert.Equal("Connection '1234' does not exist.", ex.Message); 657Assert.StartsWith("Error trying to deserialize result to Int32.", ex.Message);

Microsoft.AspNetCore.SignalR.StackExchangeRedis.Tests (2)

RedisHubLifetimeManagerTests.cs (2)

117Assert.Equal("throw from connect", ex.Message); 125Assert.Equal("throw from connect", logs[0].Exception.Message);

Microsoft.AspNetCore.SignalR.Tests (39)

ClientProxyTests.cs (1)

217Assert.Equal("EmptyHubLifetimeManager`1 does not support client return values.", ex.Message);

DefaultTransportFactoryTests.cs (2)

71Assert.Equal("No requested transports available on the server.", ex.Message); 108Assert.Equal("No requested transports available on the server.", ex.Message);

EndToEndTests.cs (5)

241Assert.Equal("Negotiation can only be skipped when using the WebSocket transport directly.", exception.Message); 391Assert.Contains("401", exception.Message); 451Assert.Equal("Response status code does not indicate success: 401 (Unauthorized).", ex.Message); 585logger.LogError(ex, "Test threw {exceptionType}: {message}", ex.GetType(), ex.Message); 625Assert.Equal("Response status code does not indicate success: 401 (Unauthorized).", ex.Message);

HubConnectionHandlerTests.ClientResult.cs (3)

123Assert.Equal($"Connection '{client.Connection.ConnectionId}' disconnected.", ex.Message); 385Assert.Equal("Invocation canceled by the server.", ex.Message); 430Assert.Equal("Invocation canceled by the server.", ex.Message);

HubConnectionHandlerTests.cs (13)

245Assert.Equal($"Cannot generate proxy implementation for '{typeof(IVoidReturningTypedHubClient).FullName}.{nameof(IVoidReturningTypedHubClient.Send)}'. All client proxy methods must return '{typeof(Task).FullName}' or 'System.Threading.Tasks.Task<T>'.", ex.Message); 502Assert.Equal(exceptionLog.First().Exception.Message, $"The maximum message size of {maximumMessageSize}B was exceeded. The message size can be configured in AddHubOptions."); 532Assert.Equal(exceptionLog.First().Exception.Message, $"The maximum message size of {maximumMessageSize}B was exceeded. The message size can be configured in AddHubOptions."); 583Assert.Equal(exceptionLog.First().Exception.Message, $"The maximum message size of {maximumMessageSize}B was exceeded. The message size can be configured in AddHubOptions."); 715Assert.Equal("Lifetime manager OnConnectedAsync failed.", exception.Message); 785Assert.Equal("Hub OnDisconnected failed.", exception.Message); 1266Assert.Equal("Duplicate definitions of 'OverloadedMethod'. Overloading is not supported.", ex.Message); 1363Assert.Equal("Method 'GenericMethod' is a generic method which is not supported on a Hub.", exception.Message); 2890Assert.Equal("Client hasn't sent a message/ping within the configured ClientTimeoutInterval.", ex.Message); 4586Assert.Equal("The underlying connection was closed.", exception.Message); 5065Assert.Equal("'Microsoft.AspNetCore.SignalR.Tests.Service1' is not in DI as a keyed service.", ex.Message); 5081Assert.Equal("BadServicesHub.BadMethod: The FromKeyedServicesAttribute is not supported on parameters that are also annotated with IFromServiceMetadata.", ex.Message); 5176Assert.Equal(errorMessage, ex.Message);

HubConnectionHandlerTestUtils\Hubs.cs (1)

279return ex.Message == HubConnectionHandlerTests.CustomErrorMessage;

Internal\TypedClientBuilderTests.cs (10)

136Assert.Equal("Type must be an interface.", ex.Message); 144Assert.Equal("Type must be an interface.", ex.Message); 152Assert.Equal("Type must be an interface.", ex.Message); 160Assert.Equal($"Cannot generate proxy implementation for '{typeof(IVoidMethodClient).FullName}.{nameof(IVoidMethodClient.Method)}'. All client proxy methods must return '{typeof(Task).FullName}' or '{typeof(Task).FullName}<T>'.", ex.Message); 168Assert.Equal($"Cannot generate proxy implementation for '{typeof(IStringMethodClient).FullName}.{nameof(IStringMethodClient.Method)}'. All client proxy methods must return '{typeof(Task).FullName}' or '{typeof(Task).FullName}<T>'.", ex.Message); 177$"Cannot generate proxy implementation for '{typeof(IOutParamMethodClient).FullName}.{nameof(IOutParamMethodClient.Method)}'. Client proxy methods must not have 'out' parameters.", ex.Message); 186$"Cannot generate proxy implementation for '{typeof(IRefParamMethodClient).FullName}.{nameof(IRefParamMethodClient.Method)}'. Client proxy methods must not have 'ref' parameters.", ex.Message); 194Assert.Equal("Type must not contain properties.", ex.Message); 202Assert.Equal("Type must not contain events.", ex.Message); 239Assert.Equal("InvokeAsync only works with Single clients.", ex.Message);

MapSignalRTests.cs (2)

29Assert.Equal("Duplicate definitions of 'OverloadedMethod'. Overloading is not supported.", ex.Message); 60"'IServiceCollection.AddSignalR' inside the call to 'ConfigureServices(...)' in the application startup code.", ex.Message);

NativeAotTests.cs (2)

149Assert.Contains("Method 'Microsoft.AspNetCore.SignalR.Tests.NativeAotTests+ChannelValueTypeMethodHub.StreamValueType' is not supported with native AOT because it has a parameter of type 'System.Threading.Channels.ChannelReader`1[System.Double]'.", e.Message); 155Assert.Contains("Method 'Microsoft.AspNetCore.SignalR.Tests.NativeAotTests+EnumerableValueTypeMethodHub.StreamValueType' is not supported with native AOT because it has a parameter of type 'System.Collections.Generic.IAsyncEnumerable`1[System.Single]'.", e.Message);

Microsoft.AspNetCore.SpaServices.Extensions (1)

Proxying\SpaProxy.cs (1)

124$"The underlying exception message was '{ex.Message}'." +

Microsoft.AspNetCore.SpaServices.Extensions.Tests (1)

SpaServicesExtensionsTests.cs (1)

38Assert.Equal("No RootPath was set on the SpaStaticFilesOptions.", exception.Message);

Microsoft.AspNetCore.TestHost.Tests (15)

HttpContextBuilderTests.cs (1)

478Assert.Equal("The application aborted the request.", ex.Message);

RequestLifetimeTests.cs (4)

29Assert.Equal("The application aborted the request.", ex.Message); 45Assert.Equal("The application aborted the request.", ex.Message); 68Assert.Equal("The application aborted the request.", rex.Message); 91Assert.Equal("The application aborted the request.", rex.Message);

ResponseBodyTests.cs (2)

62Assert.Contains("Synchronous operations are disallowed.", ex.Message); 100Assert.Contains("Synchronous operations are disallowed.", ex.Message);

ResponseResetTests.cs (4)

82Assert.Equal("The application reset the request with error code 12345.", rex.Message); 101Assert.Equal("The application reset the request with error code 12345.", rex.Message); 127Assert.Equal("The application reset the request with error code 12345.", rex.Message); 153Assert.Equal("The application reset the request with error code 12345.", rex.Message);

TestClientTests.cs (2)

341Assert.Equal("HttpContent exception", ex.Message); 561Assert.Equal("An error occurred when completing the request. Request delegate may have finished while there is a pending read of the request body.", ex.InnerException.Message);

UseSolutionRelativeContentRootTests.cs (2)

160Assert.Contains("Solution root could not be located", exception.Message); 161Assert.Contains(_tempDirectory, exception.Message);

Microsoft.AspNetCore.Testing.Tests (2)

FakesExtensionsTests.cs (2)

112Assert.Equal("No suitable address found to call the server.", exception.Message); 123Assert.Equal("No suitable address found to call the server.", exception.Message);

Microsoft.AspNetCore.Tests (13)

WebApplicationTests.cs (13)

Microsoft.AspNetCore.WebUtilities.Tests (28)

FileBufferingReadStreamTests.cs (4)

160Assert.Equal("Buffer limit exceeded.", exception.Message); 192Assert.Equal("Buffer limit exceeded.", exception.Message); 363Assert.Equal("Buffer limit exceeded.", exception.Message); 395Assert.Equal("Buffer limit exceeded.", exception.Message);

FileBufferingWriteStreamTests.cs (4)

256Assert.Equal("Buffer limit exceeded.", exception.Message); 271Assert.Equal("Buffer limit exceeded.", exception.Message); 300Assert.Equal("Buffer limit exceeded.", exception.Message); 315Assert.Equal("Buffer limit exceeded.", exception.Message);

FormPipeReaderTests.cs (13)

FormReaderTests.cs (4)

85Assert.Equal("Form value count limit 3 exceeded.", exception.Message); 97Assert.Equal("Form value count limit 3 exceeded.", exception.Message); 124Assert.Equal("Form key or value length limit 10 exceeded.", exception.Message); 151Assert.Equal("Form key or value length limit 10 exceeded.", exception.Message);

MultipartReaderTests.cs (3)

133Assert.Equal("Multipart headers count limit 1 exceeded.", exception.Message); 146Assert.Equal("Line length limit 17 exceeded.", exception.Message); 161Assert.Equal("Multipart header length limit 16384 exceeded. Too much data before the first boundary.", exception.Message);

Microsoft.Build (106)

BackEnd\BuildManager\BuildManager.cs (2)

1886LogInvalidProjectFileError(new InvalidProjectFileException(ex.Message, ex)); 3421LogErrorAndShutdown(ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("ErrorReadingCacheFile", inputCacheFile, exception.Message));

BackEnd\BuildManager\CacheSerialization.cs (1)

110return ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("ErrorWritingCacheFile", outputCacheFile, e.Message);

BackEnd\Components\BuildRequestEngine\BuildRequestEngine.cs (3)

939throw new BuildAbortedException(e.Message, e); 1437TraceEngine("EL: EXCEPTION caught in engine: {0} - {1}", e.GetType(), e.Message); 1452ErrorUtilities.ThrowInternalError(e.Message, e);

BackEnd\Components\Communications\NodeFailedToLaunchException.cs (1)

34: base(innerException.Message, innerException)

BackEnd\Components\Communications\NodeLauncher.cs (2)

209e.Message, 212throw new NodeFailedToLaunchException(e.NativeErrorCode.ToString(CultureInfo.InvariantCulture), e.Message);

BackEnd\Components\Communications\NodeProviderOutOfProcBase.cs (3)

511CommunicationsUtilities.Trace("Skipping process {0} - error retrieving command line: {1}", process.Id, ex.Message); 631CommunicationsUtilities.Trace("Error counting system-wide nodes with mode {0}: {1}", nodeMode, ex.Message); 751CommunicationsUtilities.Trace("Failed to connect to pipe {0}. {1}", pipeName, e.Message.TrimEnd());

BackEnd\Components\RequestBuilder\BatchingEngine.cs (1)

431"CannotEvaluateItemMetadata", metadataName, e.Message);

BackEnd\Components\RequestBuilder\RequestBuilder.cs (3)

807_nodeLoggingContext.LogWarning("SolutionParseUnknownProjectType", ex.Message); 811_projectLoggingContext.LogWarning("SolutionParseUnknownProjectType", ex.Message); 857ErrorUtilities.ThrowInternalError(ex.Message, ex);

BackEnd\Components\RequestBuilder\TaskBuilder.cs (5)

180ex.Message); 872throw new LoggerException(taskException.Message, taskException); 881throw new InternalLoggerException(taskException.Message, taskException, ex.BuildEventArgs, ex.ErrorCode, ex.HelpKeyword, ex.InitializationException); 899throw new BuildAbortedException(taskException.Message, (BuildAbortedException)taskException); 933throw new Exception(taskException.Message, taskException);

BackEnd\Components\SdkResolution\SdkResolverLoader.cs (4)

305ProjectFileErrorUtilities.ThrowInvalidProjectFile(new BuildEventFileInfo(location), e, "CouldNotLoadSdkResolverAssembly", resolverPath, e.Message); 320string message = e.InnerException?.Message ?? e.Message; 326ProjectFileErrorUtilities.ThrowInvalidProjectFile(new BuildEventFileInfo(location), e, "CouldNotLoadSdkResolver", type.Name, e.Message);

BackEnd\Node\InProcNode.cs (1)

195ErrorUtilities.ThrowInternalError(e.Message, e);

BackEnd\TaskExecutionHost\TaskExecutionHost.cs (7)

438_taskLoggingContext.LogError(new BuildEventFileInfo(_taskLocation), "TaskParametersError", _taskName, e.Message); 549e.Message); 572e.InnerException?.Message); 581e.Message); 1071e.Message); 1092e.Message); 1746_targetLoggingContext.LogError(new BuildEventFileInfo(_taskLocation), "AttributeTypeLoadError", _taskName, e.Message);

BuildCheck\Acquisition\BuildCheckAcquisitionModule.cs (1)

74checkContext.DispatchAsComment(MessageImportance.Normal, "CustomCheckFailedRuleLoading", ex.Message);

BuildCheck\Infrastructure\BuildCheckCentralContext.cs (1)

264$"The check '{checkCallback.Item1.Check.FriendlyName}' threw an exception while executing a registered action with message: {e.Message}");

BuildCheck\Infrastructure\BuildCheckManagerProvider.cs (4)

237e.Message); 307string message = $"The check '{check.FriendlyName}' failed to register actions with the following message: '{e.Message}'"; 348e.Message); 774$"The Check '{ba.FriendlyName}' failed to initialize: {e.Message}", e);

Construction\ProjectRootElement.cs (2)

2073ProjectFileErrorUtilities.ThrowInvalidProjectFile(new BuildEventFileInfo(projectFile), ex, "InvalidProjectFile", ex.Message); 2128ProjectFileErrorUtilities.ThrowInvalidProjectFile(fileInfo, ex, "InvalidProjectFile", ex.Message);

Construction\Solution\ProjectInSolution.cs (4)

369_canBeMSBuildProjectFileErrorMessage = e.Message; 374_canBeMSBuildProjectFileErrorMessage = e.Message; 379_canBeMSBuildProjectFileErrorMessage = e.Message; 384_canBeMSBuildProjectFileErrorMessage = e.Message;

Construction\Solution\SolutionFile.cs (5)

750ProjectFileErrorUtilities.ThrowInvalidProjectFile(new BuildEventFileInfo(_solutionFile), "InvalidProjectFile", e.Message); 1231etpProj.RelativePath, e.Message); 1240etpProj.RelativePath, e.Message); 1249etpProj.RelativePath, e.Message); 1258etpProj.RelativePath, e.Message);

Construction\Solution\SolutionProjectGenerator.cs (1)

2200e.Message);

Definition\Toolset.cs (4)

615e.Message); 866loggingContext.LogError(new BuildEventFileInfo(/* this warning truly does not involve any file it is just gathering properties */String.Empty), "TasksPropertyBagError", e.Message); 913string rootedPathMessage = ResourceUtilities.FormatResourceStringStripCodeAndKeyword("OverrideTaskProblemWithPath", _overrideTasksPath, e.Message); 960taskFileError, e.Message);

Errors\InvalidProjectFileException.cs (2)

254return base.Message + ((!String.IsNullOrEmpty(ProjectFile)) 268return base.Message;

Evaluation\Evaluator.cs (5)

351ex.Message); 1824ProjectErrorUtilities.ThrowInvalidProject(importElement.SdkLocation, "SDKResolverCriticalFailure", e.Message); 2083ProjectErrorUtilities.ThrowInvalidProject(importLocationInProject, "InvalidAttributeValueWithException", EscapingUtilities.UnescapeAll(importExpressionEscapedItem), XMakeAttributes.project, XMakeElements.import, ex.Message); 2128ProjectErrorUtilities.ThrowInvalidProject(importLocationInProject, "InvalidAttributeValueWithException", importFileUnescaped, XMakeAttributes.project, XMakeElements.import, ex.Message); 2346importFileUnescaped, ex.InnerException.Message);

Evaluation\Expander.cs (16)

FrameworkLocationHelper.cs (1)

1028ErrorUtilities.ThrowInvalidOperation("FrameworkLocationHelper.CouldNotGenerateReferenceAssemblyDirectory", targetFrameworkRootPath, frameworkName.ToString(), e.Message);

Instance\TaskFactories\AssemblyTaskFactory.cs (4)

293targetLoggingContext.LogError(new BuildEventFileInfo(taskProjectFile), "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, exception.Message); 306ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, loadInfo.AssemblyLocation, e.Message); 492targetLoggingContext.LogError(new BuildEventFileInfo(taskProjectFile), "TaskLoadFailure", taskName, _loadedType.Assembly.AssemblyLocation, exception.Message); 512ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskLoadFailure", taskName, _loadedType.Assembly.AssemblyLocation, e.Message);

Instance\TaskFactories\TaskHostTask.cs (1)

734e.Message);

Instance\TaskRegistry.cs (4)

1490targetLoggingContext.LogError(new BuildEventFileInfo(taskProjectFile), "TaskFactoryLoadFailure", TaskFactoryAttributeName, taskFactoryLoadInfo.AssemblyLocation, exception.Message); 1498ProjectErrorUtilities.ThrowInvalidProject(elementLocation, "TaskFactoryLoadFailure", TaskFactoryAttributeName, taskFactoryLoadInfo.AssemblyLocation, e.Message); 1578message += e.Message; 1596e.Message;

Logging\BinaryLogger\BinaryLogger.cs (3)

392string message = ResourceUtilities.FormatResourceStringStripCodeAndKeyword(out errorCode, out helpKeyword, "InvalidFileLoggerFile", FilePath, e.Message); 563ex.Message); 684string message = ResourceUtilities.FormatResourceStringStripCodeAndKeyword(out errorCode, out helpKeyword, "InvalidFileLoggerFile", FilePath, e.Message);

Logging\BinaryLogger\BuildEventArgsReader.cs (1)

250_recordNumber, localSerializedEventLength, localException.GetType(), localException.Message) + (_skipUnknownEvents

Logging\FileLogger.cs (2)

125string message = ResourceUtilities.FormatResourceStringStripCodeAndKeyword(out errorCode, out helpKeyword, "InvalidFileLoggerFile", _logFileName, e.Message); 154string message = ResourceUtilities.FormatResourceStringStripCodeAndKeyword(out errorCode, out helpKeyword, "InvalidFileLoggerFile", _logFileName, ex.Message);

Logging\LoggerDescription.cs (2)

225string message = ResourceUtilities.FormatResourceStringStripCodeAndKeyword("LoggerInstantiationFailureErrorInvalidCast", _loggerClassName, _loggerAssembly.AssemblyLocation, e.Message); 236throw new LoggerException(le.Message, le, le.ErrorCode, le.HelpKeyword);

Logging\ProfilerLogger.cs (1)

307Console.WriteLine(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("ErrorWritingProfilerReport", ex.Message));

NodeEndpointOutOfProcBase.cs (1)

490CommunicationsUtilities.Trace("Client connection failed but we will wait for another connection. Exception: {0}", e.Message);

PrintLineDebuggerWriters.cs (1)

33File.AppendAllText(errorFile, $"{SimpleFormat(id, callsite, args)}\n{e.Message}\n{e.StackTrace}");

ResourceUtilities.cs (2)

469ErrorUtilities.ThrowInternalError(e.Message); 476ErrorUtilities.ThrowInternalError(e.Message);

TaskLoggingHelper.cs (5)

529StringBuilder flattenedMessage = new StringBuilder(e.Message); 534flattenedMessage.Append(" ---> ").Append(excep.Message); 1254string message = exception.Message; 1627string message = exception.Message; 1642builder.AppendLine(currentException.Message);

Microsoft.Build.BuildCheck.UnitTests (1)

CheckConfiguration_Test.cs (1)

115exception.Message.ShouldContain($"Incorrect value provided in config for key {key}");

Microsoft.Build.Engine.OM.UnitTests (8)

Construction\ProjectRootElement_Tests.cs (3)

1661Assert.Contains(@"Value not set:", exception.Message); 1680Assert.Contains(@"File to reload from does not exist:", exception.Message); 1830Assert.Contains(@"ProjectRootElement can't reload if it contains unsaved changes.", exception.Message);

Definition\DefinitionEditing_Tests.cs (1)

2603Assert.Matches("The requested operation needs to split the item element at location .* into individual elements but item element splitting is disabled with .*", ex.Message);

Definition\ProjectCollection_Tests.cs (1)

777Console.WriteLine(ex.Message);

PrintLineDebuggerWriters.cs (1)

33File.AppendAllText(errorFile, $"{SimpleFormat(id, callsite, args)}\n{e.Message}\n{e.StackTrace}");

ResourceUtilities.cs (2)

469ErrorUtilities.ThrowInternalError(e.Message); 476ErrorUtilities.ThrowInternalError(e.Message);

Microsoft.Build.Engine.UnitTests (39)

BackEnd\BuildRequest_Tests.cs (4)

150exception.Message.ShouldContain($"Failed to get object '{nonExistentMoniker}' from Running Object Table"); 151exception.Message.ShouldContain("HRESULT:"); 167exception.Message.ShouldContain(testMoniker); 205var lines = exception.Message.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);

BackEnd\BuildRequestConfiguration_Tests.cs (1)

513exception.Message.ShouldContain("Method does not treat path normalization cases");

BackEnd\BuildResult_Tests.cs (2)

334Assert.Equal(result.Exception?.Message, deserializedResult.Exception?.Message);

BackEnd\CacheAggregator_Tests.cs (6)

51e.Message.ShouldContain("Cannot aggregate twice"); 68e.Message.ShouldContain("Cannot add after aggregation"); 90e.Message.ShouldContain("Assuming 1-to-1 mapping between configs and results. Otherwise it means the caches are either not minimal or incomplete"); 117e.Message.ShouldContain("Assuming 1-to-1 mapping between configs and results. Otherwise it means the caches are either not minimal or incomplete"); 140e.Message.ShouldContain("Each result should have a corresponding configuration. Otherwise the caches are not consistent"); 171e.Message.ShouldContain("Input caches should not contain entries for the same configuration");

BackEnd\LoggingServicesLogMethod_Tests.cs (2)

1264Assert.Contains("eventName is null", exception.Message); 1410Assert.Contains("ContextID " + s_buildEventContext.ProjectContextId, ex.Message);

BackEnd\MockLoggingService.cs (1)

434_writer(exception.Message);

BackEnd\SdkResolverLoader_Tests.cs (2)

146innerException.Message.ShouldBe(MockSdkResolverThatDoesNotLoad.ExpectedMessage); 209innerException.Message.ShouldBe(expectedMessage);

BackEnd\TaskHostFactory_Tests.cs (1)

211e.Message.ShouldNotBe($"Process with an Id of {pidSidecar} is not running");

BackEnd\TranslationHelpers.cs (4)

127if (left.Message != right.Message) 129diffReason = $"Exception messages are different ({left.Message} vs {right.Message}).";

Construction\SolutionFile_OldParser_Tests.cs (1)

929throw new Exception("Failed to parse solution containing description information. Error: " + ex.Message, ex);

ErrorUtilities_Tests.cs (1)

23Assert.Contains("msbuild rules", e.Message); // "exception message"

Graph\GraphLoadedFromSolution_tests.cs (2)

86exception.Message.ShouldContain("MSB4263:"); 518exception.Message.ShouldContain("MSB4251");

Graph\ProjectGraph_Tests.cs (2)

311Should.Throw<CircularDependencyException>(() => new ProjectGraph(entryProject.Path)).Message.ShouldContain(expectedErrorMessage); 345Should.Throw<CircularDependencyException>(() => new ProjectGraph(entryProject.Path)).Message.ShouldContain(errorMessage);

NodeStatus_Transition_Tests.cs (3)

138if (!ex.Message.StartsWith("Directory:")) 146foreach (var line in ex.Message.Split('\n')) 161{{ex.Message.TrimEnd('\n')}}

ProjectCache\ProjectCacheTests.cs (4)

1164buildResult.Exception.InnerException!.Message.ShouldContain("Cache plugin exception from"); 1201e.InnerException!.Message.ShouldContain("Cache plugin exception from EndBuildAsync"); 1298buildResult.Exception.InnerException!.Message.ShouldContain("Cache plugin exception from"); 1367Should.Throw<ProjectCacheException>(() => buildSession.Dispose()).InnerException!.Message.ShouldContain("Cache plugin exception from EndBuildAsync");

TestAssets\ExampleFrameworkTask\ExampleTaskX64\ExampleTaskX64.cs (1)

27Log.LogError($"Failed to determine executing process: {ex.Message}");

TestAssets\ExampleFrameworkTask\ExampleTaskX86\ExampleTaskX86.cs (1)

27Log.LogError($"Failed to determine executing process: {ex.Message}");

TestAssets\ExampleNetTask\ExampleTask\ExampleTask.cs (1)

36Log.LogError($"Failed to determine executing process: {ex.Message}");

Microsoft.Build.Framework (15)

BuildException\BuildExceptionBase.cs (1)

83writer.Write(exception.Message);

EncodingUtilities.cs (1)

77Debug.Assert(false, "GetEncoding(default OEM encoding) threw a NotSupportedException in EncodingUtilities.CurrentSystemOemEncoding! Please log a bug against MSBuild.", ex.Message);

FailFast.cs (1)

76Console.WriteLine(current.Message);

FatalError.cs (1)

25: base(innerException.Message, innerException)

FileSystem\NativeWin32Exception.cs (4)

15/// associated recent error code (<see cref="System.Runtime.InteropServices.Marshal.GetLastWin32Error" />). The <see cref="Exception.Message" /> 29/// The exception's <see cref="Exception.Message" /> includes the error code, a system-provided message describing it, 42/// The exception's <see cref="Exception.Message" /> includes the error code and a system-provided message describing it. 55string systemMessage = new Win32Exception(nativeErrorCode).Message;

FileUtilities_TempFiles.cs (1)

197throw new IOException(SR.FormatFailedCreatingTempFile(ex.Message), ex);

ITaskItemExtensions.cs (1)

58valueOrError = e.Message;

ItemSpecModifiers.cs (1)

382throw new InvalidOperationException(SR.FormatInvalidFilespecForTransform(modifier, itemSpec, e.Message));

NativeMethods.cs (1)

1126errorMessage = symbolicLinkCreated ? null : Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()).Message;

Telemetry\BuildCheckTelemetry.cs (1)

34string? sanitizedMessage = CrashTelemetry.TruncateMessage(exception.Message);

Telemetry\CrashTelemetry.cs (1)

311ExceptionMessage = TruncateMessage(exception.Message);

Telemetry\CrashTelemetryRecorder.cs (1)

191: base(CrashTelemetry.TruncateMessage(original.Message) ?? original.GetType().FullName,

Microsoft.Build.Framework.UnitTests (3)

FileUtilities_Tests.cs (1)

184Console.WriteLine(e.Message);

ResourceUtilities.cs (2)

469ErrorUtilities.ThrowInternalError(e.Message); 476ErrorUtilities.ThrowInternalError(e.Message);

Microsoft.Build.Tasks.CodeAnalysis (13)

src\Compilers\Core\MSBuildTask\CopyRefAssembly.cs (1)

51Log.LogMessageFromResources(MessageImportance.High, "CopyRefAssembly_BadSource3", SourcePath, e.Message, e.StackTrace);

src\Compilers\Core\MSBuildTask\Csc.cs (2)

552Log.LogErrorWithCodeFromResources("General_CouldNotSetHostObjectParameter", param, e.Message); 686Log.LogErrorWithCodeFromResources("General_CouldNotSetHostObjectParameter", param, e.Message);

src\Compilers\Core\MSBuildTask\Vbc.cs (2)

335Log.LogErrorWithCodeFromResources("VBC_RenamePDB", PdbFile, e.Message); 979Log.LogErrorWithCodeFromResources("General_CouldNotSetHostObjectParameter", param, e.Message);

src\Compilers\Shared\BuildServerConnection.cs (4)

src\Compilers\Shared\CompilerServerLogger.cs (2)

84builder.AppendLine($"Error: '{exception.GetType().Name}' '{exception.Message}' occurred during '{reason}'"); 139Debug.Assert(false, e.Message);

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.Build.Tasks.CodeAnalysis.Sdk (13)

src\Compilers\Core\MSBuildTask\CopyRefAssembly.cs (1)

51Log.LogMessageFromResources(MessageImportance.High, "CopyRefAssembly_BadSource3", SourcePath, e.Message, e.StackTrace);

src\Compilers\Core\MSBuildTask\Csc.cs (2)

src\Compilers\Core\MSBuildTask\Vbc.cs (2)

335Log.LogErrorWithCodeFromResources("VBC_RenamePDB", PdbFile, e.Message); 979Log.LogErrorWithCodeFromResources("General_CouldNotSetHostObjectParameter", param, e.Message);

src\Compilers\Shared\BuildServerConnection.cs (4)

src\Compilers\Shared\CompilerServerLogger.cs (2)

84builder.AppendLine($"Error: '{exception.GetType().Name}' '{exception.Message}' occurred during '{reason}'"); 139Debug.Assert(false, e.Message);

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.Build.Tasks.Core (129)

AddToWin32Manifest.cs (1)

151Log.LogErrorWithCodeFromResources(null, manifestPath, 0, 0, 0, 0, "AddToWin32Manifest.ManifestCanNotBeOpenedWithException", ex.Message);

AppConfig\AppConfig.cs (1)

65throw new AppConfigException(e.Message, appConfigFilePath, lineNumber, linePosition, e);

AppConfig\BindingRedirect.cs (2)

66ErrorUtilities.ThrowArgument(e, "AppConfig.InvalidOldVersionAttribute", e.Message); 80ErrorUtilities.ThrowArgument(e, "AppConfig.InvalidNewVersionAttribute", e.Message);

AssemblyDependency\AssemblyFoldersFromConfig\AssemblyFoldersFromConfigResolver.cs (1)

144_taskLogger.LogError(ResourceUtilities.GetResourceString("ResolveAssemblyReference.AssemblyFoldersConfigFileMalformed"), _assemblyFolderConfigFile, e.Message);

AssemblyDependency\BadImageReferenceException.cs (3)

38public override string Message => (InnerException == null) ? base.Message : $"{base.Message} {InnerException.Message}";

AssemblyDependency\ReferenceTable.cs (8)

512reference.AddError(new DependencyResolutionException(e.Message, e)); 696reference.AddError(new BadImageReferenceException(e.Message, e)); 918throw new InvalidParameterValueException("AssemblyFiles", referenceAssemblyFile.ItemSpec, e.Message); 1010_log?.LogErrorFromResources("ResolveAssemblyReference.ProblemFindingSatelliteAssemblies", reference.FullPath, e.Message); 1220reference.AddError(new DependencyResolutionException(e.Message, e)); 1224reference.AddError(new DependencyResolutionException(e.Message, e)); 1785reference.AddError(new DependencyResolutionException(e.Message, e)); 2929_log.LogErrorWithCodeFromResources("ResolveAssemblyReference.ProblemReadingImplementationDll", dllPath, e.Message);

AssemblyDependency\ResolveAssemblyReference.cs (11)

AssemblyDependency\Resolver.cs (1)

331throw new InvalidParameterValueException("SearchPaths", directory + (directory.EndsWith("\\", StringComparison.OrdinalIgnoreCase) ? String.Empty : "\\") + baseName, e.Message);

BootstrapperUtil\BootstrapperBuilder.cs (8)

249_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.General", ex.Message)); 377_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.CopyError", setupSourceFile, strOutputExe, ex.Message)); 382_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.CopyError", setupSourceFile, strOutputExe, ex.Message)); 392_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.CopyError", setupSourceFile, strOutputExe, ex.Message)); 1056Debug.Fail(ex.Message); 1483_results?.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.CopyPackageError", packageFileSource.Value, builder.Name, ex.Message)); 1489_results?.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.CopyPackageError", packageFileSource.Value, builder.Name, ex.Message)); 1501_results?.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.CopyPackageError", packageFileSource.Value, builder.Name, ex.Message));

Copy.cs (3)

981Log.LogErrorWithCodeFromResources("Copy.Error", sourceFileState.Path.OriginalValue, destinationFileState.Path.OriginalValue, e.Message); 986Log.LogErrorWithCodeFromResources("Copy.Error", sourceFileState.Path.OriginalValue, destinationFileState.Path.OriginalValue, e.Message); 1070destinationFileState.Path.OriginalValue, retries, RetryDelayMilliseconds, e.Message,

CreateManifestResourceName.cs (1)

257Log.LogErrorWithCodeFromResources("CreateManifestResourceName.Error", resourceFile.ItemSpec, e.Message);

Delete.cs (3)

160Log.LogWarningWithCodeFromResources("Delete.Retrying", filePath?.OriginalValue ?? file.ItemSpec, retries, RetryDelayMilliseconds, e.Message, lockedFileMessage); 169Log.LogWarningWithCodeFromResources("Delete.Error", filePath?.OriginalValue ?? file.ItemSpec, e.Message, lockedFileMessage); 173Log.LogErrorWithCodeFromResources("Delete.Error", filePath?.OriginalValue ?? file.ItemSpec, e.Message, lockedFileMessage);

DownloadFile.cs (2)

120Log.LogWarningWithCodeFromResources("DownloadFile.Retrying", SourceUrl, retryAttemptCount + 1, RetryDelayMilliseconds, actualException.Message); 172throw new CustomHttpRequestException(e.Message, e.InnerException, response.StatusCode);

ErrorFromResources.cs (1)

63Log.LogErrorWithCodeFromResources("ErrorFromResources.LogErrorFailure", Resource, e.Message);

FileIO\ReadLinesFromFile.cs (1)

73Log.LogErrorWithCodeFromResources("ReadLinesFromFile.ErrorOrWarning", filePath.OriginalValue, e.Message);

FileIO\WriteLinesToFile.cs (6)

150Log.LogErrorWithCodeFromResources("WriteLinesToFile.ErrorOrWarning", filePath.OriginalValue, e.Message, lockedFileMessage); 178Log.LogErrorWithCodeFromResources("WriteLinesToFile.ErrorOrWarning", filePath.OriginalValue, e.Message, lockedFileMessage); 222Log.LogErrorWithCodeFromResources("WriteLinesToFile.ErrorOrWarning", filePath.OriginalValue, moveEx.Message, lockedFileMessage); 254Log.LogErrorWithCodeFromResources("WriteLinesToFile.ErrorOrWarning", filePath.OriginalValue, fallbackEx.Message, lockedFileMessage); 262Log.LogErrorWithCodeFromResources("WriteLinesToFile.ErrorOrWarning", filePath.OriginalValue, e.Message, lockedFileMessage); 302Log.LogErrorWithCodeFromResources("WriteLinesToFile.ErrorOrWarning", filePath.OriginalValue, e.Message, lockedFileMessage);

GenerateApplicationManifest.cs (1)

479Log.LogErrorWithCodeFromResources("GenerateManifest.ReadInputManifestFailed", InputManifest.ItemSpec, ex.Message);

GenerateManifestBase.cs (2)

459Log.LogErrorWithCodeFromResources("GenerateManifest.ReadInputManifestFailed", InputManifest.ItemSpec, ex.Message); 623Log.LogErrorWithCodeFromResources("GenerateManifest.WriteOutputManifestFailed", OutputManifest.ItemSpec, ex.Message, lockedFileMessage);

GenerateResource.cs (11)

1481Log.LogErrorWithCodeFromResources("GenerateResource.InvalidFilename", item.ItemSpec, e.Message); 1640Log.LogErrorWithCodeFromResources("GenerateResource.CannotWriteSTRFile", StronglyTypedFileName, e.Message); 2620"GenerateResource.MessageTunnel", tfe.Message); 2637"General.InvalidResxFile", e.Message); 2648"General.InvalidResxFile", e.Message); 2737_stronglyTypedFilename, e.Message); 2760FileUtilities.GetFullPathNoThrow(currentOutputFile), io.Message); 2794FileUtilities.GetFullPathNoThrow(inFile), e.Message); // Input file is more useful to log 2805FileUtilities.GetFullPathNoThrow(currentOutputFile), e.Message); 2890_logger.LogWarningWithCodeFromResources("GenerateResource.DeleteCorruptOutputFailed", FileUtilities.GetFullPathNoThrow(filename), deleteException.Message); 3531logger.LogErrorWithCodeFromResources("GenerateResource.STRCodeDomProviderFailed", stronglyTypedLanguage, e.Message);

GetAssemblyIdentity.cs (1)

80Log.LogErrorWithCodeFromResources("GetAssemblyIdentity.CouldNotGetAssemblyName", item.ItemSpec, e.Message);

GetInstalledSDKLocations.cs (1)

152Log.LogErrorWithCodeFromResources("GetInstalledSDKs.CouldNotGetSDKList", e.Message);

GetReferenceAssemblyPaths.cs (1)

222Log.LogErrorWithCodeFromResources("GetReferenceAssemblyPaths.ProblemGeneratingReferencePaths", TargetFrameworkMoniker, e.Message);

GetSDKReferenceFiles.cs (5)

292Log.LogErrorWithCodeFromResources("GetSDKReferenceFiles.CouldNotGetSDKReferenceFiles", e.Message); 973_exceptionMessages.Enqueue(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("GetSDKReferenceFiles.ProblemDeletingCacheFile", existingCacheFile, e.Message)); 986_exceptionMessages.Enqueue(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("GetSDKReferenceFiles.ProblemWritingCacheFile", referencesCacheFile, e.Message)); 1108_exceptionMessages.Enqueue(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("GetSDKReferenceFiles.ProblemGeneratingHash", currentAssembly, ex.Message)); 1142_exceptionMessages.Enqueue(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("GetSDKReferenceFiles.ProblemGettingAssemblyMetadata", referencePath, e.Message));

ListOperators\FindUnderPath.cs (2)

84"FindUnderPath.InvalidParameter", "Path", Path.ItemSpec, e.Message); 113"FindUnderPath.InvalidParameter", "Files", item.ItemSpec, e.Message);

MakeDir.cs (1)

88Log.LogErrorWithCodeFromResources("MakeDir.Error", absolutePath?.OriginalValue ?? directory.ItemSpec, e.Message);

ManifestUtil\LauncherBuilder.cs (2)

75_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateLauncher.General", ex.Message)); 97_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateLauncher.CopyError", LauncherPath, strOutputExe, ex.Message));

ManifestUtil\Manifest.cs (2)

584OutputMessages.AddErrorMessage("GenerateManifest.General", e.Message); 601OutputMessages.AddErrorMessage("GenerateManifest.General", e.Message);

ManifestUtil\SecurityUtil.cs (1)

750throw new ApplicationException(ex.Message, ex);

Move.cs (1)

182Log.LogErrorWithCodeFromResources("Move.Error", sourceSpec, destinationSpec, e.Message, lockedFileMessage);

NativeMethods.cs (1)

810errorMessage = hardLinkCreated ? null : Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()).Message;

NodePipeServer.cs (1)

138CommunicationsUtilities.Trace("Client connection failed but we will wait for another connection. Exception: {0}", e.Message);

PrintLineDebuggerWriters.cs (1)

33File.AppendAllText(errorFile, $"{SimpleFormat(id, callsite, args)}\n{e.Message}\n{e.StackTrace}");

RemoveDir.cs (3)

136Log.LogErrorWithCodeFromResources("RemoveDir.Error", directoryPath.OriginalValue, e.Message); 142Log.LogErrorWithCodeFromResources("RemoveDir.Error", directoryPath.OriginalValue, e.Message); 180Log.LogErrorWithCodeFromResources("RemoveDir.Error", directory, e.Message);

ResourceUtilities.cs (2)

469ErrorUtilities.ThrowInternalError(e.Message); 476ErrorUtilities.ThrowInternalError(e.Message);

RoslynCodeTaskFactory\RoslynCodeTaskFactory.cs (1)

326log.LogErrorWithCodeFromResources("CodeTaskFactory.InvalidTaskXml", e.Message);

SignFile.cs (5)

75Log.LogErrorWithCodeFromResources("SignFile.SignToolError", ex.Message.Trim()); 80Log.LogWarningWithCodeFromResources("SignFile.SignToolWarning", ex.Message.Trim()); 85Log.LogErrorWithCodeFromResources("SignFile.SignToolError", ex.Message.Trim()); 90Log.LogErrorWithCodeFromResources("SignFile.SignToolError", ex.Message.Trim()); 95Log.LogErrorWithCodeFromResources("SignFile.SignToolError", ex.Message.Trim());

StateFileBase.cs (3)

67log.LogWarningWithCodeFromResources("General.CouldNotWriteStateFile", stateFile, e.Message); 123log.LogMessageFromResources("General.CouldNotReadStateFileMessage", stateFile, e.Message); 148log.LogWarningWithCodeFromResources("General.CouldNotDeleteStateFile", stateFile, e.Message);

Touch.cs (5)

87Log.LogErrorWithCodeFromResources("Touch.TimeSyntaxIncorrect", e.Message); 193Log.LogErrorWithCodeFromResources("Touch.CannotCreateFile", file.OriginalValue, e.Message); 266Log.LogErrorWithCodeFromResources("Touch.CannotMakeFileWritable", file.OriginalValue, e.Message, lockedFileMessage); 282Log.LogErrorWithCodeFromResources("Touch.CannotTouch", file.OriginalValue, e.Message, lockedFileMessage); 297Log.LogErrorWithCodeFromResources("Touch.CannotRestoreAttributes", file.OriginalValue, e.Message);

Unzip.cs (5)

99Log.LogErrorWithCodeFromResources("Unzip.ErrorCouldNotCreateDestinationDirectory", DestinationFolder.ItemSpec, e.Message); 159Log.LogErrorWithCodeFromResources("Unzip.ErrorCouldNotOpenFile", sourceFile.ItemSpec, e.Message); 228Log.LogErrorWithCodeFromResources("Unzip.ErrorCouldNotCreateDestinationDirectory", destinationPath.DirectoryName, e.Message); 241Log.LogErrorWithCodeFromResources("Unzip.ErrorCouldNotMakeFileWriteable", zipArchiveEntry.FullName, destinationPath.FullName, e.Message, lockedFileMessage); 291Log.LogErrorWithCodeFromResources("Unzip.ErrorCouldNotExtractFile", zipArchiveEntry.FullName, destinationPath.FullName, e.Message);

WriteCodeFragment.cs (4)

137Log.LogErrorWithCodeFromResources("WriteCodeFragment.CouldNotWriteOutput", itemSpec, ex.Message, lockedFileMessage); 172Log.LogErrorWithCodeFromResources("WriteCodeFragment.CouldNotCreateProvider", Language, e.Message); 571Log.LogErrorWithCodeFromResources("WriteCodeFragment.CouldNotConvertValue", rawValue, typeName, ex.Message); 601Log.LogMessageFromResources("WriteCodeFragment.CouldNotConvertToInferredType", parameterName, inferredType.Name, ex.Message);

XmlPeek.cs (4)

79Log.LogErrorWithCodeFromResources("XmlPeek.ArgumentError", e.Message); 94Log.LogErrorWithCodeFromResources("XmlPeekPoke.InputFileError", XmlInputPath.ItemSpec, e.Message); 111Log.LogErrorWithCodeFromResources("XmlPeekPoke.XPathError", Query, e.Message); 124Log.LogErrorWithCodeFromResources("XmlPeek.NamespacesError", e.Message);

XmlPoke.cs (4)

83Log.LogErrorWithCodeFromResources("XmlPeekPoke.InputFileError", XmlInputPath.ItemSpec, e.Message); 97Log.LogErrorWithCodeFromResources("XmlPeekPoke.XPathError", Query, e.Message); 111Log.LogErrorWithCodeFromResources("XmlPoke.NamespacesError", e.Message); 138Log.LogErrorWithCodeFromResources("XmlPoke.PokeError", Value.ItemSpec, e.Message);

XslTransformation.cs (4)

122Log.LogErrorWithCodeFromResources("XslTransform.ArgumentError", e.Message); 149Log.LogErrorWithCodeFromResources("XslTransform.XsltArgumentsError", e.Message); 167Log.LogErrorWithCodeFromResources("XslTransform.XsltLoadError", e.Message); 194Log.LogErrorWithCodeAndExceptionFromResources(e, true, true, "XslTransform.TransformError", [e.Message]);

ZipDirectory.cs (2)

98Log.LogErrorWithCodeFromResources("ZipDirectory.ErrorFailed", sourceDirectory.FullName, destinationFile.FullName, e.Message, lockedFileMessage); 141Log.LogErrorWithCodeFromResources("ZipDirectory.ErrorFailed", sourceDirectory.FullName, destinationFile.FullName, e.Message, string.Empty);

Microsoft.Build.Tasks.UnitTests (9)

AssemblyDependency\Miscellaneous.cs (2)

5623Assert.DoesNotContain("MSB3257", ((Exception)allowListErrors[0]).Message); // "Expect to not have the null redist warning" 5670Assert.Contains(message, ((Exception)allowListErrors[0]).Message); // "Expected assertion to contain correct error code"

ErrorUtilities_Tests.cs (1)

23Assert.Contains("msbuild rules", e.Message); // "exception message"

NativeMethodsShared_Tests.cs (1)

146Console.WriteLine(e.Message);

XslTransformation_Tests.cs (5)

594Assert.Contains("The '$' character", e.Message); 745Assert.Contains("'<'", e.Message); 778Assert.Contains("MSB3701", e.Message); 843Assert.Contains("error?", e.Message); 930Assert.Contains("error?", e.Message);

Microsoft.Build.UnitTests.Shared (4)

ObjectModelHelpers.cs (4)

181result.Exception.Message.ShouldContain(exceptionMessageSubstring); 191result.Exception.Message.ShouldContain(exceptionMessageSubstring); 1922Console.WriteLine("COMPARE EXCEPTIONS:\n\n#1: {0}\n\n#2: {1}", ex1.Message, ex2.Message);

Microsoft.Build.Utilities.Core (18)

FrameworkLocationHelper.cs (1)

1028ErrorUtilities.ThrowInvalidOperation("FrameworkLocationHelper.CouldNotGenerateReferenceAssemblyDirectory", targetFrameworkRootPath, frameworkName.ToString(), e.Message);

PlatformManifest.cs (1)

159ReadErrorMessage = e.Message;

PrintLineDebuggerWriters.cs (1)

33File.AppendAllText(errorFile, $"{SimpleFormat(id, callsite, args)}\n{e.Message}\n{e.StackTrace}");

ResourceUtilities.cs (2)

469ErrorUtilities.ThrowInternalError(e.Message); 476ErrorUtilities.ThrowInternalError(e.Message);

SDKManifest.cs (1)

362ReadErrorMessage = e.Message;

TaskLoggingHelper.cs (5)

ToolLocationHelper.cs (6)

868ErrorUtilities.DebugTraceMessage("GetPlatformSDKPropsFileLocation", "Encountered exception trying to get the SDK props file Location : {0}", e.Message); 1065ErrorUtilities.DebugTraceMessage("GetLegacyTargetPlatformReferences", "Encountered exception trying to gather the platform references: {0}", e.Message); 1185ErrorUtilities.DebugTraceMessage("GetValueUsingMatchingSDKManifest", "Encountered exception trying to check if SDK is versioned: {0}", e.Message); 3081ErrorUtilities.DebugTraceMessage("GatherPlatformsForSdk", "Encountered exception trying to gather platform-specific data: {0}", e.Message); 3176ErrorUtilities.ThrowInvalidOperation("ToolsLocationHelper.InvalidRedistFile", redistFilePath, ex.Message); 3224ErrorUtilities.ThrowInvalidOperation("ToolsLocationHelper.CouldNotCreateChain", path, pathToReturn, e.Message);

ToolTask.cs (1)

879LogShared.LogWarningWithCodeFromResources("Shared.FailedDeletingTempFile", fileName, e.Message, lockedFileMessage);

Microsoft.Build.Utilities.UnitTests (5)

ErrorUtilities_Tests.cs (1)

23Assert.Contains("msbuild rules", e.Message); // "exception message"

NativeMethodsShared_Tests.cs (1)

146Console.WriteLine(e.Message);

TaskItem_Tests.cs (2)

142Console.WriteLine(e.Message); 162Console.WriteLine(e.Message);

TaskLoggingHelper_Tests.cs (1)

228Console.WriteLine(e.Message);

Microsoft.CodeAnalysis (63)

CodeGen\PermissionSetAttribute.cs (1)

108throw new PermissionSetFileReadException(e.Message, _resolvedPermissionSetFilePath);

CommandLine\CommonCompiler.CompilerEmitStreamProvider.cs (3)

44var diagnosticInfo = new DiagnosticInfo(messageProvider, messageProvider.ERR_OutputWriteFailed, _filePath, e.Message); 121? (object)e.Message 126e.Message,

CommandLine\CommonCompiler.cs (3)

507diagnosticInfo = new DiagnosticInfo(messageProvider, messageProvider.ERR_NoSourceFile, filePath, e.Message); 1671diagnostics.Add(messageProvider.CreateDiagnostic(messageProvider.ERR_ErrorBuildingWin32Resource, Location.None, ex.Message)); 1705diagnostics.Add(messageProvider.CreateDiagnostic(errorCode, Location.None, fullPath, ex.Message));

Compilation.EmitStream.cs (1)

199diagnostics.Add(StrongNameKeys.GetError(_strongNameKeys.KeyFilePath, _strongNameKeys.KeyContainer, ex.Message, messageProvider));

Compilation\Compilation.cs (10)

Diagnostic\CommonMessageProvider.cs (1)

261diagnostics.Add(CreateDiagnostic(ERR_OutputWriteFailed, Location.None, filePath, e.Message));

DiagnosticAnalyzer\AnalyzerAssemblyLoader.cs (1)

238throw new InvalidOperationException($"Unable to load {assemblyName.Name}: {ex.Message}", ex);

DiagnosticAnalyzer\AnalyzerExecutor.cs (3)

1406var messageArguments = new[] { analyzerName, e.GetType().ToString(), e.Message, contextInformation }; 1438return string.Format(CodeAnalysisResources.CompilerAnalyzerThrows, analyzerName, ex.GetType().ToString(), ex.Message, ex.CreateDiagnosticDescription()); 1453var messageArguments = new[] { e.GetType().ToString(), e.Message, e.CreateDiagnosticDescription() };

DiagnosticAnalyzer\AnalyzerFileReference.cs (1)

206string message = e.Message.Replace("\r", "").Replace("\n", "");

DiaSymReader\Writer\SymUnmanagedWriterException.cs (1)

41: this(innerException.Message, innerException, implementationModuleName)

DiaSymReader\Writer\SymUnmanagedWriterFactory.cs (1)

57throw new DllNotFoundException(loadException.Message, loadException);

Emit\EditAndContinue\DefinitionMap.cs (2)

360e.Message 445e.Message

FileSystem\FileUtilities.cs (9)

FileSystem\ICommonCompilerFileSystem.cs (2)

40throw new FileNotFoundException(e.Message, filePath, e); 48throw new IOException(e.Message, e);

InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

InternalUtilities\XmlUtilities.cs (2)

82errorMessage = e.Message; 87errorMessage = e.Message;

MetadataReference\PortableExecutableReference.cs (2)

191return messageProvider.CreateDiagnostic(errorCode, location, display, e.Message); 202return messageProvider.CreateDiagnostic(errorCode, location, display, e.Message);

NativePdbWriter\PdbWriter.cs (1)

758throw new SymUnmanagedWriterException(e.Message, e);

PEWriter\MetadataWriter.cs (1)

1778throw new SymUnmanagedWriterException(e.Message, e);

PEWriter\MetadataWriter.PortablePdb.cs (1)

859throw new SymUnmanagedWriterException(e.Message, e);

PEWriter\PeWriter.cs (2)

30: base(inner.Message, inner) 232throw new SymUnmanagedWriterException(e.Message, e);

RuleSet\RuleSet.cs (2)

317diagnosticsOpt.Add(Diagnostic.Create(messageProviderOpt, messageProviderOpt.ERR_CantReadRulesetFile, resolvedPath, e.Message)); 333diagnosticsOpt.Add(Diagnostic.Create(messageProviderOpt, messageProviderOpt.ERR_CantReadRulesetFile, resolvedPath, e.Message));

RuleSet\RuleSetInclude.cs (1)

71throw new InvalidRuleSetException(string.Format(CodeAnalysisResources.InvalidRuleSetInclude, path, e.Message));

RuleSet\RuleSetProcessor.cs (1)

77throw new InvalidRuleSetException(e.Message);

SourceGeneration\GeneratorDriver.cs (1)

416return Diagnostic.Create(descriptor, Location.None, generator.GetGeneratorType().Name, e.GetType().Name, e.Message, e.CreateDiagnosticDescription());

src\Compilers\Core\AnalyzerDriver\AnalyzerExceptionDescriptionBuilder.cs (1)

42return string.Join(s_separator, exception.Message, fusionLog);

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

StrongName\DesktopStrongNameProvider.cs (5)

87return new StrongNameKeys(StrongNameKeys.GetKeyFileError(messageProvider, keyFilePath, ex.Message)); 104return new StrongNameKeys(StrongNameKeys.GetContainerError(messageProvider, keyContainerName, ex.Message)); 158throw new IOException(ex.Message); 239throw new IOException(ex.Message, ex); 261throw new IOException(ex.Message, ex);

StrongName\StrongNameKeys.cs (1)

117return new StrongNameKeys(GetKeyFileError(messageProvider, keyFilePath, ex.Message));

Microsoft.CodeAnalysis.Analyzers (12)

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.AnalyzerUtilities (12)

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.BannedApiAnalyzers (12)

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.CodeStyle (13)

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (1)

69Debug.Fail(ex.Message);

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.Collections.Package (2)

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.Contracts.Package (2)

ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.CSharp (5)

BoundTree\BoundTreeVisitors.cs (1)

168: base(inner.Message, inner)

CommandLine\CSharpCompiler.cs (1)

143diagnostics.Add(new DiagnosticInfo(MessageProvider, (int)ErrorCode.ERR_CantReadConfigFile, appConfigPath, ex.Message));

Compiler\DocumentationCommentCompiler.cs (1)

111diagnostics.Add(ErrorCode.ERR_DocFileGen, Location.None, e.Message);

Compiler\DocumentationCommentCompiler.IncludeElementExpander.cs (1)

346includeDiagnostics.Add(ErrorCode.WRN_FailedInclude, location, filePathValue, xpathValue, e.Message);

Emitter\EditAndContinue\EmitHelpers.cs (1)

106diagnostics.Add(ErrorCode.ERR_ModuleEmitFailure, NoLocation.Singleton, compilation.AssemblyName, e.Message);

Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (1)

Emit\CompilationEmitTests.cs (1)

5219var ioExceptionMessage = new IOException().Message;

Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (10)

Attributes\EmitTestStrongNameProvider.cs (2)

40Diagnostic(ErrorCode.ERR_PublicKeyFileFailure).WithArguments(keyFile, ex.Message).WithLocation(1, 1)); 60Diagnostic(ErrorCode.ERR_PublicKeyContainerFailure).WithArguments("RoslynTestContainer", ex.Message).WithLocation(1, 1));

Diagnostics\DiagnosticAnalyzerTests.cs (3)

925&& e.Exception.Message == message) 961&& e.Exception.Message == message) 1075&& e.Exception.Message == message)

Diagnostics\DiagnosticSuppressorTests.cs (5)

411Diagnostic("AD0001").WithArguments(suppressor.ToString(), typeof(NotImplementedException).FullName, new NotImplementedException().Message, context).WithLocation(1, 1), 455Diagnostic("AD0001").WithArguments(suppressor.ToString(), typeof(NotImplementedException).FullName, new NotImplementedException().Message, context).WithLocation(1, 1), 491&& e.Exception.Message == exceptionMessage) 544&& e.Exception.Message == exceptionMessage) 597&& e.Exception.Message == exceptionMessage)

Microsoft.CodeAnalysis.CSharp.Scripting.UnitTests (15)

CommandLineRunnerTests.cs (4)

184{exception.GetType()}: {exception.Message} 190$@"{exception.GetType()}: {exception.Message} 213{exception.GetType()}: {exception.Message} 219$@"{exception.GetType()}: {exception.Message}

InteractiveSessionTests.cs (5)

1933Assert.Equal("Bang!", state1.Exception.Message); 1960Assert.Equal("Bang!", state2.Exception.Message); 1988Assert.Equal("Bang!", state3.Exception.Message); 2008Assert.Equal("Bang 1!", state1.Exception.Message); 2016Assert.Equal("Bang 2!", state2.Exception.Message);

ObjectFormatterTests.cs (6)

942$@"{new Exception().Message} 966$@"{new Exception().Message} 990$@"{new Exception().Message} 1014$@"{new Exception().Message} 1087$@"{new Exception().Message} 1112$@"{new Exception().Message}

Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (8)

SourceGeneration\GeneratorDriverTests.cs (1)

4812Assert.Equal("failed", exception.Message);

SourceGeneration\SyntaxAwareGeneratorTests.cs (7)

391Assert.Equal("Test Exception", results.Results[0].Exception?.Message); 433Assert.Equal("Test Exception", results.Results[0].Exception?.Message); 523Assert.Equal("Test Exception", results.Results[0].Exception?.Message); 1870Assert.Equal("Test Exception", results.Results[0].Exception?.Message); 1911Assert.Equal("Test Exception", results.Results[0].Exception?.Message); 1957Assert.Equal("Test Exception", results.Results[0].Exception?.Message); 2061Assert.Equal("Simulated cancellation from external source", results.Results[0].Exception!.Message);

Microsoft.CodeAnalysis.CSharp.Test.Utilities (1)

CSharpTestBase.cs (1)

2130Assert.Equal(expectedMessage, e.Message);

Microsoft.CodeAnalysis.Debugging.Package (2)

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.EditorFeatures (2)

InlineRename\CommandHandlers\RenameCommandHandler.cs (2)

82notificationService?.SendNotification(ex.Message, title: EditorFeaturesResources.Rename, severity: NotificationSeverity.Error); 94message: string.Format(EditorFeaturesWpfResources.Error_performing_rename_0, ex.Message),

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (1)

CodeFixes\CodeFixServiceTests.cs (1)

598=> exception.Message + Environment.NewLine + exception.StackTrace;

Microsoft.CodeAnalysis.ExpressionEvaluator.ExpressionCompiler (1)

ExpressionCompiler.cs (1)

435errorMessage = e.Message;

Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider (3)

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

src\ExpressionEvaluator\Core\Source\ResultProvider\ResultProvider.cs (1)

1037ErrorMessage: e.Message,

Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider.Utilities (3)

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

src\ExpressionEvaluator\Core\Source\ResultProvider\ResultProvider.cs (1)

1037ErrorMessage: e.Message,

Microsoft.CodeAnalysis.Extensions.Package (3)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.Features (18)

Diagnostics\Service\DocumentAnalysisExecutor_Helpers.cs (1)

44return Diagnostic.Create(descriptor, Location.None, analyzerName, e.GetType(), e.Message);

EditAndContinue\CommittedSolution.cs (4)

397log.Write($"Source file of project '{projectName}' doesn't match output PDB: error opening PDB '{compilationOutputs.PdbDisplayPath}' (assembly: '{compilationOutputs.AssemblyDisplayPath}'): {e.Message}", LogMessageSeverity.Warning); 445log.Write($"Error calculating checksum for source file '{sourceFilePath}': '{e.Message}'", LogMessageSeverity.Error); 479debuggingSession.SessionLog.Write($"Unable to determine default defaultEncoding for '{document.FilePath}': {e.Message}"); 522log.Write($"Source '{sourceFilePath}' doesn't match output PDB: error reading symbols: {e.Message}", LogMessageSeverity.Error);

EditAndContinue\DebuggingSession.cs (3)

297return (Mvid: Guid.Empty, Error: Diagnostic.Create(descriptor, Location.None, [outputs.AssemblyDisplayPath, e.Message])); 424SessionLog.Write($"Failed to create baseline for '{projectId.DebugName}': {e.Message}", LogMessageSeverity.Error); 427diagnostics.Add(Diagnostic.Create(descriptor, Location.None, [fileBeingRead, e.Message]));

EditAndContinue\EditAndContinueDebugInfoReader.cs (3)

85throw new InvalidDataException(e.Message, e); 107throw new InvalidDataException(e.Message, e); 191throw new NotSupportedException($"Encoding '{encodingName}' not supported: {e.Message}");

EditAndContinue\Remote\RemoteDebuggingSessionProxy.cs (1)

81return EmitSolutionUpdateResults.Data.CreateFromInternalError(solution, e.Message, runningProjects);

EditAndContinue\Remote\RemoteEditAndContinueServiceProxy.cs (1)

88return new ManagedHotReloadAvailability(ManagedHotReloadAvailabilityStatus.InternalError, e.Message);

EditAndContinue\TraceLog.cs (1)

158=> AppendInMemory($"Error writing log file '{path}': {e.Message}");

Emit\CompilationOutputFilesWithImplicitPdbPath.cs (1)

97throw new IOException(e.Message, e);

PdbSourceDocument\PdbSourceDocumentLoaderService.cs (1)

103_logger?.Log(FeaturesResources._0_found_in_embedded_PDB_but_could_not_write_file_1, sourceDocument.FilePath, ex.Message);

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (1)

69Debug.Fail(ex.Message);

src\Compilers\Core\AnalyzerDriver\AnalyzerExceptionDescriptionBuilder.cs (1)

42return string.Join(s_separator, exception.Message, fusionLog);

Microsoft.CodeAnalysis.Features.UnitTests (1)

EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (1)

1040expectedErrorMessage = e.Message;

Microsoft.CodeAnalysis.InteractiveHost (16)

Interactive\Core\InteractiveHost.LazyRemoteService.cs (1)

165e.Message);

Interactive\Core\InteractiveHost.RemoteService.cs (2)

175Debug.WriteLine("InteractiveHostProcess: exception while reading output from process {0}: {1}", _processId, e.Message); 290Debug.WriteLine("InteractiveHostProcess: can't terminate process {0}: {1}", processId, e.Message);

Interactive\Core\InteractiveHost.Service.cs (2)

395Console.Error.WriteLine(e.InnerException.Message); 717Console.Error.WriteLine(e.Message);

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.LanguageServer (1)

Logging\RoslynLogger.cs (1)

217return exception.Message;

Microsoft.CodeAnalysis.LanguageServer.Protocol (1)

src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\RequestExecutionQueue.cs (1)

293var message = $"Error occurred processing queue: {ex.Message}.";

Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (11)

HandlerTests.cs (10)

158if (exception.Message == nameof(HandlerTests) || exception.InnerException?.Message == nameof(HandlerTests)) 186if (exception.Message == nameof(HandlerTests) || exception.InnerException?.Message == nameof(HandlerTests)) 214if (exception.Message == nameof(HandlerTests) || exception.InnerException?.Message == nameof(HandlerTests)) 244if (exception.Message == nameof(HandlerTests) || exception.InnerException?.Message == nameof(HandlerTests)) 272if (exception.Message == nameof(HandlerTests) || exception.InnerException?.Message == nameof(HandlerTests))

LanguageServerTargetTests.cs (1)

118Assert.Equal("'initialized' has not been called.", ex.Message);

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (12)

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.PooledObjects.Package (2)

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.PublicApiAnalyzers (13)

DeclarePublicApiAnalyzer.Impl.cs (1)

493Debug.Assert(false, ex.Message);

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.Remote.ServiceHub (2)

Host\RemoteExportProviderBuilder.cs (1)

87_errorMessages.AppendLine($"{message}: {exception.Message}");

Services\EditAndContinue\RemoteEditAndContinueService.cs (1)

154return EmitSolutionUpdateResults.Data.CreateFromInternalError(solution, e.Message, runningProjects);

Microsoft.CodeAnalysis.Remote.Workspaces (7)

BrokeredServiceConnection.cs (1)

383message = string.Format(RemoteWorkspacesResources.Feature_0_is_currently_unavailable_due_to_an_intermittent_error, featureName, exception.Message);

EditAndContinue\ManagedHotReloadLanguageService.cs (1)

262results = EmitSolutionUpdateResults.Data.CreateFromInternalError(solution, e.Message, runningProjectOptions);

Serialization\MessagePackFormatters.cs (4)

100throw new MessagePackSerializationException(e.Message, e); 126throw new MessagePackSerializationException(e.Message, e); 175throw new MessagePackSerializationException(e.Message, e); 205throw new MessagePackSerializationException(e.Message, e);

ServiceHubRemoteHostClient.cs (1)

88errorMessage = $"Unable to find Roslyn ServiceHub process: {e.Message}";

Microsoft.CodeAnalysis.ResxSourceGenerator (12)

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.Scripting (4)

Hosting\AssemblyLoader\MetadataShadowCopyProvider.cs (2)

82throw new ArgumentException(e.Message, nameof(directory)); 98throw new ArgumentException(e.Message, nameof(noShadowCopyDirectories));

Hosting\CommandLine\CommandLineRunner.cs (1)

350Console.Error.WriteLine(e.InnerException.Message);

Hosting\ObjectFormatter\CommonObjectFormatter.cs (1)

73builder.Append(e.Message);

Microsoft.CodeAnalysis.Scripting.TestUtilities (1)

ScriptingTestHelpers.cs (1)

85e.Diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error && e.Message == d.ToString());

Microsoft.CodeAnalysis.Test.Utilities (5)

Assert\AssertEx.cs (1)

998.AppendLine(ex.Message);

CompilationVerifier.cs (3)

224pePath = $"<unable to write file: '{pePath}' -- {e.Message}>"; 242pdbPath = $"<unable to write file: '{pdbPath}' -- {e.Message}>"; 510return (false, e.Message);

TempFiles\DisposableFile.cs (1)

48{1}: {2}", Path, ex.GetType().Name, ex.Message), ex);

Microsoft.CodeAnalysis.Threading.Package (2)

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.UnitTests (16)

AnalyzerAssemblyLoaderTests.cs (4)

245analyzerMainReference.AnalyzerLoadFailed += (_, e) => AssertEx.Fail(e.Exception!.Message); 247analyzerDependencyReference.AnalyzerLoadFailed += (_, e) => AssertEx.Fail(e.Exception!.Message); 761analyzerMainReference.AnalyzerLoadFailed += (_, e) => AssertEx.Fail(e.Exception!.Message); 763analyzerDependencyReference.AnalyzerLoadFailed += (_, e) => AssertEx.Fail(e.Exception!.Message);

Collections\ImmutableSegmentedDictionaryTest.cs (1)

300Assert.Contains(missingKey, exception.Message);

CommonCommandLineParserTests.cs (2)

74Assert.Equal(messageFormatter(), e.Message); 994Assert.Contains(string.Format(CodeAnalysisResources.InvalidRuleSetInclude, newFile.Path, string.Format(CodeAnalysisResources.RuleSetBadAttributeValue, "Action", "Default")), e.Message, StringComparison.Ordinal);

Diagnostics\SuppressMessageAttributeCompilerTests.cs (5)

106exception.Message, 118exception.Message, 130exception.Message, 165exception.Message, 168string.Format(CodeAnalysisResources.CompilerAnalyzerThrows, AnalyzerName, exception.GetType().ToString(), exception.Message, exception.ToString() + Environment.NewLine + "-----"))}")

Emit\CustomDebugInfoTests.cs (4)

155Assert.Equal("Invalid data at offset 3: 01-68-FF*", e.Message); 158Assert.Equal("Invalid data at offset 3: 01-68-FF*FF-FF-FF", e.Message); 161Assert.Equal("Invalid data at offset 1: FF*FF-FF-FF", e.Message); 189"00-00-00-00-00-00-00-00-00-00-00...", e.Message);

Microsoft.CodeAnalysis.VisualBasic (1)

Compilation\DocumentationComments\DocumentationCommentCompiler.Includes.vb (1)

503commentMessage = GenerateDiagnostic(True, location, ERRID.WRN_XMLDocBadFormedXML, filePathValue, xpathValue, e.Message)

Microsoft.CodeAnalysis.Workspaces (20)

Log\WorkspaceErrorLogger.cs (1)

25=> exception.Message + Environment.NewLine + exception.StackTrace;

src\Compilers\Core\Portable\DiagnosticAnalyzer\AnalyzerAssemblyLoader.cs (1)

238throw new InvalidOperationException($"Unable to load {assemblyName.Name}: {ex.Message}", ex);

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Storage\SQLite\v2\SQLitePersistentStorage.cs (1)

180d["Message"] = exception.Message;

Workspace\CommandLineProject.cs (1)

96throw new ArgumentException(string.Format(WorkspacesResources.An_error_occurred_while_reading_the_specified_configuration_file_colon_0, e.Message));

Workspace\Solution\TextLoader.cs (4)

112return CreateFailedText(e.Message); 119return CreateFailedText(e.Message); 141return CreateFailedText(e.Message); 148return CreateFailedText(e.Message);

Microsoft.CodeAnalysis.Workspaces.MSBuild (6)

MSBuild\MSBuildWorkspace.cs (6)

360Reporter.Report(new ProjectDiagnostic(WorkspaceDiagnosticKind.Failure, exception.Message, projectChanges.ProjectId)); 377Reporter.Report(new ProjectDiagnostic(WorkspaceDiagnosticKind.Failure, exception.Message, projectChanges.ProjectId)); 507Reporter.Report(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, exception.Message, id)); 535Reporter.Report(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, exception.Message, documentId)); 539Reporter.Report(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, exception.Message, documentId)); 543Reporter.Report(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, exception.Message, documentId));

Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (14)

MSBuild\Logging\DiagnosticLog.cs (1)

32=> _items.Add(new DiagnosticLogItem(kind, exception.Message, projectFilePath));

Rpc\RpcServer.cs (1)

165response = new Response { Id = request.Id, Exception = $"An exception of type {e.GetType()} was thrown: {e.Message}" };

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Compilers\Core\Portable\InternalUtilities\XmlUtilities.cs (2)

82errorMessage = e.Message; 87errorMessage = e.Message;

Microsoft.CodeAnalysis.Workspaces.MSBuild.Contracts (2)

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (6)

NewlyCreatedProjectsFromDotNetNew.cs (2)

204catch (InvalidOperationException ex) when (ex.Message.Contains("command: dotnet workload restore")) 206throw new InvalidOperationException($"The '{templateName}' template requires additional dotnet workloads to be installed. It should be excluded during template discovery. " + ex.Message);

RpcTests.cs (1)

205Assert.Contains("Exception thrown by test method!", exception.Message);

src\Workspaces\MSBuild\BuildHost\Rpc\RpcServer.cs (1)

165response = new Response { Id = request.Id, Exception = $"An exception of type {e.GetType()} was thrown: {e.Message}" };

VisualStudioMSBuildWorkspaceTests.cs (2)

869Assert.Equal(expected, e.Message); 1153Assert.Equal(expected, e.Message);

Microsoft.CodeAnalysis.Workspaces.Test.Utilities (1)

TestErrorReportingService.cs (1)

29=> OnError(exception.Message);

Microsoft.CodeAnalysis.Workspaces.UnitTests (11)

SolutionTests\SolutionTests.cs (3)

334Assert.Contains("MyTestDocument.cs", exception.Message); 4738Assert.Equal(expected, ex.Message); 4752Assert.Equal(expected, ex.Message);

SolutionTests\TryApplyChangesTests.cs (2)

109Assert.Equal(WorkspacesResources.Changing_compilation_options_is_not_supported, exception.Message); 157Assert.Equal(WorkspacesResources.Changing_parse_options_is_not_supported, exception.Message);

WorkspaceTests\WorkspaceTests.cs (6)

30Assert.Throws<NotSupportedException>(() => ws.TryApplyChanges(changedDoc.Project.Solution)).Message); 46Assert.Throws<NotSupportedException>(() => ws.TryApplyChanges(changedDoc.Project.Solution)).Message); 64Assert.Throws<NotSupportedException>(() => ws.TryApplyChanges(changedDoc.Project.Solution)).Message); 81Assert.Throws<NotSupportedException>(() => ws.TryApplyChanges(changedDoc.Project.Solution)).Message); 97Assert.Throws<NotSupportedException>(() => ws.TryApplyChanges(changedDoc.Project.Solution)).Message); 109Assert.Throws<NotSupportedException>(() => ws.TryApplyChanges(newSolution)).Message);

Microsoft.CommonLanguageServerProtocol.Framework.Example (2)

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CommonLanguageServerProtocol.Framework.Package (3)

RequestExecutionQueue.cs (1)

293var message = $"Error occurred processing queue: {ex.Message}.";

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.CommonLanguageServerProtocol.Framework.UnitTests (1)

ExampleTests.cs (1)

24Assert.Equal("Method textDocument/didOpen was implemented more than once.", ex.Message);

Microsoft.CSharp (1)

Microsoft\CSharp\RuntimeBinder\BinderHelper.cs (1)

139Expression.Constant(e.Message)

Microsoft.DotNet.Arcade.Sdk (4)

src\CheckRequiredDotNetVersion.cs (2)

52Log.LogError($"Error accessing file '{globalJsonPath}': {e.Message}"); 77Log.LogError($"Error reading file '{globalJsonPath}': {e.Message}");

src\DownloadFile.cs (2)

213Log.LogMessage($"Failed to download '{uri}' to '{DestinationPath}': {e.Message}"); 218Log.LogMessage($"Retrying download of '{uri}' to '{DestinationPath}' due to failure: '{e.Message}' ({attempt}/{Retries})");

Microsoft.DotNet.ArcadeAzureIntegration (1)

AzureCliCredentialWithAzNoUpdateWrapper.cs (1)

109Console.WriteLine($"Warning - Disable auto update of Azure CLI failed: {e.Message}");

Microsoft.DotNet.Baselines.Tasks (2)

PRCreator.cs (2)

406_logger.LogWarning($"Failed to merge the target branch into the existing pull request: {e.Message}"); 531_logger.LogWarning($"Attempt {attempt} failed: {ex.Message}. Retrying in {delayMilliseconds}ms...");

Microsoft.DotNet.Build.Tasks.Feed (6)

src\AzureStorageAssetPublisher.cs (1)

62_log.LogError($"Unexpected exception publishing file {file} to {blobClient.Uri}: {e.Message}");

src\common\AzureStorageUtils.cs (1)

295if (e.Message.Contains("404 (Not Found)"))

src\common\GeneralUtils.cs (1)

171log.LogMessage(MessageImportance.Low, $"Unexpected exception {e.Message} when attempting to determine whether feed is internal.");

src\common\NativeMethods.cs (1)

25errorMessage = hardLinkCreated ? null : Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()).Message;

src\PublishArtifactsInManifestBase.cs (2)

1848Log.LogWarning(ex.Message); 1873Log.LogMessage(MessageImportance.Low, $"Unable to delete the directory because of {ex.Message} after {attempts} attempts.");

Microsoft.DotNet.Build.Tasks.Installers (2)

src\CreateWixBuildWixpack.cs (2)

223Log.LogError($"Error ingesting variables from include file {file}: {ex.Message}"); 626Log.LogError($"Error processing {copiedXmlPath}: {ex.Message}");

Microsoft.DotNet.Build.Tasks.VisualStudio (5)

OptProf\FindLatestDrop.cs (1)

45Log.LogError($"Error parsing file '{DropListPath}': {e.Message}");

OptProf\GenerateTrainingInputFiles.cs (1)

54Log.LogError($"Unable to open the config file '{ConfigurationFile}': {e.Message}");

OptProf\GetRunSettingsSessionConfiguration.cs (3)

70Log.LogError(e.Message); 92$"Unable to read bootstrapper info: {e.Message}{Environment.NewLine}" + 118throw new ApplicationException($"Unable to read config file '{configPath}': {e.Message}");

Microsoft.DotNet.Build.Tasks.Workloads.Tests (1)

SwixPackageTests.cs (1)

35Assert.Equal(@"Relative package path exceeds the maximum length (182): Microsoft.NET.Workload.Mono.ToolChain.Manifest-6.0.100,version=6.0.0.0,chip=x64,productarch=neutral,machinearch=x64\Microsoft.NET.Workload.Mono.ToolChain.Manifest-6.0.100.6.0.0-preview.7.21377.12-x64.msi.", e.Message);

Microsoft.DotNet.Deployment.Tasks.Links (3)

src\AkaMSLinksManager.cs (3)

131_log.LogMessage(MessageImportance.High, $"Failed to delete aka.ms/{link}: {e.Message}"); 237_log.LogMessage(MessageImportance.High, $"Failed to check aka.ms/{link.ShortUrl}: {e.Message}"); 344_log.LogMessage(MessageImportance.High, $"Failed to create/update aka.ms links: {e.Message}");

Microsoft.DotNet.Helix.Client (1)

HelixApi.cs (1)

25exception is RestApiException jobListEx && jobListEx.Response.Status == 400 && jobListEx.Message.Contains("Provided Job List Uri is not accessible");

Microsoft.DotNet.Helix.Sdk (5)

DownloadFromResultsContainer.cs (1)

124Log.LogWarning($"Failed to download file '{file}' from results container for work item '{workItemName}': {rfe.Message}");

FindDotNetCliPackage.cs (4)

146Log.LogMessage($"Unable to access dotnet cli {PackageType} version {Version} from feed {feed}, {SanitizeString(ex.Message)}"); 188Log.LogWarning($"Unable to resolve download link from feed {feed}; {SanitizeString(ex.Message)}"); 273Log.LogMessage(MessageImportance.Low, $"Hit exception in GetAsync(); will retry up to 10 times ({SanitizeString(toLog.Message)})"); 297Log.LogMessage(MessageImportance.Low, $"Hit exception in SendAsync(); will retry up to 10 times ({SanitizeString(toLog.Message)})");

Microsoft.DotNet.Internal.SymbolHelper (3)

SymbolPromotionHelper.cs (1)

67logger?.Information("Try {0} failed with '{1}', delaying {2}", args.AttemptNumber + 1, httpException.Message, args.RetryDelay);

SymbolUploadHelper.cs (1)

391logWarning($"Conversion error: {ex.Message}");

SymbolUploadHelperFactory.cs (1)

126logger.Information("Try {0} failed with '{1}', delaying {2}", args.AttemptNumber + 1, httpException.Message, args.RetryDelay);

Microsoft.DotNet.NuGetRepack.Tasks (1)

src\ReplacePackageParts.cs (1)

185Log.LogError($"Failed to open replacement file '{replacementFilePath}': {e.Message}");

Microsoft.DotNet.NuGetRepack.Tests (1)

VersionUpdaterTests.cs (1)

139AssertEx.AreEqual("Package 'TestPackageC' depends on a pre-release package 'TestPackageB, [1.0.0-beta-12345-01]'", e1.Message);

Microsoft.DotNet.Open.Api.Tools.Tests (2)

src\Shared\Process\ProcessExtensions.cs (2)

73catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory")) 89catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory"))

Microsoft.DotNet.RemoteExecutor (1)

RemoteInvokeHandle.cs (1)

163description.AppendLine($"Failed to create mini dump: {exc.Message}");

Microsoft.DotNet.SignCheckLibrary (6)

Verification\AuthentiCode.cs (1)

56svr.AddDetail(DetailKeys.Error, ex.Message);

Verification\Jar\JarSignatureFile.cs (2)

225JarError.AddError(ce.Message); 291JarError.AddError(ce.Message);

Verification\JarVerifier.cs (1)

57svr.AddDetail(DetailKeys.Error, e.Message);

Verification\MsiVerifier.cs (2)

62Log.WriteError(e.Message); 94Log.WriteError(e.Message);

Microsoft.DotNet.SignCheckTask (1)

src\SignCheck.cs (1)

509Log.WriteError(e.Message);

Microsoft.DotNet.SignTool (2)

src\BatchSignUtil.cs (1)

466_log.LogError($"Updating '{dst}' with signed content failed: '{e.Message}'");

src\ZipData.cs (1)

563log.LogError(e.Message);

Microsoft.DotNet.VersionTools.Cli (2)

VersionTrimmingOperation.cs (2)

60_context.Logger.WriteError($"Asset {assetFileName} in not a valid nuget package: {e.Message}"); 75_context.Logger.WriteError($"Version trimming of {assetFileName} failed: {e.Message}");

Microsoft.DotNet.XUnitAssert.Tests (528)

AsyncCollectionAssertsTests.cs (38)

52 ex.Message 104 ex.Message 149 collEx.Message 186 ex.Message 220 collEx.Message 273 ex.Message 314 ex.Message 382 ex.Message 416 ex.Message 432 ex.Message 457 ex.Message 491 ex.Message 560 ex.Message 600 ex.Message 646 ex.Message 668 ex.Message 770 Assert.Equal(message.Replace("$$ELLIPSIS$$", ArgumentFormatter.Ellipsis), ex.Message); 801 ex.Message 882 ex.Message 934 ex.Message 974 ex.Message 1035 ex.Message 1058 ex.Message 1099 ex.Message 1148 ex.Message 1198 ex.Message 1241 ex.Message 1281 ex.Message 1339 ex.Message 1368 ex.Message 1395 Assert.Equal("Assert.Single() Failure: The collection was empty", ex.Message); 1419 ex.Message 1434 ex.Message 1459 ex.Message 1495 ex.Message 1512 ex.Message 1529 ex.Message 1555 ex.Message

BooleanAssertsTests.cs (6)

25 ex.Message 39 ex.Message 51 Assert.Equal("Custom User Message", ex.Message); 73 ex.Message 87 ex.Message 99 Assert.Equal("Custom User Message", ex.Message);

CollectionAssertsTests.cs (69)

50 ex.Message 102 ex.Message 147 collEx.Message 185 ex.Message 220 collEx.Message 273 ex.Message 314 ex.Message 376 ex.Message 416 ex.Message 450 ex.Message 466 ex.Message 491 ex.Message 525 ex.Message 558 ex.Message 576 ex.Message 638 ex.Message 678 ex.Message 719 ex.Message 736 ex.Message 804 Assert.Equal(message, ex.Message); 872 Assert.Equal(message.Replace("$$ELLIPSIS$$", ArgumentFormatter.Ellipsis), ex.Message); 887 ex.Message 1026 Assert.Equal(message.Replace("$$ELLIPSIS$$", ArgumentFormatter.Ellipsis), ex.Message); 1047 ex.Message 1116 ex.Message 1161 ex.Message 1191 ex.Message 1243 ex.Message 1282 ex.Message 1299 ex.Message 1332 ex.Message 1376 ex.Message 1406 ex.Message 1488 ex.Message 1544 ex.Message 1562 ex.Message 1579 ex.Message 1621 ex.Message 1660 ex.Message 1697 ex.Message 1713 ex.Message 1748 ex.Message 1786 ex.Message 1816 ex.Message 1850 ex.Message 1896 ex.Message 1918 ex.Message 1939 ex.Message 1956 ex.Message 2025 ex.Message 2064 ex.Message 2122 ex.Message 2175 ex.Message 2197 ex.Message 2218 ex.Message 2292 Assert.Equal("Assert.Single() Failure: The collection was empty", ex.Message); 2316 ex.Message 2331 ex.Message 2372 ex.Message 2389 ex.Message 2406 ex.Message 2427 Assert.Equal("Assert.Single() Failure: The collection was empty", ex.Message); 2451 ex.Message 2466 ex.Message 2491 ex.Message 2527 ex.Message 2544 ex.Message 2561 ex.Message 2587 ex.Message

DictionaryAssertsTests.cs (2)

50 ex.Message 102 ex.Message

EqualityAssertsTests.cs (153)

33 ex.Message 56 ex.Message 85 ex.Message 113 ex.Message 136 ex.Message 174 ex.Message 188 ex.Message 209 ex.Message 240 ex.Message 270 ex.Message 304 ex.Message 335 ex.Message 361 ex.Message 387 ex.Message 413 ex.Message 443 ex.Message 478 ex.Message 508 ex.Message 534 ex.Message 563 ex.Message 595 ex.Message 621 ex.Message 647 ex.Message 673 ex.Message 703 ex.Message 733 ex.Message 770 ex.Message 805 ex.Message 829 ex.Message 868 ex.Message 900 ex.Message 931 ex.Message 963 ex.Message 993 ex.Message 1014 ex.Message 1035 ex.Message 1049 ex.Message 1094 ex.Message 1147 ex.Message 1181 ex.Message 1211 ex.Message 1240 ex.Message 1266 ex.Message 1283 ex.Message 1300 ex.Message 1330 ex.Message 1351 ex.Message 1386 ex.Message 1425 ex.Message 1451 ex.Message 1490 ex.Message 1529 ex.Message 1557 ex.Message 1588 ex.Message 1616 ex.Message 1646 ex.Message 1676 ex.Message 1714 ex.Message 1750 ex.Message 1788 ex.Message 1799 ex2.Message 1836 ex.Message 1869 ex.Message 1907 ex.Message 1918 ex2.Message 1956 ex.Message 1967 ex2.Message 1995 ex.Message 2024 ex.Message 2051 ex.Message 2064 Assert.StartsWith("Tolerance must be greater than or equal to zero", ex.Message); 2088 ex.Message 2112 ex.Message 2136 ex.Message 2154 ex.Message 2184 ex.Message 2211 ex.Message 2224 Assert.StartsWith("Tolerance must be greater than or equal to zero", ex.Message); 2248 ex.Message 2272 ex.Message 2296 ex.Message 2314 ex.Message 2334 ex.Message 2363 ex.Message 2397 ex.Message 2420 ex.Message 2443 ex.Message 2475 ex.Message 2495 ex.Message 2516 ex.Message 2531 ex.Message 2552 ex.Message 2581 ex.Message 2616 ex.Message 2647 ex.Message 2674 ex.Message 2700 ex.Message 2726 ex.Message 2754 ex.Message 2791 ex.Message 2821 ex.Message 2847 ex.Message 2876 ex.Message 2905 ex.Message 2934 ex.Message 2960 ex.Message 2986 ex.Message 3016 ex.Message 3046 ex.Message 3081 ex.Message 3116 ex.Message 3165 ex.Message 3196 ex.Message 3224 ex.Message 3257 ex.Message 3286 ex.Message 3314 ex.Message 3365 ex.Message 3400 ex.Message 3431 ex.Message 3460 ex.Message 3486 ex.Message 3514 ex.Message 3550 ex.Message 3572 ex.Message 3611 ex.Message 3663 ex.Message 3702 ex.Message 3743 ex.Message 3760 ex.Message 3785 ex.Message 3806 ex.Message 3834 ex.Message 3865 ex.Message 3895 ex.Message 3932 ex.Message 3963 ex.Message 3992 ex.Message 4019 ex.Message 4038 Assert.StartsWith("Tolerance must be greater than or equal to zero", ex.Message); 4056 ex.Message 4080 ex.Message 4104 ex.Message 4140 ex.Message 4167 ex.Message 4186 Assert.StartsWith("Tolerance must be greater than or equal to zero", ex.Message); 4204 ex.Message 4228 ex.Message 4252 ex.Message 4282 ex.Message 4308 ex.Message 4335 ex.Message 4349 ex.Message

EquivalenceAssertsTests.cs (70)

36 ex.Message 68 ex.Message 96 ex.Message 111 ex.Message 140 ex.Message 169 ex.Message 192 ex.Message 206 ex.Message 229 ex.Message 252 ex.Message 284 ex.Message 307 ex.Message 356 ex.Message 385 ex.Message 414 ex.Message 443 ex.Message 472 ex.Message 518 ex.Message 539 ex.Message 563 ex.Message 595 ex.Message 612 ex.Message 644 ex.Message 658 ex.Message 675 ex.Message 692 ex.Message 726 ex.Message 743 ex.Message 775 ex.Message 789 ex.Message 806 ex.Message 823 ex.Message 863 ex.Message 880 ex.Message 918 ex.Message 935 ex.Message 952 ex.Message 969 ex.Message 1007 ex.Message 1024 ex.Message 1062 ex.Message 1079 ex.Message 1096 ex.Message 1113 ex.Message 1204 ex.Message 1221 ex.Message 1238 ex.Message 1255 ex.Message 1293 ex.Message 1310 ex.Message 1327 ex.Message 1344 ex.Message 1373 ex.Message 1390 ex.Message 1419 ex.Message 1436 ex.Message 1467 ex.Message 1484 ex.Message 1522 ex.Message 1555 Assert.StartsWith("Assert.Equivalent() Failure: Mismatched value on member 'FullName'" + Environment.NewLine, ex.Message); 1577 Assert.StartsWith("Assert.Equivalent() Failure: Mismatched value on member 'FullName'" + Environment.NewLine, ex.Message); 1594 ex.Message 1612 ex.Message 1641 Assert.Equal("Assert.Equivalent() Failure: Circular reference found in 'expected.Other'", ex.Message); 1653 Assert.Equal("Assert.Equivalent() Failure: Circular reference found in 'actual.Other'", ex.Message); 1670 ex.Message 1704 ex.Message 1733 ex.Message 1762 ex.Message 1810 ex.Message

EventAssertsTests.cs (16)

28 ex.Message 46 Assert.Equal("Assert.Raises() Failure: No event was raised", ex.Message); 85 ex.Message 110 ex.Message 150 ex.Message 195 ex.Message 254 ex.Message 276 ex.Message 369 ex.Message 428 ex.Message 450 ex.Message 543 ex.Message 561 Assert.Equal("Assert.Raises() Failure: No event was raised", ex.Message); 600 ex.Message 625 ex.Message 665 ex.Message

ExceptionAssertsTests.cs (36)

33 ex.Message 59 ex.Message 77 ex.Message 102 Assert.Equal("You must call Assert.ThrowsAsync when testing async code", ex.Message); 116 ex.Message 142 ex.Message 160 ex.Message 189 ex.Message 215 ex.Message 233 ex.Message 255 Assert.Equal("You must call Assert.ThrowsAsync when testing async code", ex.Message); 269 ex.Message 295 ex.Message 313 ex.Message 341 ex.Message 367 ex.Message 384 ex.Message 402 ex.Message 427 ex.Message 453 ex.Message 470 ex.Message 488 ex.Message 516 ex.Message 542 ex.Message 572 Assert.Equal("You must call Assert.ThrowsAnyAsync when testing async code", ex.Message); 586 ex.Message 612 ex.Message 646 ex.Message 672 ex.Message 705 ex.Message 731 ex.Message 749 ex.Message 774 ex.Message 800 ex.Message 817 ex.Message 835 ex.Message

FailAssertsTests.cs (2)

12 Assert.Equal("Assert.Fail() Failure", ex.Message); 21 Assert.Equal("This is a user message", ex.Message);

IdentityAssertsTests.cs (2)

17 Assert.Equal("Assert.NotSame() Failure: Values are the same instance", ex.Message); 47 ex.Message

MultipleAssertsTests.cs (1)

67 ex.Message

NullAssertsTests.cs (4)

32 Assert.Equal("Assert.NotNull() Failure: Value is null", ex.Message); 43 Assert.Equal("Assert.NotNull() Failure: Value of type 'Nullable<int>' does not have a value", ex.Message); 73 ex.Message 89 ex.Message

PropertyAssertsTests.cs (4)

27 Assert.Equal("Assert.PropertyChanged() failure: Property 'Property1' was not set", ex.Message); 38 Assert.Equal("Assert.PropertyChanged() failure: Property 'Property1' was not set", ex.Message); 80 Assert.Equal("Assert.PropertyChanged() failure: Property 'Property1' was not set", ex.Message); 93 Assert.Equal("Assert.PropertyChanged() failure: Property 'Property1' was not set", ex.Message);

RangeAssertsTests.cs (9)

24 ex.Message 44 ex.Message 58 ex.Message 78 ex.Message 111 ex.Message 134 ex.Message 154 ex.Message 174 ex.Message 191 ex.Message

SetAssertsTests.cs (12)

45 ex.Message 95 ex.Message 133 ex.Message 159 ex.Message 173 ex.Message 199 ex.Message 225 ex.Message 239 ex.Message 283 ex.Message 297 ex.Message 340 ex.Message 354 ex.Message

TypeAssertsTests.cs (16)

27 result.Message 78 result.Message 96 result.Message 147 result.Message 173 result.Message 189 result.Message 205 result.Message 236 result.Message 252 result.Message 268 result.Message 299 result.Message 331 result.Message 373 result.Message 409 result.Message 435 result.Message 471 result.Message

Microsoft.DotNet.XUnitExtensions (1)

src\Microsoft.DotNet.XUnitExtensions.Shared\Discoverers\ConditionalTestDiscoverer.cs (1)

156e.Message);

Microsoft.Extensions.AI (6)

ChatCompletion\FunctionInvokingChatClient.cs (2)

1360message = $"{message} Exception: {result.Exception.Message}"; 1454.SetStatus(ActivityStatusCode.Error, e.Message);

ChatCompletion\OpenTelemetryChatClient.cs (1)

714.SetStatus(ActivityStatusCode.Error, error.Message);

ChatCompletion\OpenTelemetryImageGenerator.cs (1)

240.SetStatus(ActivityStatusCode.Error, error.Message);

Embeddings\OpenTelemetryEmbeddingGenerator.cs (1)

237.SetStatus(ActivityStatusCode.Error, error.Message);

SpeechToText\OpenTelemetrySpeechToTextClient.cs (1)

290.SetStatus(ActivityStatusCode.Error, error.Message);

Microsoft.Extensions.AI.Abstractions (1)

Contents\FunctionResultContent.cs (1)

78$"{Exception.GetType().Name}(\"{Exception.Message}\")" :

Microsoft.Extensions.AI.Abstractions.Tests (4)

Contents\FunctionCallContentTests.cs (4)

225Assert.Contains("JsonTypeInfo metadata", ex.Message); 226Assert.Contains(nameof(CustomType), ex.Message); 229Assert.Contains("JsonTypeInfo metadata", ex.Message); 230Assert.Contains(nameof(CustomType), ex.Message);

Microsoft.Extensions.AI.OllamaSharp.Integration.Tests (3)

OllamaSharpChatClientIntegrationTests.cs (2)

101Assert.Contains("inexistent-model", ex.Message); 104Assert.Contains("inexistent-model", ex.Message);

OllamaSharpEmbeddingGeneratorIntegrationTests.cs (1)

34Assert.Contains("inexistent-model", ex.Message);

Microsoft.Extensions.AI.OpenAI.Tests (8)

OpenAIChatClientTests.cs (2)

1633Assert.StartsWith("User-Agent header: OpenAI", e.Message); 1634Assert.Contains("MEAI", e.Message);

OpenAIEmbeddingGeneratorTests.cs (2)

313Assert.StartsWith("User-Agent header: OpenAI", e.Message); 314Assert.Contains("MEAI", e.Message);

OpenAIResponseClientIntegrationTests.cs (2)

635Assert.Contains("encrypted", ex.Message, StringComparison.OrdinalIgnoreCase); 720Assert.Contains("encrypted", ex.Message, StringComparison.OrdinalIgnoreCase);

OpenAIResponseClientTests.cs (2)

3268Assert.StartsWith("User-Agent header: OpenAI", e.Message); 3269Assert.Contains("MEAI", e.Message);

Microsoft.Extensions.AI.Templates.Tests (1)

test\ProjectTemplates\Infrastructure\ProcessExtensions.cs (1)

17catch (InvalidOperationException ex) when (ex.Message.Contains("No process is associated with this object"))

Microsoft.Extensions.AI.Tests (25)

ChatCompletion\ChatClientBuilderTest.cs (1)

78Assert.Contains("entry at index 0", ex.Message);

ChatCompletion\ChatClientStructuredOutputExtensionsTests.cs (2)

268Assert.Equal("The deserialized response is null.", ex.Message); 287Assert.Equal("The response did not contain JSON to be deserialized.", ex.Message);

ChatCompletion\DistributedCachingChatClientTest.cs (4)

187Assert.Equal("some failure", ex1.Message); 195Assert.Equal("some failure", ex2.Message); 498Assert.Equal("some failure", ex1.Message); 507Assert.Equal("some failure", ex2.Message);

ChatCompletion\FunctionInvokingChatClientApprovalsTests.cs (2)

843Assert.Equal("FunctionApprovalRequestContent found with FunctionCall.CallId(s) 'callId1' that have no matching FunctionApprovalResponseContent.", invokeException.Message); 847Assert.Equal("FunctionApprovalRequestContent found with FunctionCall.CallId(s) 'callId1' that have no matching FunctionApprovalResponseContent.", invokeStreamingException.Message);

ChatCompletion\FunctionInvokingChatClientTests.cs (8)

887Assert.Equal("Exception from call 11", ex.InnerExceptions[0].Message); 888Assert.Equal("Exception from call 12", ex.InnerExceptions[1].Message); 893Assert.Equal("Exception from call 11", ex.InnerExceptions[0].Message); 894Assert.Equal("Exception from call 12", ex.InnerExceptions[1].Message); 902Assert.Equal("Exception from call 11", ex.Message); 906Assert.Equal("Exception from call 11", ex.Message); 944Assert.Equal("It failed", ex.Message); 948Assert.Equal("It failed", ex.Message);

ChatCompletion\ReducingChatClientTests.cs (1)

135Assert.Contains("IChatReducer", exception.Message);

Embeddings\DistributedCachingEmbeddingGeneratorTest.cs (2)

192Assert.Equal("some failure", ex1.Message); 200Assert.Equal("some failure", ex2.Message);

Embeddings\EmbeddingGeneratorBuilderTests.cs (1)

78Assert.Contains("entry at index 0", ex.Message);

Functions\AIFunctionFactoryTest.cs (3)

123Assert.Contains("'theParam'", e.Message); 688Assert.Contains("Unable to resolve", e.Message); 695Assert.Contains("Unable to resolve", e.Message);

Image\ImageGeneratorBuilderTests.cs (1)

78Assert.Contains("entry at index 0", ex.Message);

Microsoft.Extensions.ApiDescription.Client.Tests (2)

src\Shared\Process\ProcessExtensions.cs (2)

73catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory")) 89catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory"))

Microsoft.Extensions.Caching.Hybrid (1)

Internal\DefaultHybridCache.L2.cs (1)

172Debug.WriteLine(ex.Message);

Microsoft.Extensions.Caching.Hybrid.Tests (2)

LogCollector.cs (1)

28var errSuffix = logItem.exception is null ? "" : $" - {logItem.exception.Message}";

SqlServerTests.cs (1)

47Log.WriteLine(ex.Message);

Microsoft.Extensions.Caching.SqlServer.Tests (1)

SqlServerCacheWithDatabaseTest.cs (1)

88Assert.Equal("The absolute expiration value must be in the future.", exception.Message);

Microsoft.Extensions.Compliance.Testing (1)

FakeRedactorOptionsCustomValidator.cs (1)

25$"{nameof(options.RedactionFormat)} must be a valid .NET format string taking 0 or 1 arguments: {ex.Message}",

Microsoft.Extensions.DataIngestion (1)

IngestionPipeline.cs (1)

125.SetStatus(ActivityStatusCode.Error, ex.Message);

Microsoft.Extensions.DataIngestion.Tests (1)

Readers\DocumentReaderConformanceTests.cs (1)

175throw new SkipTestException($"Unable to download the test file: '{ex.Message}'");

Microsoft.Extensions.DependencyInjection (1)

ServiceProvider.cs (1)

253throw new InvalidOperationException($"Error while validating the service descriptor '{descriptor}': {e.Message}", e);

Microsoft.Extensions.Diagnostics.HealthChecks (1)

DefaultHealthCheckService.cs (1)

141description: ex.Message,

Microsoft.Extensions.Diagnostics.HealthChecks.Tests (4)

DefaultHealthCheckServiceTest.cs (4)

144Assert.Equal(ExceptionMessage, actual.Value.Exception!.Message); 153Assert.Equal(OperationCancelledMessage, actual.Value.Exception!.Message); 296Assert.Equal(thrownException.Message, actual.Value.Description); 303Assert.Equal(faultedException.Message, actual.Value.Description);

Microsoft.Extensions.Diagnostics.Probes.Tests (1)

KubernetesProbesOptionsValidatorTests.cs (1)

92Assert.Fail("Unexpected exception: " + ex.Message);

Microsoft.Extensions.Diagnostics.ResourceMonitoring (4)

Linux\Disk\LinuxSystemDiskMetrics.cs (2)

178_logger.HandleDiskStatsException(ex.Message); 184_logger.HandleDiskStatsException(ex.Message);

Windows\Disk\WindowsDiskMetrics.cs (2)

101_logger.DiskIoPerfCounterException(WindowsDiskPerfCounterNames.DiskIdleTimeCounter, ex.Message); 127_logger.DiskIoPerfCounterException(counterName, ex.Message);

Microsoft.Extensions.Features.Tests (1)

FeatureCollectionTests.cs (1)

56Assert.Equal("System.Int32 does not exist in the feature collection and because it is a struct the method can't return null. Use 'featureCollection[typeof(System.Int32)] is not null' to check if the feature exists.", ex.Message);

Microsoft.Extensions.Hosting (1)

Internal\HostingLoggerExtensions.cs (1)

21message = message + Environment.NewLine + ex.Message;

Microsoft.Extensions.Hosting.Testing.Tests (1)

HostingFakesExtensionsTests.cs (1)

55Assert.Equal("No fake log collector registered", exception.Message);

Microsoft.Extensions.Http.Polly.Tests (1)

PolicyHttpMessageHandlerTest.cs (1)

222exception.Message);

Microsoft.Extensions.Http.Resilience.Tests (3)

Hedging\HedgingTests.cs (2)

153Assert.Equal("The routing strategy did not provide any route URL on the first attempt.", exception.Message); 175Assert.Equal("Something went wrong!", exception.Message);

Resilience\RequestMessageSnapshotTests.cs (1)

29Assert.Equal("StreamContent content cannot by cloned.", exception.Message);

Microsoft.Extensions.Localization.Tests (1)

ResourceManagerStringLocalizerTest.cs (1)

208Assert.Equal(expected, exception.Message);

Microsoft.Extensions.Logging.EventLog (1)

WindowsEventLog.cs (1)

59$"Unable to log .NET application events. {sx.Message}");

Microsoft.Extensions.Logging.EventSource (1)

ExceptionInfo.cs (1)

23Message = exception.Message;

Microsoft.Extensions.ServiceDiscovery.Tests (4)

ServiceEndpointResolverTests.cs (4)

30Assert.Equal("No provider which supports the provided service name, 'https://basket', has been configured.", exception.Message); 41Assert.Equal("No service endpoint providers are configured.", exception.Message); 43Assert.Equal("No service endpoint providers are configured.", exception.Message); 64Assert.Equal("No provider which supports the provided service name, 'http://foo', has been configured.", exception.Message);

Microsoft.Extensions.Telemetry (3)

Logging\ExtendedLogger.cs (2)

146tags.Add(ExceptionMessage, exception.Message); 196_ = sb.AppendLine(exception.Message);

src\Shared\LogBuffering\SerializedLogRecordFactory.cs (1)

46exceptionMessage = exception.Message;

Microsoft.Extensions.Telemetry.Tests (2)

Http\HttpParserTests.cs (1)

66Assert.Equal(TelemetryCommonExtensions.UnsupportedEnumValueExceptionMessage, ex.Message);

Http\HttpRouteFormatterTests.cs (1)

146Assert.Equal(TelemetryCommonExtensions.UnsupportedEnumValueExceptionMessage, ex.Message);

Microsoft.Extensions.Validation (2)

ValidatableParameterInfo.cs (1)

101context.AddValidationError(Name, key, [ex.Message], null);

ValidatablePropertyInfo.cs (1)

170context.AddOrExtendValidationErrors(name, key, [ex.Message], container);

Microsoft.Extensions.Validation.Tests (2)

RuntimeValidatableParameterInfoResolverTests.cs (1)

32Assert.Contains("without a name", exception.Message);

ValidatableTypeInfoTests.cs (1)

375Assert.Equal("Maximum validation depth of 3 exceeded at 'Children[0].Parent.Children[0]' in 'TreeNode'. This is likely caused by a circular reference in the object graph. Consider increasing the MaxDepth in ValidationOptions if deeper validation is required.", exception.Message);

Microsoft.Gen.Logging.Generated.Tests (8)

LogMethodTests.cs (8)

Microsoft.Gen.MetadataExtractor (1)

src\Generators\Microsoft.Gen.MetricsReports\MetricDefinitionEmitter.cs (1)

143throw new InvalidOperationException($"An exception occurred during metric report generation {e.GetType()}:{e.Message}.");

Microsoft.Gen.MetricsReports (1)

MetricDefinitionEmitter.cs (1)

143throw new InvalidOperationException($"An exception occurred during metric report generation {e.GetType()}:{e.Message}.");

Microsoft.JSInterop (1)

JSRuntime.cs (1)

305var message = $"An exception occurred executing JS interop: {exception.Message}. See InnerException for more details.";

Microsoft.JSInterop.Tests (8)

DotNetObjectReferenceTest.cs (1)

60Assert.Equal(expected, ex.Message);

Infrastructure\DotNetDispatcherTest.cs (4)

172Assert.Equal($"In call to '{method}', parameter of type '{nameof(TestDTO)}' at index 3 must be declared as type 'DotNetObjectRef<TestDTO>' to receive the incoming value.", ex.Message); 298Assert.Equal(expected, ex.Message); 314Assert.Empty(ex.Message); 871Assert.Equal($"In call to '{method}', parameter of type '{nameof(TestDTO)}' at index 2 must be declared as type 'DotNetObjectRef<TestDTO>' to receive the incoming value.", ex.Message);

Infrastructure\DotNetStreamReferenceJsonConverterTest.cs (1)

27Assert.StartsWith("DotNetStreamReference cannot be supplied from JavaScript to .NET because the stream contents have already been transferred.", ex.Message);

JSRuntimeTest.cs (2)

203Assert.Equal("This is a test exception", jsException.Message); 424Assert.Equal("The current JavaScript runtime does not support reading data streams.", exception.Message);

Microsoft.JSInterop.WebAssembly (1)

WebAssemblyJSRuntime.cs (1)

54throw new JSException(ex.Message, ex);

Microsoft.Maui (2)

Handlers\HybridWebView\HybridWebViewHandler.cs (2)

152 var ex = new HybridWebViewInvokeJavaScriptException($"InvokeJavaScript threw an exception: {jsException.Message}", jsException); 199 MauiContext?.CreateLogger<HybridWebViewHandler>()?.LogError(ex, "An error occurred while invoking a .NET method from JavaScript: {ErrorMessage}", ex.Message);

Microsoft.Maui.Controls (3)

Xaml\TypeConversionExtensions.cs (1)

159 exception = e as XamlParseException ?? new XamlParseException($"Type converter failed: {e.Message}", serviceProvider, e);

Xaml\ValueConverterProvider.cs (1)

19 throw new XamlParseException(exception.Message, serviceProvider, exception);

XamlParseException.cs (1)

54 internal string UnformattedMessage => _unformattedMessage ?? Message;

Microsoft.Maui.Controls.Build.Tasks (2)

XamlCTask.cs (2)

317 LoggingHelper.LogError("XamlC", null, xpe.HelpLink, xamlFilePath, xpe.XmlInfo.LineNumber, xpe.XmlInfo.LinePosition, 0, 0, xpe.Message); 321 LoggingHelper.LogError("XamlC", null, e.HelpLink, xamlFilePath, 0, 0, 0, 0, e.Message);

Microsoft.Maui.Controls.SourceGen (2)

CodeBehindGenerator.cs (1)

272 context.ReportDiagnostic(Diagnostic.Create(Descriptors.XamlParserError, location, xamlItem.Exception.Message));

src\Controls\src\Core\XamlParseException.cs (1)

54 internal string UnformattedMessage => _unformattedMessage ?? Message;

Microsoft.Maui.Graphics.Text.Markdig (1)

Renderer\SimpleCssParser.cs (1)

31 System.Diagnostics.Debug.WriteLine(exc.Message);

Microsoft.Maui.Resizetizer (1)

AsyncTask.cs (1)

69 LogError(ex.Message + Environment.NewLine + ex.StackTrace);

Microsoft.McpServer.ProjectTemplates.Tests (1)

test\ProjectTemplates\Infrastructure\ProcessExtensions.cs (1)

17catch (InvalidOperationException ex) when (ex.Message.Contains("No process is associated with this object"))

Microsoft.ML.AutoML (8)

API\BinaryClassificationExperiment.cs (1)

462throw new OperationCanceledException(ex.Message, ex.InnerException);

API\MulticlassClassificationExperiment.cs (1)

440throw new OperationCanceledException(ex.Message, ex.InnerException);

API\RegressionExperiment.cs (1)

455throw new OperationCanceledException(ex.Message, ex.InnerException);

AutoMLExperiment\AutoMLExperiment.cs (1)

301Exception Details: {ex.Message}

AutoMLExperiment\IMonitor.cs (1)

61_logger.Trace(exception.Message + exception.StackTrace);

AutoMLExperiment\Runner\SweepablePipelineRunner.cs (1)

108throw new OperationCanceledException(ex.Message, ex.InnerException);

Experiment\Experiment.cs (2)

199_logger.Warning(_operationCancelledMessage, e.Message); 211_logger.Warning(_operationCancelledMessage, e.Message);

Microsoft.ML.AutoML.Tests (3)

AutoFitTests.cs (3)

664var containsMessage = lastException.Message.Contains(expectedExceptionMessage); 674if (!ex.Message.Contains(expectedExceptionMessage)) 684$"Obtained unexpected error of type {lastException.GetType()} with message: {lastException.Message}");

Microsoft.ML.Core (16)

CommandLine\CmdParser.cs (2)

987Report("Error: Can't open command line argument file '{0}' : '{1}'", fileName, e.Message); 1058Console.WriteLine("Error: Can't open command line argument file '{0}' : '{1}'", path, e.Message);

ComponentModel\AssemblyLoadingUtils.cs (1)

57Console.Error.WriteLine("Warning: Could not load '{0}': {1}", path, ex.Message);

ComponentModel\ComponentCatalog.cs (1)

1068throw Contracts.Except(e, "Unexpected exception thrown while parsing: " + e.Message);

Utilities\Contracts.cs (1)

74Contracts.Assert(false, "Format string arg mismatch: " + ex.Message);

Utilities\PathUtils.cs (1)

143throw Contracts.ExceptParam(nameof(folder), $"Failed to create folder for the provided path: {folder}. \nException: {exc.Message}");

Utilities\ResourceManagerUtils.cs (7)

145downloadResult += $"DownloadFailed with exception {ex.Message}" + @"\n"; 147ch.Warning($"{i + 1} - th try: Dowload {fileName} from {url} fail with exception {ex.Message}"); 171return (await t).Message; 186ch.Warning($"File '{filePath}' could not be deleted: {e.Message}"); 223error = $"Error trying to create directory {appDataBaseDir}: {e.Message}.\nPlease fix your " + 242error = $"Error trying to create directory {absDir}: {e.Message}.\nPlease try setting the " + 296ch.Error($"{fileName}: Could not download. HttpClient returned the following error: {e.Message}");

Utilities\Stream.cs (3)

855throw Contracts.ExceptUserArg(userArgument, exc.Message); 859throw Contracts.ExceptUserArg(userArgument, exc.Message); 863throw Contracts.ExceptUserArg(userArgument, exc.Message);

Microsoft.ML.Core.Tests (7)

UnitTests\DataTypes.cs (7)

96Assert.Equal("Value could not be parsed from text to sbyte.", ex.Message); 102Assert.Equal("Value could not be parsed from text to sbyte.", ex.Message); 136Assert.Equal("Value could not be parsed from text to short.", ex.Message); 142Assert.Equal("Value could not be parsed from text to short.", ex.Message); 176Assert.Equal("Value could not be parsed from text to int.", ex.Message); 182Assert.Equal("Value could not be parsed from text to int.", ex.Message); 222Assert.Equal("Value could not be parsed from text to long.", ex.Message);

Microsoft.ML.CpuMath (1)

src\Microsoft.ML.Core\Utilities\Contracts.cs (1)

74Contracts.Assert(false, "Format string arg mismatch: " + ex.Message);

Microsoft.ML.Data (4)

DataLoadSave\MultiFileSource.cs (1)

87throw Contracts.ExceptIO(e, "Could not open file '{0}'. Error is: {1}", path, e.Message);

DataLoadSave\Text\TextLoaderCursor.cs (1)

840"Parsing failed with an exception: {0}", state.ParsingException.Message);

Dirty\PredictionUtils.cs (1)

44errorMsg = "Unexpected exception thrown while parsing: " + e.Message;

Transforms\KeyToVector.cs (1)

267var errorMsg = e.Message + " Related column: ";

Microsoft.ML.DataView (1)

Contracts.cs (1)

26Debug.Fail("Format string arg mismatch: " + ex.Message);

Microsoft.ML.Ensemble (1)

Trainer\EnsembleTrainerBase.cs (1)

170index + 1, Trainers.Length, ex.Message);

Microsoft.ML.EntryPoints (1)

JsonUtils\ExecuteGraphCommand.cs (1)

58throw _host.Except(ex, "Failed to parse experiment graph: {0}", ex.Message);

Microsoft.ML.FastTree (1)

FastTreeRanking.cs (1)

165throw Host.Except(ex, "Error in the format of custom gains. Inner exception is {0}", ex.Message);

Microsoft.ML.Maml (3)

MAML.cs (3)

169ch.Error(e.Sensitivity(), e.Message); 248writer.WriteLine("({0}) Unexpected exception: {1}, '{2}'", index, e.Message, e.GetType()); 266ch.Error(e.Sensitivity(), "({0}) Unexpected exception: {1}, '{2}'", index, e.Message, e.GetType());

Microsoft.ML.Parquet (4)

ParquetLoader.cs (1)

737_ch.Error("Cannot convert BigInteger to RowId. Exception : '{0}'", ex.Message);

PartitionedFileLoader.cs (3)

478Ch.Warning($"Failed to load file {path} due to a loader exception. Moving on to the next file. Ex: {e.Message}"); 492Ch.Warning(MessageSensitivity.Schema, e.Message); 735Ch.Warning($"Could not parse column values from the path {path}. Ex: {e.Message}");

Microsoft.ML.Predictor.Tests (2)

CmdLine\CmdIndenterTest.cs (1)

90wrt.WriteLine("Exception: {0}", ex.Message);

CmdLine\CmdLine.cs (1)

392wrt.WriteLine("Exception: {0}", ex.Message);

Microsoft.ML.ResultProcessor (1)

ResultProcessor.cs (1)

1024Console.Error.WriteLine(e.Message);

Microsoft.ML.Samples (1)

Program.cs (1)

30Console.WriteLine($"An error occurred while running {type.Name}: {ex.Message}");

Microsoft.ML.StandardTrainers (1)

Standard\LogisticRegression\LbfgsPredictorBase.cs (1)

704ch.Warning("Premature convergence occurred. The OptimizationTolerance may be set too small. {0}", e.Message);

Microsoft.ML.Sweeper (4)

ConfigRunner.cs (1)

144throw Host.Except(e, e.Message);

Parameters.cs (3)

606error = $"Error creating sweep generator for parameter '{paramName}': {e.Message}"; 636error = $"Error creating sweep generator for parameter '{paramName}': {e.Message}"; 660error = $"Error creating sweep generator for parameter '{paramName}': {e.Message}";

Microsoft.ML.TensorFlow (3)

TensorflowUtils.cs (3)

316throw Contracts.ExceptParam(nameof(folder), $"Failed to create folder for the provided path: {folder}. \nException: {exc.Message}"); 340ch.Info("Error deleting folder. {0}. Retry,", e.Message); 385throw Contracts.ExceptParam(nameof(folder), $"Failed to create folder for the provided path: {folder}. \nException: {exc.Message}");

Microsoft.ML.TestFramework (2)

DataPipe\Parquet.cs (1)

32Assert.Equal("Nullable object must have a value.", ex.Message);

DataPipe\TestDataPipe.cs (1)

1610Assert.Equal(ex.Message, string.Format("The specified documents are all empty in column '{0}'.", colName));

Microsoft.ML.TestFrameworkCommon (1)

TestCommon.cs (1)

279if (ex.Message != "Invalid call to 'GetValue'")

Microsoft.ML.Tests (25)

CachingTests.cs (1)

68Assert.Contains("Current estimator chain has no estimator, can't append cache checkpoint.", ex.Message,

DatabaseLoaderTests.cs (1)

47Assert.Contains("Timeout", ex.InnerException.Message);

ExpressionLanguageTests\ExpressionLanguageTests.cs (1)

206wrt.WriteLine("Exception: {0}", ex.Message);

OnnxConversionTest.cs (4)

2041Assert.Contains("Requested OpSet version 9 is lower than HashTransform's minimum OpSet version requirement: 11", ex.Message); 2054Assert.Contains("Requested OpSet version 13 is higher than the current most updated OpSet version 12", ex.Message); 2065Assert.Contains("Requested OpSet version 9 is lower than HashTransform's minimum OpSet version requirement: 11", ex.Message); 2076Assert.Contains("Requested OpSet version 13 is higher than the current most updated OpSet version 12", ex.Message);

OnnxSequenceTypeWithAttributesTest.cs (1)

110Assert.Equal(expectedExceptionMessage, ex.Message.Substring(0, 387));

SvmLightTests.cs (11)

247Assert.Contains("Duplicate keys found in dataset", ex.InnerException.Message); 362Assert.Contains("Encountered 0 index while parsing a 1-based dataset", ex.InnerException.Message); 381Assert.Contains("Encountered non-parsable index '-1' while parsing dataset", ex.InnerException.Message); 400Assert.Contains("Encountered non-parsable index 'a' while parsing dataset", ex.InnerException.Message); 407Assert.Contains("No int parsable keys found during key transform inference", ex.Message); 444Assert.Contains("If the number of features is not specified, a dataset must be provided to infer it.", ex.Message); 446Assert.Contains("To use the text feature names option, a dataset must be provided", ex.Message); 513Assert.Contains("Column Label not found in data", ex.Message); 521Assert.Contains("Column Features not found in data", ex.Message); 529Assert.Contains("Column Group not found in data", ex.Message); 537Assert.Contains("Column Weight not found in data", ex.Message);

TextLoaderTests.cs (4)

108Assert.Contains("Could not parse value -9223372036854775809 in line 1, column DvInt8", ex.Message); 132Assert.Contains("Could not parse value 9223372036854775808 in line 1, column DvInt8", ex.Message); 1203Assert.StartsWith("Should define at least one public, readable field or property in TInput.", ex.Message); 1214Assert.StartsWith("Should define at least one public, readable field or property in TInput.", ex.Message);

Transformers\ConcatTests.cs (1)

32Assert.Contains("Input columns not specified", ex.Message);

Transformers\KeyToVectorEstimatorTests.cs (1)

268Assert.Contains("Arithmetic operation resulted in an overflow. Related column: ProblematicColumn", ex.Message);

Microsoft.ML.Tokenizers (5)

Model\CodeGenTokenizer.cs (2)

1756throw new ArgumentException($"Problems met when parsing JSON vocabulary object.{Environment.NewLine}Error message: {e.Message}"); 1796throw new IOException($"Cannot read the file Merge file.{Environment.NewLine}Error message: {e.Message}", e);

Model\EnglishRobertaTokenizer.cs (2)

188throw new ArgumentException($"Problems met when parsing JSON vocabulary object.{Environment.NewLine}Error message: {e.Message}"); 228throw new IOException($"Cannot read the file Merge file.{Environment.NewLine}Error message: {e.Message}", e);

Model\TiktokenTokenizer.cs (1)

233throw new InvalidOperationException($"Failed to load from BPE vocab file stream: {ex.Message}", ex);

Microsoft.ML.Tokenizers.Data.Tests (2)

src\Common\tests\RetryHelper.cs (1)

60string diagnostic = $"RetryHelper: retrying {testName} {i}th time of {maxAttempts}: got {lastException.Message}";

TokenizerDataTests.cs (1)

32Assert.Contains(packageName, exception.Message);

Microsoft.ML.Tokenizers.Tests (1)

src\Common\tests\RetryHelper.cs (1)

60string diagnostic = $"RetryHelper: retrying {testName} {i}th time of {maxAttempts}: got {lastException.Message}";

Microsoft.VisualBasic.Core (7)

Microsoft\VisualBasic\CompilerServices\LateBinding.vb (1)

599Debug.Assert(False, ex.Message)

Microsoft\VisualBasic\CompilerServices\VB6BinaryFile.vb (1)

197Throw New NullReferenceException(JustNeedTheMessage.Message, New IO.IOException(SR.FileOpenedNoRead))

Microsoft\VisualBasic\CompilerServices\VB6File.vb (1)

2714Throw New NullReferenceException(JustNeedTheMessage.Message, New IO.IOException(SR.FileOpenedNoRead))

Microsoft\VisualBasic\ErrObject.vb (1)

130Me.Description = FilterDefaultMessage(m_curException.Message)

Microsoft\VisualBasic\FileIO\FileSystem.vb (3)

1026Exceptions.Add(SourceDirectoryNode.Path, ex.Message) 1046Exceptions.Add(SubFilePath, ex.Message) 1066Exceptions.Add(SourceDirectoryNode.Path, ex.Message)

Microsoft.VisualBasic.Forms.Tests (6)

System\Windows\Forms\ApplicationServicesExceptionsTests.vb (6)

24ex.Message.Should.Be(expected) 28ex.Message.Should.Be(TestMessage) 32ex.Message.Should.Be(Test1Message) 41ex.Message.Should.Be(expected) 45ex.Message.Should.Be(TestMessage) 49ex.Message.Should.Be(Test1Message)

Microsoft.VisualStudio.Extensibility.Testing.Xunit (2)

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Microsoft.VisualStudio.LanguageServices (13)

CallHierarchy\Finders\AbstractCallFinder.cs (1)

76completionErrorMessage = e.Message;

ErrorReporting\VisualStudioErrorReportingService.cs (1)

69new DetailedErrorInfoDialog(exception.Message, errorInfo).ShowModal();

ErrorReporting\VisualStudioErrorReportingService.ExceptionFormatting.cs (2)

48var message = exception.Message; 60stackText += " ---> " + innerException.Message;

ExternalAccess\LegacyCodeAnalysis\LegacyCodeAnalysisVisualStudioSuppressionFixServiceAccessor.cs (3)

46string.Format(ServicesVSResources.Error_updating_suppressions_0, ex.Message), 68message: string.Format(ServicesVSResources.Error_updating_suppressions_0, ex.Message), 90message: string.Format(ServicesVSResources.Error_updating_suppressions_0, ex.Message),

GenerateType\GenerateTypeDialogViewModel.cs (1)

277SendFailureNotification(e.Message);

Log\VisualStudioErrorLogger.cs (1)

38=> exception.Message + Environment.NewLine + exception.StackTrace;

Packaging\PackageInstallerServiceFactory.cs (4)

352dte.StatusBar.Text = string.Format(ServicesVSResources.Package_install_failed_colon_0, e.Message); 356string.Format(ServicesVSResources.Installing_0_failed_Additional_information_colon_1, packageName, e.Message), 413dte.StatusBar.Text = string.Format(ServicesVSResources.Package_uninstall_failed_colon_0, e.Message); 417string.Format(ServicesVSResources.Uninstalling_0_failed_Additional_information_colon_1, packageName, e.Message),

Microsoft.VisualStudio.LanguageServices.CSharp (1)

SemanticSearch\SemanticSearchQueryExecutor.cs (1)

170result = new ExecuteQueryResult(e.Message);

Microsoft.VisualStudio.LanguageServices.Implementation (2)

SolutionExplorer\AnalyzersCommandHandler.cs (2)

376SendUnableToOpenRuleSetNotification(workspace, e.Message); 493notificationMessages.Add(e.Message);

MiddlewareAnalysisSample (1)

Startup.cs (1)

109Console.WriteLine($"MiddlewareException: {name}; {exception.Message}");

MSBuild (37)

CommandLine\CommandLineSwitchException.cs (2)

71return base.Message; 75return base.Message + Environment.NewLine + ResourceUtilities.FormatResourceStringStripCodeAndKeyword("InvalidSwitchIndicator", commandLineArg);

FrameworkLocationHelper.cs (1)

1028ErrorUtilities.ThrowInvalidOperation("FrameworkLocationHelper.CouldNotGenerateReferenceAssemblyDirectory", targetFrameworkRootPath, frameworkName.ToString(), e.Message);

InitializationException.cs (3)

76return base.Message; 80return base.Message + Environment.NewLine + ResourceUtilities.FormatResourceStringStripCodeAndKeyword("InvalidSwitchIndicator", invalidSwitch); 154errorMessage = ResourceUtilities.FormatString(errorMessage, (e == null) ? String.Empty : e.Message);

NodeEndpointOutOfProcBase.cs (1)

490CommunicationsUtilities.Trace("Client connection failed but we will wait for another connection. Exception: {0}", e.Message);

PrintLineDebuggerWriters.cs (1)

33File.AppendAllText(errorFile, $"{SimpleFormat(id, callsite, args)}\n{e.Message}\n{e.StackTrace}");

ResourceUtilities.cs (2)

469ErrorUtilities.ThrowInternalError(e.Message); 476ErrorUtilities.ThrowInternalError(e.Message);

XMake.cs (27)

951Console.WriteLine(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("ConfigurationFailurePrefixNoErrorCode", e.ErrorCode, e.Message)); 969Console.WriteLine(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("LoggerFailurePrefixNoErrorCode", e.ErrorCode, e.Message)); 975Console.WriteLine(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("LoggerFailurePrefixWithErrorCode", e.Message)); 994Console.WriteLine($"MSBUILD : error {e.ErrorCode}: {e.Message}"); 1007$"MSBUILD : error {e.ErrorCode}: {e.Message}{(e.InnerException != null ? $" {e.InnerException.Message}" : "")}"); 1020Console.WriteLine($"MSBUILD : error {pce?.ErrorCode ?? exppce?.ErrorCode}: {e.Message}"); 1041$"MSBUILD : error {e.ErrorCode}: {e.Message}{(e.InnerException != null ? $" {e.InnerException.Message}" : string.Empty)}"); 1049$"{e.Message}{(e.InnerException != null ? $" {e.InnerException.Message}" : string.Empty)}"); 2733CommunicationsUtilities.Trace("Invalid node packet version value '{0}': {1}", parameters[parameters.Length - 1], ex.Message); 2738CommunicationsUtilities.Trace("Node packet version value '{0}' out of range: {1}", parameters[parameters.Length - 1], ex.Message); 2768CommandLineSwitchException.Throw("InvalidNodeReuseValue", parameters[parameters.Length - 1], ex.Message); 2795CommandLineSwitchException.Throw("InvalidPreprocessPath", parameters[parameters.Length - 1], ex.Message); 2814CommandLineSwitchException.Throw("TargetsCouldNotBePrinted", parameters[parameters.Length - 1], ex.Message); 2877CommandLineSwitchException.Throw(resourceName, parameters[parameters.Length - 1], ex.Message); 2926ex.Message); 2931ex.Message); 3074CommandLineSwitchException.Throw("InvalidMaxCPUCountValue", parameters[parameters.Length - 1], ex.Message); 3078CommandLineSwitchException.Throw("InvalidMaxCPUCountValue", parameters[parameters.Length - 1], ex.Message); 3706throw new LoggerException(e.Message, e); 3988InitializationException.Throw("XMake.LoggerCreationError", unquotedParameter, e, false, [loggerDescription.Name, (e == null) ? String.Empty : e.Message]); 3996InitializationException.Throw("XMake.LoggerCreationError", unquotedParameter, e, false, [loggerDescription.Name, (e == null) ? String.Empty : e.Message]); 4004InitializationException.Throw("XMake.LoggerCreationError", unquotedParameter, e, false, [loggerDescription.Name, (e == null) ? String.Empty : e.Message]); 4012Console.WriteLine(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("OptionalLoggerCreationMessage", loggerDescription.Name, e.Message)); 4086var message = ResourceUtilities.FormatResourceStringStripCodeAndKeyword("InvalidLogFileFormat", ex.Message);

MSBuildTaskHost (3)

BackEnd\NodeEndpointOutOfProcTaskHost.cs (1)

343CommunicationsUtilities.Trace($"Client connection failed but we will wait for another connection. Exception: {e.Message}");

Exceptions\BuildExceptionBase.cs (1)

84writer.Write(exception.Message);

Utilities\FileUtilities.ItemSpecModifiers.cs (1)

244ErrorUtilities.ThrowInvalidOperation(SR.Shared_InvalidFilespecForTransform, modifier, itemSpec, e.Message);

Pipelines.AppHost (1)

AppHost.cs (1)

221$"Error assigning role: {ex.Message}",

PresentationBuildTasks (15)

Microsoft\Build\Tasks\Windows\FileClassifier.cs (1)

109errorId = Log.ExtractMessageCode(e.Message, out message);

Microsoft\Build\Tasks\Windows\MarkupCompilePass1.cs (1)

182errorId = Log.ExtractMessageCode(e.Message, out message);

Microsoft\Build\Tasks\Windows\MarkupCompilePass2.cs (1)

136errorId = Log.ExtractMessageCode(e.Message, out message);

Microsoft\Build\Tasks\Windows\ResourcesGenerator.cs (1)

203string errorId = Log.ExtractMessageCode(e.Message, out message);

Microsoft\Build\Tasks\Windows\UidManager.cs (1)

104errorId = Log.ExtractMessageCode(e.Message, out message);

MS\Internal\Tasks\TaskHelper.cs (4)

193string message = e.Message; 199if (!e.Message.Contains(eInner.Message, StringComparison.Ordinal)) 205message += eInner.Message;

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\BamlRecordWriter.cs (1)

90_xamlTypeMapper.ThrowExceptionWithLine(e.Message, e.InnerException);

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XamlParseException.cs (3)

420if (innerException != null && innerException.Message != null) 423if (innerException.Message != String.Empty) 428sb.Append(innerException.Message);

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XamlParser.cs (1)

232newMessage = $"{e.Message} {SR.Format(SR.ParserLineAndOffset,

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XamlReaderHelper.cs (1)

419RethrowAsParseException(e.Message, LineNumber, LinePosition, e);

PresentationCore (4)

MS\Internal\FontFace\CompositeFontParser.cs (2)

201Fail(x.Message, x); 893x.Message),

MS\Internal\TextFormatting\FullTextLine.cs (1)

426new object[] { caughtException.Message, caughtException }

System\Windows\Nrbf\SerializationRecordExtensions.cs (1)

25Debug.Fail(ex.Message);

PresentationFramework (24)

MS\Internal\DataStreams.cs (2)

131Debug.Fail($"Unexpected exception writing binary formatted data. {ex.Message}"); 260Debug.Fail($"Unexpected exception reading binary formatted data. {ex.Message}");

MS\Internal\IO\Packaging\XpsFilter.cs (4)

423throw new COMException(ex.Message, (int)FilterErrorCode.FILTER_E_ACCESS); 427throw new COMException(ex.Message, (int)FilterErrorCode.FILTER_E_UNKNOWNFORMAT); 552throw new COMException(ex.Message, (int)FilterErrorCode.FILTER_E_ACCESS); 556throw new COMException(ex.Message, (int)FilterErrorCode.FILTER_E_UNKNOWNFORMAT);

MS\Internal\PtsHost\Pts.cs (2)

99string message = (innerException == null) ? String.Empty : innerException.Message; 281get { return InnerException.Message; }

MS\Internal\TraceData.cs (1)

292return $"{ex.GetType().Name} ({AvTrace.AntiFormat(ex.Message)})";

MS\Internal\WindowsRuntime\Generated\WinRT\ExceptionHelpers.cs (2)

179string message = ex.Message; 363string message = innerException.Message ?? messageResource;

MS\Internal\WindowsRuntime\Generated\WinRT\Interop\ExceptionErrorInfo.cs (1)

60string desc = _exception.Message;

System\Windows\Controls\DataErrorValidationRule.cs (1)

93ex.Message),

System\Windows\Controls\Primitives\Popup.cs (1)

1863throw new NullReferenceException(nre.Message, SavedException);

System\Windows\Data\BindingExpression.cs (1)

2191validationError = new ValidationError(exceptionValidationRule, this, ex.Message, ex);

System\Windows\Data\BindingGroup.cs (3)

979AddValidationError(new ValidationError(rule, this, vue.Message, vue)); 1214AddValidationError(new ValidationError(rule, this, vue.Message, vue)); 1242ValidationError error = new ValidationError(ExceptionValidationRule.Instance, this, ex.Message, ex);

System\Windows\Markup\BamlRecordWriter.cs (1)

90_xamlTypeMapper.ThrowExceptionWithLine(e.Message, e.InnerException);

System\Windows\Markup\XamlParseException.cs (3)

420if (innerException != null && innerException.Message != null) 423if (innerException.Message != String.Empty) 428sb.Append(innerException.Message);

System\Windows\Markup\XamlReader.cs (2)

523return new XamlParseException(e.Message, lineInfo.LineNumber, lineInfo.LinePosition, baseUri, baseException); 527return new XamlParseException(e.Message, baseException);

PresentationUI (2)

MS\Internal\Documents\DocumentSignatureManager.cs (1)

607e.Message),

MS\Internal\Documents\RightsManagementProvider.cs (1)

247rmException.Message);

ReachFramework (8)

PrintConfig\PrintSchema.cs (4)

2434errMsg = e.Message; 2439errMsg = e.Message; 2469errMsg = e.Message; 2474errMsg = e.Message;

PrintConfig\PrtCap_Public.cs (1)

39/// The exception object's <see cref="Exception.Message"/> property describes why the XML is not well-formed. And if not

PrintConfig\PrtCap_Public_Simple.cs (1)

193/// well-formed XML PrintCapabilities. The exception object's <see cref="Exception.Message"/> property describes

PrintConfig\PrtTicket_Public.cs (1)

58/// The exception object's <see cref="Exception.Message"/> property describes why the XML is not well-formed.

PrintConfig\PrtTicket_Public_Simple.cs (1)

262/// well-formed XML PrintTicket. The exception object's <see cref="Exception.Message"/> property describes

Replay (9)

Replay.cs (1)

115Console.WriteLine($"Error: {ex.Message}");

src\Compilers\Shared\BuildServerConnection.cs (4)

src\Compilers\Shared\CompilerServerLogger.cs (2)

84builder.AppendLine($"Error: '{exception.GetType().Name}' '{exception.Message}' occurred during '{reason}'"); 139Debug.Assert(false, e.Message);

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

RepoTasks (14)

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (3)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (11)

Roslyn.Compilers.Extension (1)

CompilerPackage.cs (1)

133$@"{e.Message}

Roslyn.Diagnostics.Analyzers (12)

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Roslyn.Test.PdbUtilities (2)

EditAndContinue\EditAndContinueTest.cs (1)

162builder.AppendLine(exception.Message);

EditAndContinue\EditAndContinueTestUtilities.cs (1)

29throw new InvalidDataException(e.Message, e);

Roslyn.VisualStudio.Next.UnitTests (4)

Services\ServiceHubServicesTests_ExtensionMessageHandler.cs (4)

215Assert.Equal(ExpectedExceptionMessage, result.ExtensionException.Message); 326Assert.Equal(ExpectedExceptionMessage, result.ExtensionException.Message); 455Assert.Contains(ExtensionExceptionMessage, result.ExtensionException.Message); 503Assert.Contains(ExtensionExceptionMessage, result.ExtensionException.Message);

RulesetToEditorconfigConverter (1)

Program.cs (1)

25Console.WriteLine(ex.Message);

RunTests (6)

Logger.cs (3)

31s_lines.Add($"Error {ex.Message}: {line}"); 41s_lines.Add(ex.Message); 50s_lines.Add(ex.Message);

Options.cs (1)

198ConsoleUtil.WriteLine($"Error parsing command line arguments: {e.Message}");

Program.cs (1)

249ConsoleUtil.WriteLine(ex.Message);

TestRunner.cs (1)

120ConsoleUtil.WriteLine(ConsoleColor.Red, $"Error: {ex.Message}");

ScenarioTests.Common.Tests (1)

ScenarioTestHelpers.cs (1)

143Logger.LogInformation(" {0}", ex.Message);

Security.TransportSecurity.IntegrationTests (7)

Https\ClientCredentialTypeTests.4.1.0.cs (2)

163Assert.True(exception.Message.ToLower().Contains(message), string.Format("Expected exception message to contain: '{0}', actual message is: '{1}'", message, exception.Message));

Tcp\ClientCredentialTypeCertificateCanonicalNameTests.4.1.0.cs (3)

87errorBuilder.AppendFormat("Exception message: {0}{1}", Environment.NewLine, exception.Message); 164errorBuilder.AppendFormat("Exception message: {0}{1}", Environment.NewLine, exception.Message); 248errorBuilder.AppendFormat("Exception message: {0}{1}", Environment.NewLine, exception.Message);

Tcp\IdentityTests.4.1.1.cs (2)

42Assert.True(exception.Message.Contains(Endpoints.Tcp_VerifyDNS_HostName), string.Format("Expected exception message contains: '{0}', actual: '{1}')", Endpoints.Tcp_VerifyDNS_HostName, exception.Message));

SemanticSearch.BuildTask (4)

GenerateFilteredReferenceAssembliesTask.cs (2)

189Log.LogError($"Unable to read '{outputFilePath}': {e.Message}"); 211Log.LogError($"Error updating baseline '{outputFilePath}': {e.Message}");

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

Shared (1)

LogBuffering\SerializedLogRecordFactory.cs (1)

46exceptionMessage = exception.Message;

Shared.Tests (79)

Throw\DoubleTests.cs (12)

Throw\IntegerTests.cs (24)

Throw\LongTests.cs (24)

Throw\ThrowTest.cs (19)

SignalR.Client.FunctionalTestApp (1)

Startup.cs (1)

255return ex.Message;

SocialSample (1)

Startup.cs (1)

220context.Failure.Message.Split(Environment.NewLine).Select(s => HtmlEncoder.Default.Encode(s) + " ").Aggregate((s1, s2) => s1 + s2));

Sockets.BindTests (4)

src\Servers\Kestrel\test\BindTests\AddressRegistrationTests.cs (4)

558Assert.Equal(expectedMessage, exception.Message); 593Assert.Equal(expectedMessage, exception.Message); 978if (exception.Message == CoreStrings.FormatEndpointAlreadyInUse(otherAddressString)) 986Assert.Equal(CoreStrings.FormatEndpointAlreadyInUse(thisAddressString), exception.Message);

Sockets.FunctionalTests (1)

src\Servers\Kestrel\test\FunctionalTests\Http2\HandshakeTests.cs (1)

61Assert.Equal("HTTP/2 over TLS is not supported on Windows 7 due to missing ALPN support.", ex.Message);

System.Collections.Concurrent (1)

System\Collections\Concurrent\ConcurrentBag.cs (1)

303throw new InvalidCastException(e.Message, e);

System.ComponentModel.Annotations (1)

System\ComponentModel\DataAnnotations\ValidationException.cs (1)

97_validationResult ??= new ValidationResult(Message);

System.ComponentModel.Composition (16)

System\ComponentModel\Composition\CompositionContractMismatchException.cs (2)

32/// the <see cref="Exception.Message"/> property to its default value. 47/// the <see cref="Exception.Message"/> property to its default value.

System\ComponentModel\Composition\CompositionException.cs (4)

41/// the <see cref="Exception.Message"/> property to its default value. 56/// the <see cref="Exception.Message"/> property to its default value. 127return base.Message; 318VisitError(new CompositionError(exception.Message, exception.InnerException), context);

System\ComponentModel\Composition\ErrorBuilder.cs (1)

42exception.Message,

System\ComponentModel\Composition\ImportCardinalityMismatchException.cs (2)

35/// the <see cref="Exception.Message"/> property to its default value. 50/// the <see cref="Exception.Message"/> property to its default value.

System\ComponentModel\Composition\ImportCardinalityMismatchExceptionDebuggerProxy.cs (1)

26get { return _exception.Message; }

System\ComponentModel\Composition\Primitives\ComposablePartException.cs (4)

66/// the <see cref="Exception.Message"/> property to its default value. 81/// the <see cref="Exception.Message"/> property to its default value. 102/// the <see cref="Exception.Message"/> property to its default value. 122/// the <see cref="Exception.Message"/> property to its default value.

System\ComponentModel\Composition\Primitives\ComposablePartExceptionDebuggerProxy.cs (1)

31get { return _exception.Message; }

System\Composition\Diagnostics\CompositionTrace.cs (1)

58exception.Message);

System.ComponentModel.TypeConverter (1)

System\ComponentModel\ReflectPropertyDescriptor.cs (1)

938string message = t.Message ?? t.GetType().Name;

System.Configuration.ConfigurationManager (10)

System\Configuration\BaseConfigurationRecord.cs (1)

3613SR.Format(SR.Decryption_failed, protectionProvider.Name, e.Message), e, filename, lineNumber);

System\Configuration\ConfigurationElement.cs (1)

1781ex.Message));

System\Configuration\ConfigurationException.cs (1)

85public virtual string BareMessage => base.Message;

System\Configuration\ConfigurationProperty.cs (4)

306Name, ex.Message)); 337ex.Message)); 360SR.Format(SR.Top_level_conversion_error_to_string, Name, ex.Message)); 373SR.Format(SR.Top_level_validation_error, Name, ex.Message), ex);

System\Configuration\ExceptionUtil.cs (1)

75SR.Format(SR.Wrapped_exception_message, outerMessage, e.Message),

System\Configuration\MgmtConfigurationRecord.cs (1)

1679configSection.SectionInformation.ProtectionProvider.Name, e.Message),

System\Configuration\SettingsPropertyValue.cs (1)

145throw new ArgumentException(SR.Format(SR.Could_not_create_from_default_value, Property.Name, e.Message));

System.Data.Common (8)

src\libraries\Common\src\System\Data\Common\DbConnectionOptions.Common.cs (1)

502string msg1 = e.Message;

System\Data\Common\DbDataAdapter.cs (3)

1665string message = errors.Message; 1674string rowMsg = commandErrors.Message; 1733string message = errors.Message;

System\Data\Constraint.cs (1)

121throw ExceptionBuilder.BadObjectPropertyAccess(e.Message);

System\Data\DataException.cs (1)

503public static Exception SetFailed(object? value, DataColumn column, Type type, Exception innerException) => _Argument(innerException.Message + SR.Format(SR.DataColumn_SetFailed, value?.ToString(), column.ColumnName, type.Name), innerException);

System\Data\DataRelation.cs (1)

677throw ExceptionBuilder.BadObjectPropertyAccess(e.Message);

System\Data\Merger.cs (1)

591_dataSet.RaiseMergeFailed(null, e.Message, _missingSchemaAction);

System.Data.Odbc (2)

src\libraries\Common\src\System\Data\Common\DbConnectionOptions.Common.cs (1)

502string msg1 = e.Message;

System\Data\Odbc\DbDataRecord.cs (1)

66throw new OverflowException(innerException.Message, innerException);

System.Diagnostics.DiagnosticSource (1)

System\Diagnostics\Activity.cs (1)

590exceptionTags.Add(new KeyValuePair<string, object?>(ExceptionMessageTag, exception.Message));

System.DirectoryServices.Protocols (1)

System\DirectoryServices\Protocols\ldap\LdapPartialResultsProcessor.cs (1)

371Debug.WriteLine(e.Message);

System.Drawing.Primitives (1)

System\Drawing\ColorTranslator.cs (1)

278throw new ArgumentException(ex.Message, nameof(htmlColor), ex);

System.Formats.Asn1 (1)

System\Formats\Asn1\AsnWriter.cs (1)

550throw new InvalidOperationException(new InvalidOperationException().Message, e);

System.IO.Pipelines (1)

System\IO\Pipelines\StreamPipeReader.cs (1)

289throw new OperationCanceledException(ex.Message, ex, cancellationToken);

System.IO.Ports (1)

System\IO\Ports\InternalResources.cs (1)

19return new Win32Exception(errorCode).Message;

System.Net.Http (15)

src\libraries\Common\src\System\Net\InternalException.cs (2)

21base.Message + " " + _unexpectedValue : 22base.Message;

System\Net\Http\CancellationHelper.cs (1)

13private static readonly string s_cancellationMessage = new OperationCanceledException().Message; // use same message as the default ctor

System\Net\Http\DiagnosticsHandler.cs (1)

301[DynamicDependency(nameof(System.Exception.Message), typeof(Exception))]

System\Net\Http\Headers\ByteArrayHeaderParser.cs (1)

52if (NetEventSource.Log.IsEnabled()) NetEventSource.Error(this, SR.Format(SR.net_http_parser_invalid_base64_string, base64String, e.Message));

System\Net\Http\HttpClient.cs (2)

605e = toThrow = new TaskCanceledException(oce.Message, oce, cancellationToken); 618e = toThrow = new TaskCanceledException(SR.Format(SR.net_http_request_timedout, _timeout.TotalSeconds), new TimeoutException(e.Message, e), oce.CancellationToken);

System\Net\Http\HttpIOException.cs (1)

31public override string Message => $"{base.Message} ({HttpRequestError})";

System\Net\Http\HttpTelemetry.cs (1)

82RequestFailed(exceptionMessage: exception.Message);

System\Net\Http\SocketsHttpHandler\ConnectHelper.cs (1)

143new HttpRequestException(DeduceError(exception), $"{exception.Message} ({host}:{port})", exception, RequestRetryType.RetryOnNextProxy);

System\Net\Http\SocketsHttpHandler\Http2Connection.cs (2)

616if (NetEventSource.Log.IsEnabled()) Trace($"{nameof(ProcessIncomingFramesAsync)}: {e.Message}"); 1342if (NetEventSource.Log.IsEnabled()) Trace($"{nameof(HeartBeat)}: {e.Message}");

System\Net\Http\SocketsHttpHandler\Http3RequestStream.cs (3)

327throw new TaskCanceledException(ex.Message, ex, cancellationToken); 351throw new TaskCanceledException(ex.Message, ex, cancellationToken); 1371throw new TaskCanceledException(e.Message, e, cancellationToken);

System.Net.Http.Json (1)

System\Net\Http\Json\HttpClientJsonExtensions.cs (1)

98throw new TaskCanceledException(message, new TimeoutException(oce.Message, oce), oce.CancellationToken);

System.Net.HttpListener (10)

System\Net\HttpListenerException.cs (4)

16if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(this, $"{NativeErrorCode}:{Message}"); 21if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(this, $"{NativeErrorCode}:{Message}"); 26if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(this, $"{NativeErrorCode}:{Message}"); 34if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(this, $"{NativeErrorCode}:{Message}");

System\Net\Managed\ChunkedInputStream.cs (2)

147_context.Connection.SendError(e.Message, 400); 171throw new HttpListenerException((int)HttpStatusCode.BadRequest, SR.Format(SR.net_io_operation_aborted, ares._error.Message));

System\Net\Managed\HttpConnection.cs (1)

397_context.ErrorMessage = e.Message;

System\Net\Managed\HttpResponseStream.Managed.cs (3)

152throw new HttpListenerException(ex.HResult, ex.Message); 254throw new HttpListenerException(ex.HResult, ex.Message); 292throw new HttpListenerException(ex.HResult, ex.Message);

System.Net.Mail (1)

System\Net\Mime\ContentType.cs (1)

282catch (FormatException fe) when (fe.Message != SR.ContentTypeInvalid)

System.Net.NameResolution (2)

src\libraries\Common\src\System\Net\InternalException.cs (2)

21base.Message + " " + _unexpectedValue : 22base.Message;

System.Net.Primitives (1)

System\Net\SocketException.cs (1)

50public override string Message => base.Message;

System.Net.Requests (8)

src\libraries\Common\src\System\Net\InternalException.cs (2)

21base.Message + " " + _unexpectedValue : 22base.Message;

System\Net\FileWebRequest.cs (2)

154catch (Exception e) { throw new WebException(e.Message, e); } 214throw new WebException(e.Message, e);

System\Net\FileWebResponse.cs (1)

45throw new WebException(e.Message, e, WebExceptionStatus.ConnectFailure, null);

System\Net\FtpWebRequest.cs (2)

1105_exception = new WebException(exception.Message, null, ((WebException)exception).Status, _ftpWebResponse); 1118_exception = new WebException(exception.Message, exception);

System\Net\WebException.cs (1)

86exception.Message,

System.Net.Security (4)

src\libraries\Common\src\System\Net\InternalException.cs (2)

21base.Message + " " + _unexpectedValue : 22base.Message;

System\Net\Security\SslStream.IO.cs (1)

163NetSecurityTelemetry.Log.HandshakeFailed(IsServer, startingTimestamp, ex.Message);

System\Net\Security\SslStream.Protocol.cs (1)

855NetEventSource.Error(this, $"Authentication failed. Status: {token.Status}, Exception message: {token.GetException()!.Message}");

System.Net.Sockets (10)

src\libraries\Common\src\System\Net\InternalException.cs (2)

21base.Message + " " + _unexpectedValue : 22base.Message;

System\Net\Sockets\NetworkStream.cs (1)

721return new IOException(SR.Format(resourceFormatString, innerException.Message), innerException);

System\Net\Sockets\Socket.cs (5)

1070SocketsTelemetry.Log.AfterAccept(SocketError.Interrupted, ex.Message); 2874SocketsTelemetry.Log.AfterAccept(SocketError.Interrupted, ex.Message); 2960SocketsTelemetry.Log.AfterConnect(SocketError.NotSocket, e.ConnectActivity, ex.Message); 2977SocketsTelemetry.Log.AfterConnect(SocketError.NotSocket, e.ConnectActivity, ex.Message); 3374SocketsTelemetry.Log.AfterConnect(SocketError.NotSocket, activity, ex.Message);

System\Net\Sockets\Socket.Tasks.cs (2)

905new IOException(SR.Format(SR.net_io_readwritefailure, e.Message), e) : 1378new IOException(SR.Format(_isReadForCaching ? SR.net_io_readfailure : SR.net_io_writefailure, e.Message), e) :

System.Net.WebSockets (5)

System\Net\WebSockets\Compression\WebSocketDeflater.cs (1)

218throw new WebSocketException(ex.Message, ex.InnerException);

System\Net\WebSockets\Compression\WebSocketInflater.cs (1)

264throw new WebSocketException(ex.Message, ex.InnerException);

System\Net\WebSockets\ManagedWebSocket.cs (1)

1723new OperationCanceledException().Message,

System\Net\WebSockets\ManagedWebSocket.KeepAlive.cs (1)

66if (NetEventSource.Log.IsEnabled()) NetEventSource.Trace(this, $"KeepAlive already faulted, skipping... (exception: {_keepAlivePingState.Exception.Message})");

System\Net\WebSockets\NetEventSource.WebSockets.cs (1)

84=> Trace(obj, $"{exception.GetType().Name}: {exception.Message}", memberName);

System.Private.CoreLib (32)

src\libraries\System.Private.CoreLib\src\System\AggregateException.cs (4)

335return new AggregateException(GetType() == typeof(AggregateException) ? base.Message : Message, flattenedExceptions.ToArray(), cloneExceptions: false); 345return base.Message; 349sb.Append(base.Message); 354sb.Append(_innerExceptions[i].Message);

src\libraries\System.Private.CoreLib\src\System\ArgumentException.cs (1)

79string s = base.Message;

src\libraries\System.Private.CoreLib\src\System\ComponentModel\Win32Exception.cs (1)

92string message = Message;

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Contracts\ContractException.cs (1)

19public string Failure => this.Message;

src\libraries\System.Private.CoreLib\src\System\Diagnostics\DebugProvider.Unix.cs (1)

28Environment.FailFast(ex.Message, ex, errorSource);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (5)

1733ReportOutOfBandMessage("ERROR: Exception during construction of EventSource " + Name + ": " + e.Message); 2215+ e.Message); 2460ReportOutOfBandMessage(errorPrefix + ": " + innerEx.GetType() + ":" + innerEx.Message); 2827ReportOutOfBandMessage("ERROR: Exception in Command Processing for EventSource " + Name + ": " + e.Message); 3350msg = "Unexpected error: " + exception!.Message;

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\IncrementingPollingCounter.cs (1)

60ReportOutOfBandMessage($"ERROR: Exception during EventCounter {Name} getMetricFunction callback: " + ex.Message);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\PollingCounter.cs (1)

56ReportOutOfBandMessage($"ERROR: Exception during EventCounter {Name} metricProvider callback: " + ex.Message);

src\libraries\System.Private.CoreLib\src\System\Exception.cs (1)

127string? message = Message;

src\libraries\System.Private.CoreLib\src\System\IO\InvalidDataException.cs (3)

16/// <remarks>This constructor initializes the <see cref="Exception.Message" /> property of the new instance to a system-supplied message that describes the error, such as "An invalid argument was specified." This message is localized based on the current system culture.</remarks> 24/// <remarks>This constructor initializes the <see cref="Exception.Message" /> property of the new instance to a system-supplied message that describes the error, such as "An invalid argument was specified." This message is localized based on the current system culture.</remarks> 33/// <remarks>This constructor initializes the <see cref="Exception.Message" /> property of the new instance using the value of the <paramref name="message" /> parameter. The content of the <paramref name="message" /> parameter is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture.

src\libraries\System.Private.CoreLib\src\System\MissingMemberException.cs (1)

65return base.Message;

src\libraries\System.Private.CoreLib\src\System\ObjectDisposedException.cs (2)

96return base.Message; 100return base.Message + Environment.NewLineConst + objectDisposed;

src\libraries\System.Private.CoreLib\src\System\Reflection\ReflectionTypeLoadException.cs (2)

55string baseValue = isMessage ? base.Message : base.ToString(); 68text.AppendLine().Append(isMessage ? e.Message : e.ToString());

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\SwitchExpressionException.cs (2)

59return base.Message; 63return base.Message + Environment.NewLine + valueMessage;

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\COMException.cs (1)

56string message = Message;

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\ExternalException.cs (1)

52string message = Message;

src\libraries\System.Private.CoreLib\src\System\ThrowHelper.cs (2)

658if (ex != null && !string.IsNullOrEmpty(ex.Message)) 660ex = new ApplicationException(ex.Message);

src\System\Reflection\RuntimeCustomAttributeData.cs (1)

689throw new CustomAttributeFormatException(ex.Message, ex);

src\System\RuntimeType.ActivatorCache.cs (1)

62string friendlyMessage = SR.Format(SR.Activator_CannotCreateInstance, rt, ex.Message);

System.Private.DataContractSerialization (9)

System\Runtime\Serialization\DataContract.cs (4)

438throw new Exception(ex.Message, ex); 917throw new Exception(ex.Message, ex); 935throw new Exception(ex.Message, ex); 947throw new Exception(ex.Message, ex);

System\Runtime\Serialization\SchemaImporter.cs (2)

814ThrowTypeCannotBeImportedException(typeName.Name, typeName.Namespace, SR.Format(SR.IsValueTypeFormattedIncorrectly, isValueTypeInnerText, fe.Message)); 1161ThrowTypeCannotBeImportedException(typeName.Name, typeName.Namespace, SR.Format(SR.IsDictionaryFormattedIncorrectly, isDictionaryInnerText, fe.Message));

System\Runtime\Serialization\XmlObjectSerializer.cs (1)

459string innerExceptionMessage = (innerException == null) ? string.Empty : innerException.Message;

System\Xml\ValueHandle.cs (1)

463throw new XmlException(exception.Message, exception.InnerException);

System\Xml\XmlBaseReader.cs (1)

1512throw new XmlException(exception.Message, exception.InnerException);

System.Private.Windows.Core (13)

System\ExceptionExtensions.cs (1)

38new SerializationException(ex.Message, ex),

System\Private\Windows\BinaryFormat\BinaryFormatWriter.cs (2)

656new BinaryObjectString(3, exception.Message), 801Debug.WriteLine($"Failed to binary format: {ex.Message}");

System\Private\Windows\JsonData.cs (1)

123result = new NotSupportedException(ex.Message);

System\Private\Windows\Nrbf\SerializationRecordExtensions.cs (1)

48Debug.Fail(ex.Message);

System\Private\Windows\Ole\BinaryFormatUtilities.cs (1)

39Debug.Fail($"Unexpected exception writing binary formatted data. {ex.Message}");

System\Private\Windows\Ole\Composition.NativeToManagedAdapter.cs (1)

338Debug.Assert(e is NotSupportedException, e.Message);

System\TypeExtensions.cs (1)

281Debug.Fail(e.Message);

Windows\Win32\PInvokeCore.GetWindowText.cs (2)

31Debug.Fail($"GetWindowTextLength failed. Error: {new Win32Exception(error).Message}"); 50Debug.Fail($"GetWindowText failed. Error: {new Win32Exception().Message}");

Windows\Win32\System\Com\ComHelpers.cs (2)

108Debug.WriteLine($"Did not find IUnknown for {@object.GetType().Name}. {ex.Message}"); 222Debug.WriteLine($"{nameof(TryGetObjectForIUnknown)}: Failed to get object for {typeof(TObject).Name}. {ex.Message}");

Windows\Win32\System\Com\WinFormsComWrappers.cs (1)

85Debug.Fail($"Exception thrown in UnwrapAndInvoke {ex.Message}.");

System.Private.Xml (27)

System\Xml\BinaryXml\XmlBinaryReader.cs (1)

969throw new XmlException(e.Message, e);

System\Xml\Core\XmlTextReaderImpl.cs (2)

2732Throw(new XmlException(e.Message, (Exception?)null, lineNo, linePos, _ps.baseUriStr)); 7946string innerMessage = e.Message;

System\Xml\Core\XmlTextReaderImplAsync.cs (1)

5138innerMessage = e.Message;

System\Xml\Schema\DataTypeImplementation.cs (2)

535throw new XmlSchemaException(SR.Sch_InvalidValueDetailed, new string[] { s, GetTypeName(), exception.Message }, exception, null, 0, 0, null); 556throw new XmlSchemaException(SR.Sch_InvalidValueDetailed, new string[] { s, GetTypeName(), exception.Message }, exception, null, 0, 0, null);

System\Xml\Schema\FacetChecker.cs (2)

371throw new XmlSchemaException(SR.Sch_PatternFacetInvalid, new string[] { e.Message }, e, _pattern_facet!.SourceUri, _pattern_facet.LineNumber, _pattern_facet.LinePosition, _pattern_facet); 673throw new XmlSchemaException(code, new string[] { ex.Message }, ex, facet.SourceUri, facet.LineNumber, facet.LinePosition, facet);

System\Xml\Schema\Preprocessor.cs (4)

546SendValidationEvent(SR.Sch_AttributeValueDataTypeDetailed, new string[] { "version", schema.Version, tokenDt.TypeCodeString, exception.Message }, exception, schema); 1993SendValidationEvent(SR.Sch_InvalidAnyDetailed, new string[] { fe.Message }, fe, particle); 2037SendValidationEvent(SR.Sch_InvalidAnyDetailed, new string[] { fe.Message }, fe, anyAttribute); 2114SendValidationEvent(SR.Sch_InvalidAttribute, new string[] { attributeName, fx.Message }, fx, xso);

System\Xml\Schema\SchemaCollectionpreProcessor.cs (2)

1725SendValidationEvent(SR.Sch_InvalidIdAttribute, ex.Message, xso); 1766SendValidationEvent(SR.Sch_InvalidAttribute, attributeName, ex.Message, xso);

System\Xml\Schema\XdrValidator.cs (1)

360SendValidationEvent(SR.Sch_CannotLoadSchema, new string[] { uri, e.Message }, XmlSeverityType.Warning);

System\Xml\Schema\XmlSchemaException.cs (1)

221return _message ?? base.Message;

System\Xml\Schema\XmlSchemaValidator.cs (6)

1276SendValidationEvent(SR.Sch_InvalidValueDetailedAttribute, new string[] { "schemaLocation", xsiSchemaLocation, s_dtStringArray.TypeCodeString, exception.Message }, exception); 1477SendValidationEvent(SR.Sch_ElementValueDataTypeDetailed, new string[] { QNameString(_context.LocalName!, _context.Namespace!), stringValue, GetTypeName(decl), exception.Message }, exception); 1648SendValidationEvent(SR.Sch_InvalidValueDetailedAttribute, new string[] { "type", xsiType, s_dtQName.TypeCodeString, exception.Message }, exception); 1859SendValidationEvent(SR.Sch_CannotLoadSchema, new string[] { uri, e.Message }, e, XmlSeverityType.Warning); 1961SendValidationEvent(SR.Sch_AttributeValueDataTypeDetailed, new string[] { attdef.Name.ToString(), stringValue, GetTypeName(decl), exception.Message }, exception); 1976SendValidationEvent(SR.Sch_ElementValueDataTypeDetailed, new string[] { QNameString(_context.LocalName!, _context.Namespace!), stringValue, GetTypeName(decl), exception.Message }, exception);

System\Xml\Schema\XsdValidator.cs (1)

609SendValidationEvent(SR.Sch_CannotLoadSchema, new string[] { uri, e.Message }, XmlSeverityType.Warning);

System\Xml\Serialization\Compilation.cs (1)

76throw new InvalidOperationException(ex.Message, ex);

System\Xml\XmlException.cs (1)

280return _message ?? base.Message;

System\Xml\XPath\XPathException.cs (1)

126return _message ?? base.Message;

System\Xml\Xslt\XsltException.cs (1)

120return _message ?? base.Message;

System.Reflection.Metadata (4)

System\Reflection\Internal\MemoryBlocks\StreamMemoryBlockProvider.cs (1)

138throw new IOException(e.Message, e);

System\Reflection\Metadata\MetadataReader.netstandard.cs (1)

110throw new BadImageFormatException(ex.Message, assemblyFile, ex);

System\Reflection\PortableExecutable\PEReader.cs (1)

731throw new ArgumentException(e.Message, nameof(peImagePath), e);

System\Reflection\PortableExecutable\PEReader.EmbeddedPortablePdb.cs (1)

112throw new BadImageFormatException(e.Message, e);

System.Resources.Extensions (1)

System\Resources\Extensions\BinaryFormat\SerializationExtensions.cs (1)

20new SerializationException(ex.Message, ex),

System.Security.Cryptography (1)

System\Security\Cryptography\X509Certificates\OpenSslDirectoryBasedStoreProvider.cs (1)

348throw new CryptographicException(e.Message, e);

System.ServiceModel.Http (13)

System\ServiceModel\Channels\ClientWebSocketTransportDuplexSessionChannel.cs (3)

85new WebSocketException(WebSocketError.ConnectionClosedPrematurely).Message); 112WcfEventSource.Instance.WebSocketConnectionFailed(EventTraceActivity, ex.Message); 266throw FxTrace.Exception.AsError(new CommunicationException(ex.Message, ex));

System\ServiceModel\Channels\HttpChannelHelpers.cs (2)

113throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(requestException.Message, requestException)); 159return new CommunicationException(exception.Message, exception);

System\ServiceModel\Channels\MessageContent.cs (1)

119new ProtocolException(SR.Format(SR.HttpContentTypeFormatException, formatException.Message, Headers.ContentType.ToString()), formatException));

System\ServiceModel\Channels\TransportDuplexSessionChannel.cs (3)

134WcfEventSource.Instance.ReceiveTimeout(e.Message); 154WcfEventSource.Instance.ReceiveTimeout(e.Message); 172WcfEventSource.Instance.ReceiveTimeout(e.Message);

System\ServiceModel\Channels\WebSocketHelper.cs (3)

139CommunicationObjectAbortedException communicationObjectAbortedException = new CommunicationObjectAbortedException(ex.Message, ex); 182return new CommunicationObjectAbortedException(exception.Message, exception); 185return new CommunicationException(exception.Message, exception);

System\ServiceModel\Channels\WebSocketTransportDuplexSessionChannel.cs (1)

639WcfEventSource.Instance.ReceiveTimeout(exception.Message);

System.ServiceModel.NetFramingBase (16)

System\ServiceModel\Channels\Connection.cs (3)

348return new TimeoutException(ioException.InnerException.Message, ioException); 352return new CommunicationObjectAbortedException(ioException.InnerException.Message, ioException); 356return new CommunicationException(ioException.InnerException.Message, ioException);

System\ServiceModel\Channels\ConnectionPool.cs (1)

186WcfEventSource.Instance.CloseTimeout(exception.Message);

System\ServiceModel\Channels\FramingDecoders.cs (3)

293return new CommunicationException(inner.Message, inner); 306return new CommunicationException(inner.Message, inner); 311return new CommunicationException(inner.Message, inner);

System\ServiceModel\Channels\SessionConnectionReader.cs (1)

159WcfEventSource.Instance.ReceiveTimeout(e.Message);

System\ServiceModel\Channels\SslStreamSecurityUpgradeProvider.cs (3)

374throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException(tokenValidationException.Message, 379throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException(exception.Message, 385SR.Format(SR.NegotiationFailedIO, ioException.Message), ioException));

System\ServiceModel\Channels\TransportDuplexSessionChannel.cs (3)

137WcfEventSource.Instance.ReceiveTimeout(e.Message); 156WcfEventSource.Instance.ReceiveTimeout(e.Message); 174WcfEventSource.Instance.ReceiveTimeout(e.Message);

System\ServiceModel\Channels\WindowsStreamSecurityUpgradeProvider.cs (2)

186throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException(exception.Message, 192SR.Format(SR.NegotiationFailedIO, ioException.Message), ioException));

System.ServiceModel.NetNamedPipe (5)

System\ServiceModel\Channels\PipeConnection.cs (1)

88return ConvertPipeException(pipeException.Message, pipeException, transferOperation);

System\ServiceModel\Channels\PipeConnectionInitiator.cs (4)

199resolvedAddress, ex.Message), ex.HResult); 221resolvedAddress, ex.Message), error); 235PipeException innerException = new PipeException(SR.Format(SR.PipeModeChangeFailed, ex.Message), ex.HResult); 437exception.Message,

System.ServiceModel.Primitives (36)

Internals\System\Runtime\Diagnostics\EtwDiagnosticTrace.cs (1)

78new Tuple<string, string> (DiagnosticStrings.MessageTag, XmlEncode(exception.Message)),

Internals\System\Xml\XmlMtomReader.cs (1)

1328throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(e.Message, e));

System\IdentityModel\Selectors\X509CertificateValidator.cs (2)

276throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenValidationException(exception.Message + " " + ex.Message));

System\ServiceModel\ActionNotSupportedException.cs (1)

25string reason = Message;

System\ServiceModel\Channels\Message.cs (2)

1353new CommunicationException(versionMismatchException.Message, versionMismatchException), 1581new CommunicationException(versionMismatchException.Message, versionMismatchException),

System\ServiceModel\Channels\MessageHeader.cs (1)

320throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(exception.Message, null));

System\ServiceModel\Channels\ReliableMessagingHelpers.cs (1)

882new CommunicationException(exception.Message, exception));

System\ServiceModel\Channels\RequestContextBase.cs (1)

321WcfEventSource.Instance.CloseTimeout(e.Message);

System\ServiceModel\Channels\ServiceChannel.cs (1)

859WcfEventSource.Instance.CloseTimeout(e.Message);

System\ServiceModel\Dispatcher\DataContractSerializerOperationFormatter.cs (3)

296SRP.Format(SRP.SFxInvalidMessageBodyErrorSerializingParameter, part.Description.Namespace, part.Description.Name, sx.Message), sx)); 538part.Description.Namespace, part.Description.Name, e.Message), 546part.Description.Namespace, part.Description.Name, e.Message),

System\ServiceModel\Dispatcher\ErrorBehavior.cs (2)

96fault = MessageFault.CreateFault(code, new FaultReason(error.Message), new ExceptionDetail(error)); 129WcfEventSource.Instance.FaultProviderInvoked(_handlers[i].GetType().FullName, e.Message);

System\ServiceModel\Dispatcher\ImmutableDispatchRuntime.cs (2)

583throw DiagnosticUtility.ExceptionUtility.ThrowHelperFatal(e.Message, e); 683throw DiagnosticUtility.ExceptionUtility.ThrowHelperFatal(e.Message, e);

System\ServiceModel\Dispatcher\MessageRpc.cs (1)

468throw DiagnosticUtility.ExceptionUtility.ThrowHelperFatal(e.Message, e);

System\ServiceModel\Dispatcher\OperationFormatter.cs (4)

156SRP.Format(SRP.SFxErrorDeserializingReplyBodyMore, _operationName, fe.Message), fe)); 161SRP.Format(SRP.SFxErrorDeserializingReplyBodyMore, _operationName, se.Message), se)); 225SRP.Format(SRP.SFxErrorDeserializingRequestBodyMore, _operationName, fe.Message), 231SRP.Format(SRP.SFxErrorDeserializingRequestBodyMore, _operationName, se.Message),

System\ServiceModel\Dispatcher\PrimitiveOperationFormatter.cs (4)

511SRP.Format(SRP.SFxErrorDeserializingReplyBodyMore, _operation.Name, fe.Message), fe)); 516SRP.Format(SRP.SFxErrorDeserializingReplyBodyMore, _operation.Name, se.Message), se)); 562SRP.Format(SRP.SFxErrorDeserializingRequestBodyMore, _operation.Name, fe.Message), 568SRP.Format(SRP.SFxErrorDeserializingRequestBodyMore, _operation.Name, se.Message),

System\ServiceModel\Dispatcher\XmlSerializerOperationFormatter.cs (2)

140SRP.Format(SRP.SFxErrorSerializingHeader, messageDescription.MessageName, e.Message), e)); 364SRP.Format(SRP.SFxErrorSerializingBody, messageDescription.MessageName, e.Message), e));

System\ServiceModel\ExceptionDetail.cs (1)

25Message = exception.Message;

System\ServiceModel\Security\WSSecurityTokenSerializer.cs (4)

286throw FxTrace.Exception.AsError(new MessageSecurityException(ex.Message)); 303throw FxTrace.Exception.AsError(new MessageSecurityException(ex.Message)); 320throw FxTrace.Exception.AsError(new MessageSecurityException(ex.Message)); 337throw FxTrace.Exception.AsError(new MessageSecurityException(ex.Message));

System\ServiceModel\WSAddressing10ProblemHeaderQNameFault.cs (2)

39_reason = new FaultReason(e.Message, CultureInfo.CurrentCulture); 49_reason = new FaultReason(e.Message, CultureInfo.CurrentCulture);

System.ServiceModel.Primitives.Tests (25)

Channels\CommunicationObjectTest.cs (8)

Channels\CustomChannelTest.cs (12)

251Assert.True(String.Equals(expectedExceptionMessage, actualException.Message), 253expectedExceptionMessage, actualException.Message)); 306Assert.True(String.Equals(expectedExceptionMessage, actualException.Message), 308expectedExceptionMessage, actualException.Message)); 471Assert.True(String.Equals(caughtException.Message, thrownException.Message), 473thrownException.Message, caughtException.Message)); 725Assert.True(string.Equals(thrownException.Message, caughtException.Message), 727thrownException.Message, caughtException.Message));

Description\OperationContractAttributeTest.cs (2)

34Assert.Contains("INonInitiatingNonTerminatingService", exception.Message); 47Assert.Contains("IInitiatingTerminatingService", exception.Message);

Security\SecurityNegotiationExceptionTest.cs (2)

24Assert.Equal(exceptionMessage, exception2.Message); 27Assert.Equal(exceptionMessage, exception3.InnerException.Message);

ServiceModel\DuplexChannelFactoryTest.cs (1)

109Assert.True(exception.Message.Contains("BasicHttpBinding"),

System.Text.Json (5)

System\Text\Json\JsonException.cs (1)

145return _message ?? base.Message;

System\Text\Json\Serialization\JsonConverterOfT.ReadCore.cs (1)

82case NotSupportedException when !ex.Message.Contains(" Path: "):

System\Text\Json\Serialization\JsonConverterOfT.WriteCore.cs (1)

41case NotSupportedException when !ex.Message.Contains(" Path: "):

System\Text\Json\ThrowHelper.Serialization.cs (2)

609string message = innerException.Message; 637string message = innerException.Message;

System.Text.RegularExpressions.Generator (2)

RegexGenerator.cs (1)

98return Diagnostic.Create(DiagnosticDescriptors.InvalidRegexArguments, method.DiagnosticLocation, e.Message);

RegexGenerator.Parser.cs (1)

157return Diagnostic.Create(DiagnosticDescriptors.InvalidRegexArguments, memberSyntax.GetLocation(), e.Message);

System.Threading.Tasks.Dataflow (1)

Internal\Common.cs (1)

141return exception.Message;

System.Windows.Forms (43)

System\Resources\ResXDataNode.cs (2)

308Debug.Fail($"Unexpected exception writing binary formatted data. {ex.Message}"); 375string newMessage = string.Format(SR.NotSupported, typeName, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X, nse.Message);

System\Resources\ResXResourceReader.cs (3)

376string newMessage = string.Format(SR.SerializationException, reader[ResXResourceWriter.TypeStr], pt.Y, pt.X, se.Message); 383string newMessage = string.Format(SR.InvocationException, reader[ResXResourceWriter.TypeStr], pt.Y, pt.X, tie.InnerException?.Message); 400XmlException xmlEx = new(e.Message, e, pt.Y, pt.X);

System\Windows\Forms\ActiveX\AxHost.AxPerPropertyBrowsingEnum.cs (1)

122Debug.Fail($"Failed to build IPerPropertyBrowsing editor. {ex.GetType().Name}, {ex.Message}");

System\Windows\Forms\ActiveX\AxHost.ConnectionPointCookie.cs (1)

53Debug.Fail(ex.Message);

System\Windows\Forms\ActiveX\AxHost.cs (1)

3393Debug.Fail(ex.Message);

System\Windows\Forms\ActiveX\AxHost.PropertyBagStream.cs (3)

39Debug.WriteLine($"PropertyBagStream: {nameof(NrbfDecoder)} failed with {ex.Message}"); 53Debug.Fail($"PropertyBagStream: {nameof(BinaryFormatter)} failed with {inner.Message}"); 114Debug.WriteLine($"PropertyBagStream.Save: {nameof(NrbfDecoder)} failed with {ex.Message}");

System\Windows\Forms\ActiveX\Control.ActiveXImpl.cs (1)

1525Debug.Fail($"Failed to write with BinaryFormatWriter: {ex.Message}");

System\Windows\Forms\ActiveX\Control.ActiveXImpl.PropertyBagStream.cs (1)

39Debug.Fail(e.Message);

System\Windows\Forms\Application.ComponentThreadContext.cs (1)

182Debug.Fail($"Unexpected exception thrown during Dispose: {ex.Message}");

System\Windows\Forms\ComponentModel\COM2Interop\Com2IPerPropertyBrowsingHandler.Com2IPerPropertyBrowsingEnum.cs (1)

152Debug.Fail($"Failed to build IPerPropertyBrowsing editor. {ex.GetType().Name}, {ex.Message}");

System\Windows\Forms\ComponentModel\COM2Interop\COM2PropertyDescriptor.cs (1)

652Debug.Fail($"Could not convert the native value to a .NET object: {ex.Message}");

System\Windows\Forms\ComponentModel\COM2Interop\COM2TypeInfoProcessor.cs (1)

812Debug.Fail($"Failed to process type info enum. {ex.Message}");

System\Windows\Forms\ComponentModel\COM2Interop\ComNativeDescriptor.cs (1)

158Debug.Fail(ex.Message);

System\Windows\Forms\Controls\Buttons\ButtonInternal\DarkMode\ButtonDarkModeAdapter.cs (1)

184Debug.Assert(false, $"Exception in PaintOver: {ex.Message}");

System\Windows\Forms\Controls\DataGridView\DataGridView.Methods.cs (1)

16722Debug.Fail($"DataGridView.OnPaint exception: {ex.Message} stack trace {ex.StackTrace}");

System\Windows\Forms\Controls\MonthCalendar\MonthCalendar.cs (1)

2109Debug.Fail($"NotifyWinEvent failed: {ex.Message}");

System\Windows\Forms\Controls\PropertyGrid\PropertyGrid.cs (2)

1647Debug.Fail($"{nameof(CreatePropertyTab)} failed. {exception.Message}"); 1684Debug.Fail($"Failed to create {nameof(PropertyTab)}. {exception.Message}");

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\CommandsPane.cs (1)

128ex.Message,

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\GridEntry.cs (3)

1101e.Message, 1400Debug.Fail($"Failed to get properties: {e.GetType().Name},{e.Message}\n{e.StackTrace}"); 1444Debug.Fail($"Bad Type Converter! {t.GetType().Name}, {t.Message},{converter}", t.ToString());

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\ImmutablePropertyDescriptorGridEntry.cs (1)

76if (string.IsNullOrEmpty(e.Message))

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\MultiPropertyDescriptorGridEntry.cs (1)

147Debug.Fail(e.Message);

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\PropertyDescriptorGridEntry.ExceptionConverter.cs (1)

27return ex.Message;

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\PropertyDescriptorGridEntry.ExceptionEditor.cs (1)

27string message = ex.Message;

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\PropertyGridView.cs (6)

3375Debug.Fail(ex.Message); 3402Debug.Fail(ex.Message); 4952string? exMessage = ex?.Message; 4964exMessage = ex.Message; 5025string? message = ex?.Message; 5037message = ex.Message;

System\Windows\Forms\Controls\TextBox\MaskedTextBox.cs (1)

2345message = $"{exception.GetType()}: {exception.Message}";

System\Windows\Forms\DataBinding\Binding.cs (1)

601errorText = ex.Message;

System\Windows\Forms\Dialogs\ThreadExceptionDialog.cs (2)

104messageText = w.Message; 116messageText = t.Message;

System\Windows\Forms\Internal\Formatter.cs (2)

390throw new FormatException(ex.Message, ex); 485throw new FormatException(ex.InnerException?.Message, ex.InnerException);

System.Windows.Forms.Analyzers.CSharp (1)

System\Windows\Forms\CSharp\Generators\ApplicationConfiguration\ProjectFileReader.cs (1)

93ex.Message);

System.Windows.Forms.Design (35)

System\ComponentModel\Design\BinaryEditor.BinaryUI.cs (1)

121RTLAwareMessageBox.Show(null, string.Format(SR.BinaryEditorFileError, x.Message),

System\ComponentModel\Design\CollectionEditor.CollectionForm.cs (1)

157string message = e.Message;

System\ComponentModel\Design\DesignerActionPanel.EditorPropertyLine.cs (1)

46ActionPanel.ShowError(string.Format(SR.DesignerActionPanel_ErrorActivatingDropDown, ex.Message));

System\ComponentModel\Design\DesignerActionPanel.MethodLine.cs (1)

76ActionPanel.ShowError(string.Format(SR.DesignerActionPanel_ErrorInvokingAction, _methodItem!.DisplayName, Environment.NewLine + ex.Message));

System\ComponentModel\Design\DesignerActionPanel.PropertyLine.cs (1)

85ActionPanel.ShowError(string.Format(SR.DesignerActionPanel_ErrorSettingValue, newValue, PropertyDescriptor.Name, e.Message));

System\ComponentModel\Design\DesignerHost.cs (1)

343string message = e.Message;

System\ComponentModel\Design\DesignSurface.cs (1)

140throw new InvalidOperationException(ex.Message, ex);

System\ComponentModel\Design\Serialization\CodeDomDesignerLoader.cs (1)

141sw.WriteLine($"Error during declaration dump: {ex.Message}");

System\ComponentModel\Design\Serialization\CodeDomSerializerException.cs (2)

19public CodeDomSerializerException(Exception? ex, CodeLinePragma? linePragma) : base(ex?.Message, ex) 29public CodeDomSerializerException(Exception? ex, IDesignerSerializationManager manager) : base(ex?.Message, ex)

System\ComponentModel\Design\Serialization\EventMemberCodeDomSerializer.cs (1)

69manager.ReportError(new CodeDomSerializerException(string.Format(SR.SerializerPropertyGenFailed, eventToSerialize.Name, e.Message), manager));

System\ComponentModel\Design\Serialization\PropertyMemberCodeDomSerializer.cs (2)

57manager.ReportError(new CodeDomSerializerException(string.Format(SR.SerializerPropertyGenFailed, property.Name, e.Message), manager)); 123manager.ReportError(new CodeDomSerializerException(string.Format(SR.SerializerPropertyGenFailed, propertyToSerialize.Name, e.Message), manager));

System\ComponentModel\Design\Serialization\ResourceCodeDomSerializer.SerializationResourceManager.cs (1)

255string message = e.Message;

System\Windows\Forms\Design\ChangeToolStripParentVerb.cs (1)

103uiService.ShowError(e.Message);

System\Windows\Forms\Design\CommandSet.CommandSetItem.cs (1)

185_uiService?.ShowError(e, string.Format(SR.CommandSetError, e.Message));

System\Windows\Forms\Design\ComponentTray.cs (1)

834string message = e.Message;

System\Windows\Forms\Design\ControlDesigner.cs (2)

427string message = e.Message; 2505string.Format(SR.ControlDesigner_WndProcException, typeName, exception.Message, stack),

System\Windows\Forms\Design\DataGridViewDesigner.cs (1)

701string message = ex.Message;

System\Windows\Forms\Design\ListViewDesigner.cs (1)

194string message = ex.Message;

System\Windows\Forms\Design\OleDragDropHandler.cs (1)

224exceptionMessage = ex.Message;

System\Windows\Forms\Design\SelectionUIService.cs (1)

128string message = e.Message;

System\Windows\Forms\Design\SplitContainerDesigner.cs (1)

327uiService?.ShowError(ex.Message);

System\Windows\Forms\Design\StandardMenuStripVerb.cs (2)

224uiService.ShowError(e.Message); 360uiService.ShowError(e.Message);

System\Windows\Forms\Design\TableLayoutPanelDesigner.cs (5)

1689uiService.ShowError(ex.Message); 1766uiService.ShowError(ex.Message); 1928uiService.ShowError(ex.Message); 2023uiService.ShowError(ex.Message); 2042uiService.ShowError(ex.Message);

System\Windows\Forms\Design\ToolStripDesigner.cs (1)

2450GetService<IUIService>().ShowError(ex.Message);

System\Windows\Forms\Design\ToolStripItemCustomMenuItemCollection.cs (2)

246uiService.ShowError(ex.Message); 611uiService.ShowError(ex.Message);

System\Windows\Forms\Design\ToolStripMenuItemDesigner.cs (1)

806GetService<IUIService>().ShowError(ex.Message);

System.Windows.Forms.Design.Tests (6)

System\ComponentModel\Design\DesignSurfaceTests.cs (2)

456.Setup(e => e.Message) 473Assert.Contains("ExceptionText", error.Message);

System\ComponentModel\Design\Serialization\CodeDomSerializerExceptionTests.cs (4)

27Assert.NotEmpty(exception.Message); 43Assert.NotEmpty(exception.Message); 60Assert.NotEmpty(exception.Message); 77Assert.NotEmpty(exception.Message);

System.Windows.Forms.Primitives.TestUtilities (3)

Extensions\AssertExtensions.cs (3)

30Assert.Equal(expectedMessage, Assert.Throws<T>(action).Message); 36Assert.Contains(expectedMessageContent, Assert.Throws<T>(action).Message); 548{e.Message}

System.Windows.Forms.Tests (2)

System\Windows\Forms\Application.ParkingWindowTests.cs (1)

31Assert.True(ex is null, $"Expected no exception, but got: {ex.Message}"); // Actually need to check whether GC.Collect() does not throw exception.

System\Windows\Forms\NativeToWinFormsAdapterTests.cs (1)

361ex.Should().BeOfType<NotSupportedException>().Which.Message.Should().Be(FormatterDisabledMessage);

System.Windows.Forms.UI.IntegrationTests (2)

DataGridViewTests.cs (1)

83throw new InvalidOperationException(ex.Message);

DesignBehaviorsTests.cs (1)

30throw new InvalidOperationException(e.Exception.Message, e.Exception);

System.Xaml (6)

System\Xaml\InfosetObjects\XamlObjectWriter.cs (1)

2200throw ctx.WithLineInfo(new XamlObjectWriterException(SR.Format(SR.NameScopeException, ex.Message), ex));

System\Xaml\Parser\GenericTypeNameParser.cs (2)

85error = ex.Message; 115error = ex.Message;

System\Xaml\XamlException.cs (3)

45return SR.Format(SR.LineNumberAndPosition, base.Message, LineNumber, LinePosition); 48return SR.Format(SR.LineNumberOnly, base.Message, LineNumber); 51return base.Message;

TaskUsageLogger (1)

TaskUsageLogger.cs (1)

129throw new LoggerException(String.Format(CultureInfo.CurrentCulture, "Failed to load and read task registration information from project '{0}'. {1}", e.ProjectFile, ex.Message));

Templates.Blazor.Tests (17)

src\ProjectTemplates\Shared\Project.cs (1)

501DiagnosticsMessageSink.OnMessage(new DiagnosticMessage($"Failed to delete directory {TemplateOutputDir} because of error {ex.Message}. Will try again {numAttemptsRemaining - 1} more time(s)."));

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (3)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (11)

src\Shared\Process\ProcessExtensions.cs (2)

73catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory")) 89catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory"))

Templates.Blazor.WebAssembly.Auth.Tests (18)

src\ProjectTemplates\Shared\Project.cs (1)

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (3)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (11)

src\Shared\E2ETesting\BrowserFixture.cs (1)

223output.WriteLine($"Error initializing RemoteWebDriver: {ex.Message}");

src\Shared\Process\ProcessExtensions.cs (2)

73catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory")) 89catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory"))

Templates.Blazor.WebAssembly.Tests (18)

src\ProjectTemplates\Shared\Project.cs (1)

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (3)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (11)

src\Shared\E2ETesting\BrowserFixture.cs (1)

223output.WriteLine($"Error initializing RemoteWebDriver: {ex.Message}");

src\Shared\Process\ProcessExtensions.cs (2)

73catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory")) 89catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory"))

Templates.Mvc.Tests (18)

src\ProjectTemplates\Shared\Project.cs (1)

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (3)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (11)

src\Shared\E2ETesting\BrowserFixture.cs (1)

223output.WriteLine($"Error initializing RemoteWebDriver: {ex.Message}");

src\Shared\Process\ProcessExtensions.cs (2)

73catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory")) 89catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory"))

Templates.Tests (18)

src\ProjectTemplates\Shared\Project.cs (1)

src\Shared\CertificateGeneration\MacOSCertificateManager.cs (3)

src\Shared\CertificateGeneration\UnixCertificateManager.cs (11)

src\Shared\E2ETesting\BrowserFixture.cs (1)

223output.WriteLine($"Error initializing RemoteWebDriver: {ex.Message}");

src\Shared\Process\ProcessExtensions.cs (2)

73catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory")) 89catch (Win32Exception ex) when (ex.Message.Contains("No such file or directory"))

Test.Utilities (12)

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

TestDiscoveryWorker (1)

Program.cs (1)

100Console.WriteLine(e.Message);

Text.Analyzers (13)

IdentifiersShouldBeSpelledCorrectly.cs (1)

281var diagnostic = Diagnostic.Create(FileParseRule, Location.None, additionalText.Path, exception.Message);

src\Compilers\Core\Portable\FileSystem\FileUtilities.cs (9)

src\Compilers\Core\Portable\InternalUtilities\StringExtensions.cs (1)

262error = ex.Message;

src\Dependencies\Contracts\ErrorReporting\FailFast.cs (1)

76Console.WriteLine(current.Message);

src\Dependencies\Contracts\ErrorReporting\FatalError.cs (1)

25: base(innerException.Message, innerException)

UIAutomationClientSideProviders (3)

MS\Internal\AutomationProxies\Accessible.cs (1)

1370Debug.Fail(string.Format(CultureInfo.CurrentCulture, "MsaaNativeProvider: IAccessible threw a COMException: {0}", e.Message));

MS\Internal\AutomationProxies\WinEventTracker.cs (2)

264Debug.Fail("Exception raising event " + eventId + " for prop " + ecp._idProp + " on hwnd " + hwnd + "\n" + e.Message); 309Debug.Fail("Exception raising event " + eventId + " for prop " + ecp._idProp + " on hwnd " + hwnd + "\n" + e.Message);

UnitTests.Common (1)

TestTypes.cs (1)

123this.ErrorMessage = (ex == null) ? "unexpected" : ex.Message;

vbc (6)

src\Compilers\Shared\BuildServerConnection.cs (4)

src\Compilers\Shared\CompilerServerLogger.cs (2)

84builder.AppendLine($"Error: '{exception.GetType().Name}' '{exception.Message}' occurred during '{reason}'"); 139Debug.Assert(false, e.Message);

VBCSCompiler (8)

src\Compilers\Server\VBCSCompiler\AnalyzerConsistencyChecker.cs (1)

67errorMessages.Add(e.Message);

src\Compilers\Server\VBCSCompiler\ClientConnectionHandler.cs (1)

142response = new RejectedBuildResponse($"Exception during compilation: {ex.Message}");

src\Compilers\Shared\BuildServerConnection.cs (4)

src\Compilers\Shared\CompilerServerLogger.cs (2)

84builder.AppendLine($"Error: '{exception.GetType().Name}' '{exception.Message}' occurred during '{reason}'"); 139Debug.Assert(false, e.Message);

WindowsBase.Tests (14)

System\Security\RightsManagement\RightsManagementExceptionTests.cs (14)

WinFormsControlsTest (3)

PictureBoxes.cs (2)

39MessageBox.Show(ex.Message); 55MessageBox.Show(e.Error.Message, $"{e.Error.GetType().FullName} occurred");

RichTextBoxes.cs (1)

105MessageBox.Show(this, ex.Message);

XmlFormattersWebSite (1)

Controllers\ValidationController.cs (1)

42errorMessage = modelError.Exception.Message;

xunit.assert (5)

Sdk\Exceptions\AllException.cs (1)

73 error.Item3.Message.Replace(Environment.NewLine, wrapSpaces, StringComparison.Ordinal)

Sdk\Exceptions\CollectionException.cs (1)

44 var text = innerException.Message;

Sdk\Exceptions\EqualException.cs (1)

113 return new EqualException("Assert.Equal() Failure: " + error.Message);

Sdk\Exceptions\NotEqualException.cs (1)

90 return new NotEqualException("Assert.NotEqual() Failure: " + error.Message);

Sdk\Exceptions\XunitException.cs (1)

63 var message = Message;

xunit.console (2)

ConsoleRunner.cs (2)

108Console.WriteLine($"error: {ex.Message}"); 421Console.WriteLine($"{e.GetType().FullName}: {e.Message}");