Message

33 overrides of Message

dotnet-svcutil-lib (5)

FrameworkFork\Microsoft.Xml\Xml\schema\XmlSchemaException.cs (1)

185public override string Message

FrameworkFork\Microsoft.Xml\Xml\XmlException.cs (1)

249public override string Message

FrameworkFork\Microsoft.Xml\Xml\XPath\XPathException.cs (1)

83public override string Message

FrameworkFork\System.ServiceModel\System\ServiceModel\Description\WsdlImporter.cs (1)

1960public override string Message

FrameworkFork\System.ServiceModel\System\ServiceModel\FaultException.cs (1)

136public override string Message

Microsoft.AspNetCore.Identity (1)

SignInManager.cs (1)

1551public override string Message

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

ModelBinding\ModelStateDictionaryTest.cs (1)

1774public override string Message { get; }

Microsoft.CodeAnalysis.Test.Utilities (1)

Diagnostics\ThrowingDiagnosticAnalyzer.cs (1)

37public override string Message

Microsoft.Extensions.Options (1)

OptionsValidationException.cs (1)

48public override string Message => string.Join("; ", Failures);

PresentationFramework (1)

MS\Internal\PtsHost\Pts.cs (1)

279public override string Message

System.ComponentModel.Composition (1)

System\ComponentModel\Composition\CompositionException.cs (1)

118public override string Message

System.Configuration.ConfigurationManager (1)

System\Configuration\ConfigurationException.cs (1)

67public override string Message

System.Diagnostics.EventLog (1)

artifacts\obj\System.Diagnostics.EventLog\Debug\net10.0\System.Diagnostics.EventLog.notsupported.cs (1)

237public override string Message { get { throw new System.PlatformNotSupportedException(System.SR.PlatformNotSupported_EventLog); } }

System.DirectoryServices (1)

artifacts\obj\System.DirectoryServices\Debug\net10.0\System.DirectoryServices.notsupported.cs (1)

756public override string Message { get { throw new System.PlatformNotSupportedException(System.SR.DirectoryServices_PlatformNotSupported); } }

System.Net.Http (1)

artifacts\obj\System.Net.Http\Debug\net10.0\System.Net.Http.notsupported.cs (1)

209public override string Message { get { throw new System.PlatformNotSupportedException(System.SR.PlatformNotSupported_NetHttp); } }

System.Net.Primitives (1)

artifacts\obj\System.Net.Primitives\Debug\net10.0\System.Net.Primitives.notsupported.cs (1)

535public override string Message { get { throw new System.PlatformNotSupportedException(System.SR.PlatformNotSupported_NetPrimitives); } }

System.Private.CoreLib (10)

src\libraries\System.Private.CoreLib\src\System\AggregateException.cs (1)

339public override string Message

src\libraries\System.Private.CoreLib\src\System\ArgumentException.cs (1)

73public override string Message

src\libraries\System.Private.CoreLib\src\System\BadImageFormatException.cs (1)

70public override string Message

src\libraries\System.Private.CoreLib\src\System\IO\FileLoadException.cs (1)

45public override string Message => _message ??= FormatFileLoadExceptionMessage(FileName, HResult);

src\libraries\System.Private.CoreLib\src\System\IO\FileNotFoundException.cs (1)

48public override string Message

src\libraries\System.Private.CoreLib\src\System\MissingMemberException.cs (1)

59public override string Message

src\libraries\System.Private.CoreLib\src\System\ObjectDisposedException.cs (1)

89public override string Message

src\libraries\System.Private.CoreLib\src\System\Reflection\ReflectionTypeLoadException.cs (1)

49public override string Message => CreateString(isMessage: true);

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\SwitchExpressionException.cs (1)

53public override string Message

src\libraries\System.Private.CoreLib\src\System\TypeLoadException.cs (1)

41public override string Message

System.Private.Xml (4)

System\Xml\Schema\XmlSchemaException.cs (1)

217public override string Message

System\Xml\XmlException.cs (1)

276public override string Message

System\Xml\XPath\XPathException.cs (1)

122public override string Message

System\Xml\Xslt\XsltException.cs (1)

116public override string Message

System.ServiceModel.Primitives (1)

netstandard.cs (1)

741public override string Message { get { return default; } }

System.Text.Json (1)

System\Text\Json\JsonException.cs (1)

141public override string Message

System.Xaml (1)

System\Xaml\XamlException.cs (1)

37public override string Message

3992 references to Message

aspire (29)

Commands\AddCommand.cs (5)

164catch (ProjectLocatorException ex) when (string.Equals(ex.Message, ErrorStrings.ProjectFileDoesntExist, StringComparisons.CliInputOrOutput)) 169catch (ProjectLocatorException ex) when (string.Equals(ex.Message, ErrorStrings.MultipleProjectFilesFound, StringComparisons.CliInputOrOutput)) 174catch (ProjectLocatorException ex) when (string.Equals(ex.Message, ErrorStrings.NoProjectFileFound, StringComparisons.CliInputOrOutput)) 186_interactionService.DisplayError(ex.Message); 192_interactionService.DisplayError(string.Format(CultureInfo.CurrentCulture, AddCommandStrings.ErrorOccurredWhileAddingPackage, ex.Message));

Commands\ConfigCommand.cs (2)

158_interactionService.DisplayError(string.Format(CultureInfo.CurrentCulture, ErrorStrings.ErrorSettingConfiguration, ex.Message)); 260_interactionService.DisplayError(string.Format(CultureInfo.CurrentCulture, ErrorStrings.ErrorDeletingConfiguration, ex.Message));

Commands\ExecCommand.cs (6)

241catch (ProjectLocatorException ex) when (string.Equals(ex.Message, ErrorStrings.ProjectFileDoesntExist, StringComparisons.CliInputOrOutput)) 246catch (ProjectLocatorException ex) when (string.Equals(ex.Message, ErrorStrings.MultipleProjectFilesFound, StringComparisons.CliInputOrOutput)) 251catch (ProjectLocatorException ex) when (string.Equals(ex.Message, ErrorStrings.NoProjectFileFound, StringComparisons.CliInputOrOutput)) 265_interactionService.DisplayError(string.Format(CultureInfo.CurrentCulture, TemplatingStrings.CertificateTrustError, ex.Message)); 270_interactionService.DisplayError(string.Format(CultureInfo.CurrentCulture, InteractionServiceStrings.ErrorConnectingToAppHost, ex.Message)); 276_interactionService.DisplayError(string.Format(CultureInfo.CurrentCulture, InteractionServiceStrings.UnexpectedErrorOccurred, ex.Message));

Commands\PublishCommandBase.cs (6)

192catch (ProjectLocatorException ex) when (string.Equals(ex.Message, ErrorStrings.ProjectFileNotAppHostProject, StringComparisons.CliInputOrOutput)) 197catch (ProjectLocatorException ex) when (string.Equals(ex.Message, ErrorStrings.ProjectFileDoesntExist, StringComparisons.CliInputOrOutput)) 202catch (ProjectLocatorException ex) when (string.Equals(ex.Message, ErrorStrings.MultipleProjectFilesFound, StringComparisons.CliInputOrOutput)) 207catch (ProjectLocatorException ex) when (string.Equals(ex.Message, ErrorStrings.NoProjectFileFound, StringComparisons.CliInputOrOutput)) 221_interactionService.DisplayError(string.Format(CultureInfo.CurrentCulture, InteractionServiceStrings.ErrorConnectingToAppHost, ex.Message)); 227_interactionService.DisplayError(string.Format(CultureInfo.CurrentCulture, InteractionServiceStrings.UnexpectedErrorOccurred, ex.Message));

Commands\RunCommand.cs (6)

253catch (ProjectLocatorException ex) when (string.Equals(ex.Message, ErrorStrings.ProjectFileDoesntExist, StringComparisons.CliInputOrOutput)) 258catch (ProjectLocatorException ex) when (string.Equals(ex.Message, ErrorStrings.MultipleProjectFilesFound, StringComparisons.CliInputOrOutput)) 263catch (ProjectLocatorException ex) when (string.Equals(ex.Message, ErrorStrings.NoProjectFileFound, StringComparisons.CliInputOrOutput)) 277_interactionService.DisplayError(string.Format(CultureInfo.CurrentCulture, TemplatingStrings.CertificateTrustError, ex.Message.EscapeMarkup())); 282_interactionService.DisplayError(string.Format(CultureInfo.CurrentCulture, InteractionServiceStrings.ErrorConnectingToAppHost, ex.Message.EscapeMarkup())); 288_interactionService.DisplayError(string.Format(CultureInfo.CurrentCulture, InteractionServiceStrings.UnexpectedErrorOccurred, ex.Message.EscapeMarkup()));

Interaction\ExtensionInteractionService.cs (2)

107DisplayError(ex.Message); 136DisplayError(ex.Message);

Templating\DotNetTemplateFactory.cs (2)

274interactionService.DisplayError(string.Format(CultureInfo.CurrentCulture, TemplatingStrings.CertificateTrustError, ex.Message)); 279interactionService.DisplayError(ex.Message);

Aspire.Azure.AI.OpenAI.Tests (4)

AspireAzureOpenAIClientBuilderChatClientExtensionsTests.cs (2)

129Assert.StartsWith("The connection string 'openai' contains both 'Deployment' and 'Model' keys.", ex.Message); 160Assert.StartsWith("The deployment could not be determined", ex.Message);

AspireAzureOpenAIClientBuilderEmbeddingGeneratorExtensionsTests.cs (2)

129Assert.StartsWith("The connection string 'openai' contains both 'Deployment' and 'Model' keys.", ex.Message); 160Assert.StartsWith("The deployment could not be determined", ex.Message);

Aspire.Azure.Messaging.WebPubSub.Tests (1)

AspireWebPubSubExtensionsTests.cs (1)

152Assert.Equal("A WebPubSubServiceClient could not be configured. Ensure a valid HubName was configured or provided in the 'Aspire:Azure:Messaging:WebPubSub' configuration section.", ex.Message);

Aspire.Azure.Npgsql.EntityFrameworkCore.PostgreSQL.Tests (4)

AspireAzureEFPostgreSqlExtensionsTests.cs (1)

283Assert.Equal("DbContext<TestDbContext> is already registered. Please ensure 'services.AddDbContext<TestDbContext>()' is not used when calling 'AddNpgsqlDbContext()' or use the corresponding 'Enrich' method.", exception.Message);

EnrichNpgsqlTests.cs (3)

38Assert.Equal("DbContext<TestDbContext> was not registered. Ensure you have registered the DbContext in DI before calling EnrichNpgsqlDbContext.", exception.Message); 113Assert.Equal("Conflicting values for 'CommandTimeout' were found in NpgsqlEntityFrameworkCorePostgreSQLSettings and set in DbContextOptions<TestDbContext>.", exception.Message); 319Assert.Equal("NpgsqlEntityFrameworkCorePostgreSQLSettings.DisableRetry needs to be set when a custom Execution Strategy is configured.", exception.Message);

Aspire.Cli.Tests (3)

Projects\ProjectLocatorTests.cs (2)

38Assert.Equal("Project file does not exist.", ex.Message); 229Assert.Equal("No project file found.", ex.Message);

Utils\TemporaryRepo.cs (1)

53Console.WriteLine($"Error disposing TemporaryRepo: {ex.Message}");

Aspire.Dashboard (5)

Configuration\DashboardOptions.cs (2)

332errorMessage = $"Error converting server certificate payload from base64 to bytes: {ex.Message}"; 342errorMessage = $"Error reading server certificate as X509Certificate2: {ex.Message}";

Model\DashboardCommandExecutor.cs (1)

65telemetryService.EndOperation(operationId, TelemetryResult.Failure, ex.Message);

Telemetry\TelemetryLoggerProvider.cs (2)

55$"{exception.GetType().FullName}: {exception.Message}", 60[TelemetryPropertyKeys.ExceptionMessage] = new AspireTelemetryProperty(exception.Message),

Aspire.Dashboard.Tests (5)

Integration\StartupTests.cs (1)

247Assert.Contains(fileConfigDirectory, ex.Message);

Model\ResourceViewModelTests.cs (1)

105Assert.Equal(@"Error converting resource ""TestName-abc"" to ResourceViewModel.", ex.Message);

OtlpApiKeyAuthenticationHandlerTests.cs (2)

29Assert.Equal($"API key from '{OtlpApiKeyAuthenticationHandler.ApiKeyHeaderName}' header is missing.", result.Failure.Message); 43Assert.Equal($"Incoming API key from '{OtlpApiKeyAuthenticationHandler.ApiKeyHeaderName}' header doesn't match configured API key.", result.Failure.Message);

TelemetryRepositoryTests\TraceTests.cs (1)

150Assert.Equal("Circular loop detected for span '312d31' with parent '312d31'.", write.Exception!.Message);

Aspire.EndToEnd.Tests (5)

tests\Shared\TemplatesTesting\AspireProject.cs (3)

368return ex.Message.Contains("net::ERR_NETWORK_CHANGED", StringComparison.OrdinalIgnoreCase) || 369ex.Message.Contains("net::ERR_SOCKET_NOT_CONNECTED", StringComparison.OrdinalIgnoreCase); 373_testOutput.WriteLine($"Reloading dashboard page due to {args.Outcome.Exception?.Message}");

tests\Shared\TemplatesTesting\BuildEnvironment.cs (1)

259Console.WriteLine($"\tFailed to delete {dir} : {ioex.Message}. Ignoring.");

tests\Shared\TemplatesTesting\TestExtensions.cs (1)

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

Aspire.Hosting (10)

ApplicationModel\ResourceCommandAnnotation.cs (2)

134/// Produces an unsuccessful result from an <see cref="Exception"/>. <see cref="Exception.Message"/> is used as the error message. 137public static ExecuteCommandResult Failure(Exception exception) => Failure(exception.Message);

Backchannel\BackchannelService.cs (1)

75logger.LogDebug("Backchannel service was cancelled: {Message}", ex.Message);

Dcp\DcpDependencyCheck.cs (1)

117$"{ex.Message} {errorStringBuilder.ToString()}{Environment.NewLine}{outputStringBuilder.ToString()}"

Dcp\DcpPipelineBuilder.cs (1)

25logger.LogDebug("Retrying check for deleted resource. Attempt: {Attempt}. Error message: {ErrorMessage}", retry.AttemptNumber, retry.Outcome.Exception?.Message);

Devcontainers\DevcontainerSettingsWriter.cs (1)

190catch (IOException ex) when (ex.Message == $"The file '{path}' already exists.")

DistributedApplicationRunner.cs (2)

63await activityReporter.CompletePublishAsync(completionMessage: ex.Message, CompletionState.CompletedWithError, stoppingToken).ConfigureAwait(false); 67throw new DistributedApplicationException($"Publishing failed exception message: {ex.Message}", ex);

Exec\ExecResourceManager.cs (1)

78Text = execResourceInitializationException.Message,

Orchestrator\ParameterProcessor.cs (1)

109Properties = s.Properties.SetResourceProperty(KnownProperties.Parameter.Value, ex.Message)

Aspire.Hosting.Azure (1)

AzurePublishingContext.cs (1)

99await writeTask.FailAsync($"Failed to write Azure Bicep templates: {ex.Message}", cancellationToken).ConfigureAwait(false);

Aspire.Hosting.Azure.AIFoundry (2)

AzureAIFoundryExtensions.cs (2)

188logger.LogInformation("Foundry Local could not be started. Ensure it's installed correctly: https://learn.microsoft.com/azure/ai-foundry/foundry-local/get-started (Error: {Error}).", e.Message); 274logger.LogInformation("Failed to start {Model}. Error: {Error}", model, e.Message);

Aspire.Hosting.Azure.Tests (13)

AzureAppServiceTests.cs (1)

310Assert.Contains("there are no 'AzureAppServiceEnvironmentResource' resources", ex.Message);

AzureContainerAppsTests.cs (8)

745Assert.Equal("Automatic Key vault generation is not supported in this environment. Please create a key vault resource directly.", ex.Message); 1061Assert.Equal("The endpoint(s) 'foo' specify an unsupported scheme. The supported schemes are 'http', 'https', and 'tcp'.", ex.Message); 1082Assert.Equal("Multiple external endpoints are not supported", ex.Message); 1101Assert.Equal("External non-HTTP(s) endpoints are not supported", ex.Message); 1121Assert.Equal("HTTP(s) and TCP endpoints cannot be mixed", ex.Message); 1140Assert.Equal($"The endpoint 'http' is an http endpoint and must use port 80", ex.Message); 1159Assert.Equal($"The endpoint 'https' is an https endpoint and must use port 443", ex.Message); 1526Assert.Contains("there are no 'AzureContainerAppEnvironmentResource' resources", ex.Message);

AzureResourceOptionsTests.cs (1)

59output.WriteLine($"Failed to delete {tempDir.FullName} : {ex.Message}. Ignoring.");

AzureResourcePreparerTests.cs (1)

32Assert.Contains("role assignments", ex.Message);

DefaultProvisioningContextProviderTests.cs (2)

85Assert.Contains("Azure subscription id is required", exception.Message); 112Assert.Contains("azure location/region is required", exception.Message);

Aspire.Hosting.Containers.Tests (4)

ContainerResourceBuilderTests.cs (3)

83Assert.Equal("The resource 'testcontainer' does not have a container image specified. Use WithImage to specify the container image and tag.", exception.Message); 93Assert.Equal("The resource 'testcontainer' does not have a container image specified. Use WithImage to specify the container image and tag.", exception.Message); 103Assert.Equal("The resource 'testcontainer' does not have a container image specified. Use WithImage to specify the container image and tag.", exception.Message);

WithDockerfileTests.cs (1)

601ex.Message

Aspire.Hosting.Docker.Tests (2)

DockerComposeTests.cs (1)

103Assert.Contains("there are no 'DockerComposeEnvironmentResource' resources", ex.Message);

EnvVarEscaperTests.cs (1)

84Assert.Contains("Maximum recursion depth exceeded", ex.Message);

Aspire.Hosting.GitHub.Models (1)

GitHubModelsHealthCheck.cs (1)

66_result = HealthCheckResult.Unhealthy($"Failed to check GitHub Models endpoint: {ex.Message}", ex);

Aspire.Hosting.Kubernetes.Tests (1)

KubernetesEnvironmentResourceTests.cs (1)

51Assert.Contains("there are no 'KubernetesEnvironmentResource' resources", ex.Message);

Aspire.Hosting.Testing.Tests (4)

TestingBuilderTests.cs (3)

73Assert.Contains("does not have an entry point", ioe.Message); 453Assert.Contains(crashArg, exception.Message); 471Assert.Contains(crashArg, exception.Message);

TestingFactoryCrashTests.cs (1)

28Assert.Contains(crashArg, exception.Message);

Aspire.Hosting.Tests (55)

Dcp\DcpExecutorTests.cs (4)

374Assert.Contains("cannot be proxied when both TargetPort and Port are specified with the same value", exception.Message); 526Assert.Contains(tc.ErrorMessageFragment, exception.Message); 965Assert.Contains(tc.ErrorMessageFragment, exception.Message); 1144Assert.Equal($"Failed to delete '{dcpCtr.Metadata.Name}' successfully before restart.", ex.Message);

Dcp\TestKubernetesService.cs (2)

117throw new HttpOperationException(ex.Message) 119Response = new HttpResponseMessageWrapper(new HttpResponseMessage { StatusCode = System.Net.HttpStatusCode.NotFound }, ex.Message)

DistributedApplicationBuilderExtensionsTests.cs (2)

13Assert.Contains("not found", missingException.Message); 22Assert.Contains("not assignable", incorrectTypeException.Message);

DistributedApplicationBuilderTests.cs (4)

135Assert.Equal("Cannot add resource of type 'Aspire.Hosting.ApplicationModel.ContainerResource' with name 'Test' because resource of type 'Aspire.Hosting.ApplicationModel.ContainerResource' with that name already exists. Resource names are case-insensitive.", ex.Message); 146Assert.Equal("Cannot add resource of type 'Aspire.Hosting.ApplicationModel.ContainerResource' with name 'TEST' because resource of type 'Aspire.Hosting.ApplicationModel.ContainerResource' with that name already exists. Resource names are case-insensitive.", ex.Message); 158Assert.Equal("Multiple resources with the name 'Test'. Resource names are case-insensitive.", ex.Message); 170Assert.Equal("Multiple resources with the name 'Test'. Resource names are case-insensitive.", ex.Message);

DistributedApplicationRunnerTests.cs (1)

23e => Assert.Equal("Publishing failed exception message: Boom!", e.Message)

DistributedApplicationTests.cs (6)

67Assert.Equal(exceptionMessage, ex.Message); 108Assert.Equal(exceptionMessage, ex.Message); 405Assert.Equal(exceptionMessage, ex.InnerExceptions.First().Message); 1016Assert.Equal($"Resource '{testName}-servicea-{suffix}' uses multiple replicas and a proxy-less endpoint 'http'. These features do not work together.", ex.Message); 1035Assert.Equal($"Service '{testName}-servicea-{suffix}' needs to specify a port for endpoint 'http' since it isn't using a proxy.", ex.Message); 1265Assert.Equal($"The endpoint 'tcp' for container resource '{testName}-redis' must specify the TargetPort value", ex.Message);

HealthCheckTests.cs (3)

32ex.Message 52ex.Message 73ex.Message

Orchestrator\ApplicationOrchestratorTests.cs (1)

341Assert.Contains("Circular dependency detected", e.Message);

ProjectResourceTests.cs (3)

30Assert.Equal(expectedMessage, ex.Message); 275Assert.Equal("Project file 'another-path' was not found.", ex.Message); 285Assert.Equal("Launch settings file does not contain 'not-exist' profile.", ex.Message);

Publishing\PublishingActivityReporterTests.cs (11)

Publishing\ResourceContainerImageBuilderTests.cs (1)

409Assert.Equal("Container runtime is not running or is unhealthy.", exception.Message);

PublishingTests.cs (1)

253Assert.Contains("Deploy failed!", ex.Message);

ResourceExtensionsTests.cs (1)

309Assert.Contains("'compute1, compute2'", ex.Message);

WaitForTests.cs (7)

49Assert.Equal("The 'test' resource cannot wait for itself.", waitForEx.Message); 56Assert.Equal("The 'test' resource cannot wait for itself.", waitForCompletionEx.Message); 71Assert.Equal("The 'child' resource cannot wait for its parent 'parent'.", waitForEx.Message); 78Assert.Equal("The 'child' resource cannot wait for its parent 'parent'.", waitForCompletionEx.Message); 248Assert.Equal("Stopped waiting for resource 'redis' to become healthy because it failed to start.", ex.Message); 272Assert.Equal("The operation has timed out.", ex.Message); 301Assert.Equal(exceptionMessage, ex.Message);

WithEndpointTests.cs (4)

167Assert.Equal("Endpoint with name 'mybinding' already exists. Endpoint name may not have been explicitly specified and was derived automatically from scheme argument (e.g. 'http', 'https', or 'tcp'). Multiple calls to WithEndpoint (and related methods) may result in a conflict if name argument is not specified. Each endpoint must have a unique name. For more information on networking in .NET Aspire see: https://aka.ms/dotnet/aspire/networking", ex.Message); 182Assert.Equal("Endpoint with name 'https' already exists. Endpoint name may not have been explicitly specified and was derived automatically from scheme argument (e.g. 'http', 'https', or 'tcp'). Multiple calls to WithEndpoint (and related methods) may result in a conflict if name argument is not specified. Each endpoint must have a unique name. For more information on networking in .NET Aspire see: https://aka.ms/dotnet/aspire/networking", ex.Message); 196Assert.Equal("Endpoint with name 'mybinding' already exists. Endpoint name may not have been explicitly specified and was derived automatically from scheme argument (e.g. 'http', 'https', or 'tcp'). Multiple calls to WithEndpoint (and related methods) may result in a conflict if name argument is not specified. Each endpoint must have a unique name. For more information on networking in .NET Aspire see: https://aka.ms/dotnet/aspire/networking", ex.Message); 240Assert.Equal("The endpoint \"ep\" has no associated container host name.", ex.Message);

WithEnvironmentTests.cs (1)

169Assert.Equal("Parameter resource could not be used because configuration key 'Parameters:parameter' is missing and the Parameter has no default value.", exception.Message);

WithHttpCommandTests.cs (2)

52ex.Message 74ex.Message

WithReferenceTests.cs (1)

198Assert.Equal("Connection string parameter resource could not be used because connection string 'missingresource' is missing.", exception.Message);

Aspire.Keycloak.Authentication.Tests (4)

AspireKeycloakExtensionTests.cs (4)

33Assert.Equal("The MetadataAddress or Authority must use HTTPS unless disabled for development by setting RequireHttpsMetadata=false.", exception.Message); 52Assert.Equal("The MetadataAddress or Authority must use HTTPS unless disabled for development by setting RequireHttpsMetadata=false.", exception.Message); 114Assert.Equal("The MetadataAddress or Authority must use HTTPS unless disabled for development by setting RequireHttpsMetadata=false.", exception.Message); 133Assert.Equal("The MetadataAddress or Authority must use HTTPS unless disabled for development by setting RequireHttpsMetadata=false.", exception.Message);

Aspire.Microsoft.Azure.Cosmos.Tests (5)

AspireMicrosoftAzureCosmosExtensionsTests.cs (5)

171Assert.Equal("The connection string 'cosmos-key' does not exist or is missing the container name or database name.", exception.Message); 188Assert.Equal("The connection string 'cosmos-key' does not exist or is missing the container name or database name.", exception.Message); 204Assert.Equal("A Database could not be configured. Ensure valid connection information was provided in 'ConnectionStrings:cosmos-key'.", exception.Message); 220Assert.Equal("A Database could not be configured. Ensure valid connection information was provided in 'ConnectionStrings:cosmos-key'.", exception.Message); 492Assert.Contains("A Container could not be configured", exception.Message);

Aspire.Microsoft.Data.SqlClient (1)

src\Vendoring\OpenTelemetry.Instrumentation.SqlClient\Implementation\SqlClientDiagnosticListener.cs (1)

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

Aspire.Microsoft.EntityFrameworkCore.Cosmos.Tests (6)

AspireAzureEfCoreCosmosDBExtensionsTests.cs (4)

174Assert.Equal("DbContext<TestDbContext> is already registered. Please ensure 'services.AddDbContext<TestDbContext>()' is not used when calling 'AddCosmosDbContext()' or use the corresponding 'Enrich' method.", exception.Message); 314Assert.Contains("A DbContext could not be configured with this AddCosmosDbContext overload.", exception.Message); 327Assert.Contains("A DbContext could not be configured.", exception.Message); 339Assert.Contains("A DbContext could not be configured with this AddCosmosDbContext overload.", exception.Message);

EnrichCosmosDbTests.cs (2)

32Assert.Equal("DbContext<TestDbContext> was not registered. Ensure you have registered the DbContext in DI before calling EnrichCosmosDbContext.", exception.Message); 135Assert.Equal("Conflicting values for 'RequestTimeout' were found in EntityFrameworkCoreCosmosSettings and set in DbContextOptions<TestDbContext>.", exception.Message);

Aspire.Microsoft.EntityFrameworkCore.SqlServer (1)

src\Vendoring\OpenTelemetry.Instrumentation.SqlClient\Implementation\SqlClientDiagnosticListener.cs (1)

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

Aspire.Microsoft.EntityFrameworkCore.SqlServer.Tests (4)

AspireSqlServerEFCoreSqlClientExtensionsTests.cs (1)

275Assert.Equal("DbContext<TestDbContext> is already registered. Please ensure 'services.AddDbContext<TestDbContext>()' is not used when calling 'AddSqlServerDbContext()' or use the corresponding 'Enrich' method.", exception.Message);

EnrichSqlServerTests.cs (3)

36Assert.Equal("DbContext<TestDbContext> was not registered. Ensure you have registered the DbContext in DI before calling EnrichSqlServerDbContext.", exception.Message); 109Assert.Equal("Conflicting values for 'CommandTimeout' were found in MicrosoftEntityFrameworkCoreSqlServerSettings and set in DbContextOptions<TestDbContext>.", exception.Message); 304Assert.Equal("MicrosoftEntityFrameworkCoreSqlServerSettings.DisableRetry needs to be set when a custom Execution Strategy is configured.", exception.Message);

Aspire.Npgsql.EntityFrameworkCore.PostgreSQL.Tests (4)

AspireEFPostgreSqlExtensionsTests.cs (1)

EnrichNpgsqlTests.cs (3)

40Assert.Equal("DbContext<TestDbContext> was not registered. Ensure you have registered the DbContext in DI before calling EnrichNpgsqlDbContext.", exception.Message); 115Assert.Equal("Conflicting values for 'CommandTimeout' were found in NpgsqlEntityFrameworkCorePostgreSQLSettings and set in DbContextOptions<TestDbContext>.", exception.Message); 318Assert.Equal("NpgsqlEntityFrameworkCorePostgreSQLSettings.DisableRetry needs to be set when a custom Execution Strategy is configured.", exception.Message);

Aspire.OpenAI.Tests (5)

AspireOpenAIClientBuilderChatClientExtensionsTests.cs (2)

132Assert.StartsWith("The connection string 'openai' contains both 'Deployment' and 'Model' keys.", ex.Message); 163Assert.StartsWith("The deployment could not be determined", ex.Message);

AspireOpenAIClientBuilderEmbeddingGeneratorExtensionsTests.cs (2)

132Assert.StartsWith("The connection string 'openai' contains both 'Deployment' and 'Model' keys.", ex.Message); 163Assert.StartsWith("The deployment could not be determined", ex.Message);

AspireOpenAIExtensionsTests.cs (1)

107"'ConnectionStrings:openai' or specify a Key in the 'Aspire:OpenAI' configuration section.", exception.Message);

Aspire.Oracle.EntityFrameworkCore.Tests (4)

AspireOracleEFCoreDatabaseExtensionsTests.cs (1)

276Assert.Equal("DbContext<TestDbContext> is already registered. Please ensure 'services.AddDbContext<TestDbContext>()' is not used when calling 'AddOracleDatabaseDbContext()' or use the corresponding 'Enrich' method.", exception.Message);

EnrichOracleDatabaseTests.cs (3)

36Assert.Equal("DbContext<TestDbContext> was not registered. Ensure you have registered the DbContext in DI before calling EnrichOracleDatabaseDbContext.", exception.Message); 109Assert.Equal("Conflicting values for 'CommandTimeout' were found in OracleEntityFrameworkCoreSettings and set in DbContextOptions<TestDbContext>.", exception.Message); 304Assert.Equal("OracleEntityFrameworkCoreSettings.DisableRetry needs to be set when a custom Execution Strategy is configured.", exception.Message);

Aspire.Pomelo.EntityFrameworkCore.MySql.Tests (4)

AspireEFMySqlExtensionsTests.cs (1)

270Assert.Equal("DbContext<TestDbContext> is already registered. Please ensure 'services.AddDbContext<TestDbContext>()' is not used when calling 'AddMySqlDbContext()' or use the corresponding 'Enrich' method.", exception.Message);

EnrichMySqlTests.cs (3)

50Assert.Equal("DbContext<TestDbContext> was not registered. Ensure you have registered the DbContext in DI before calling EnrichMySqlDbContext.", exception.Message); 123Assert.Equal("Conflicting values for 'CommandTimeout' were found in PomeloEntityFrameworkCoreMySqlSettings and set in DbContextOptions<TestDbContext>.", exception.Message); 318Assert.Equal("PomeloEntityFrameworkCoreMySqlSettings.DisableRetry needs to be set when a custom Execution Strategy is configured.", exception.Message);

Aspire.RabbitMQ.Client (1)

src\Components\Aspire.RabbitMQ.Client\AspireRabbitMQExtensions.cs (1)

254connectAttemptActivity.AddTag("exception.message", ex.Message);

Aspire.RabbitMQ.Client.Tests (1)

AspireRabbitMQLoggingTests.cs (1)

197Assert.Equal($"{innerException.GetType()}: {innerException.Message}", errorEvent[3].Value?.ToString());

Aspire.RabbitMQ.Client.v7.Tests (1)

tests\Aspire.RabbitMQ.Client.Tests\AspireRabbitMQLoggingTests.cs (1)

197Assert.Equal($"{innerException.GetType()}: {innerException.Message}", errorEvent[3].Value?.ToString());

Aspire.Templates.Tests (5)

tests\Shared\TemplatesTesting\AspireProject.cs (3)

tests\Shared\TemplatesTesting\BuildEnvironment.cs (1)

259Console.WriteLine($"\tFailed to delete {dir} : {ioex.Message}. Ignoring.");

tests\Shared\TemplatesTesting\TestExtensions.cs (1)

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

BasicTestApp (2)

InteropTest\JavaScriptInterop.cs (2)

437return e.Message; 451return e.Message;

BasicWebSite (1)

Controllers\AsyncActionsController.cs (1)

20context.Result = Content($"Action exception message: {context.Exception.Message}");

BuildActionTelemetryTable (2)

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

76Console.WriteLine(current.Message);

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

25: base(innerException.Message, innerException)

BuildBoss (5)

CompilerNuGetCheckerUtil.cs (1)

82textWriter.WriteLine($"Error verifying: {ex.Message}");

OptProfCheckerUtil.cs (1)

55textWriter.WriteLine($"Error verifying: {ex.Message}");

Program.cs (2)

26Console.WriteLine($"Unhandled exception: {ex.Message}"); 60Console.Error.WriteLine(ex.Message);

StructuredLoggerCheckerUtil.cs (1)

57textWriter.WriteLine($"Error processing binary log file: {ex.Message}");

BuildValidator (3)

Program.cs (3)

172logger.LogError(ex, ex.Message); 357logger.LogError(ex.Message); 358return CompilationDiff.CreateMiscError(assemblyInfo, ex.Message);

CatalogDb (1)

CatalogDbInitializerHealthCheck.cs (1)

14{ IsFaulted: true } => Task.FromResult(HealthCheckResult.Unhealthy(task.Exception?.InnerException?.Message, task.Exception)),

Client.ClientBase.IntegrationTests (1)

DuplexClientBaseTests.4.1.0.cs (1)

41Assert.Contains("BasicHttpBinding", exception.Message);

Client.ExpectedExceptions.IntegrationTests (13)

ExpectedExceptionTests.4.0.0.cs (2)

49Assert.True(String.Equals(exception.Message, exceptionMsg), String.Format("Expected exception message: {0}\nActual exception message: {1}", exceptionMsg, exception.Message));

ExpectedExceptionTests.4.1.0.cs (10)

51Assert.True(exception.Message.Contains(nonExistentHost), string.Format("Expected exception message to contain: '{0}'\nThe exception message was: {1}", nonExistentHost, exception.Message)); 114string exceptionMessage = ex.Message; 115string innerExceptionMessage = ex.InnerException?.Message; 184Assert.True(exception.Message.Contains(notFoundUrl), string.Format("Expected exception message to contain: '{0}'\nThe exception message was:{1}", notFoundUrl, exception.Message)); 223Assert.True(exception.Message.Contains(protocolExceptionUri), string.Format("Expected exception message to contain: '{0}'\nThe exception was: '{1}'", protocolExceptionUri, exception.Message)); 411Assert.True(exception.Message.Contains(Endpoints.Tcp_RevokedServerCertResource_HostName), 459Assert.True(exception.Message.Contains(Endpoints.Tcp_RevokedServerCertResource_HostName),

ExpectedExceptionTests.4.1.1.cs (1)

56Assert.Equal(MyCertificateValidator.exceptionMsg, exception.Message);

ClientSample (2)

Tcp\TcpConnection.cs (2)

144error = new IOException(ex.Message, ex); 205error = new IOException(ex.Message, ex);

CodeStyleConfigFileGenerator (2)

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

76Console.WriteLine(current.Message);

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

25: base(innerException.Message, innerException)

Contract.XmlSerializer.IntegrationTests (10)

XmlSerializerFormatTest.cs (10)

Crossgen2Tasks (1)

CommonFilePulledFromSdkRepo\TaskBase.cs (1)

39Log.LogError(e.Message);

csc (4)

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

289return new RejectedBuildResponse($"Error writing build request: {e.Message}"); 314response = new RejectedBuildResponse($"Error reading response: {e.Message}");

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

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

DemoConsole (1)

Program.cs (1)

35Console.WriteLine($"Exception (strike a key to quit!): {ex.Message}");

Diagnostics.EFCore.FunctionalTests (4)

DatabaseErrorPageMiddlewareTest.cs (2)

83Assert.Equal("Exception requested from TestMiddleware", ex.Message); 109Assert.Equal("SQLite Error 1: 'no such table: Blogs'.", ex.InnerException.Message);

MigrationsEndPointMiddlewareTest.cs (2)

264Assert.StartsWith(StringsHelpers.GetResourceString("FormatMigrationsEndPointMiddleware_Exception", typeof(BloggingContextWithSnapshotThatThrows)), ex.Message); 265Assert.Equal("Welcome to the invalid snapshot!", ex.InnerException.Message);

dotnet-dev-certs (14)

Program.cs (1)

294reporter.Error(e.Message);

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

146Log.MacOSAddCertificateToUserProfileDirError(candidate.Thumbprint, ex.Message); 327Log.MacOSAddCertificateToUserProfileDirError(certificate.Thumbprint, ex.Message); 471Log.MacOSRemoveCertificateFromUserProfileDirError(certificate.Thumbprint, ex.Message);

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

209Log.UnixDotnetTrustException(ex.Message); 374Log.UnixDotnetUntrustException(ex.Message); 577Log.UnixNssDbCheckException(nssDb.Path, ex.Message); 606Log.UnixNssDbAdditionException(nssDb.Path, ex.Message); 636Log.UnixNssDbRemovalException(nssDb.Path, ex.Message); 656Log.UnixFirefoxProfileEnumerationException(firefoxDirectory, ex.Message); 682Log.UnixCertificateFileDeletionException(certPath, ex.Message); 818Log.UnixOpenSslVersionException(ex.Message); 855Log.UnixOpenSslHashException(certificatePath, ex.Message); 930Log.UnixOpenSslRehashException(ex.Message);

dotnet-getdocument (1)

src\Tools\GetDocumentInsider\src\ProgramBase.cs (1)

58_reporter.WriteError(ex.Message);

dotnet-openapi (2)

Application.cs (2)

65Error.WriteLine(ex.InnerException.Message); 81Error.WriteLine(ex.Message);

dotnet-sql-cache (4)

Program.cs (4)

145CreateReporter(verbose: false).Error($"An error occurred. {exception.Message}"); 193$"An error occurred while trying to script the table and index. {ex.Message}"); 249$"An error occurred while trying to create the table and index. {ex.Message}"); 269$"Invalid SQL Server connection string '{_connectionString}'. {ex.Message}", ex);

dotnet-svcutil.xmlserializer (8)

Microsoft\Tools\ServiceModel\SvcUtil\ExportModule.cs (1)

78_contractLoadErrorCallback(type, e.Message);

Microsoft\Tools\ServiceModel\SvcUtil\InputModule.cs (1)

243ToolConsole.WriteLine(" " + e.Message, 2);

Microsoft\Tools\ServiceModel\SvcUtil\Options.cs (2)

451ToolConsole.WriteError(string.Format("Fail to load the assembly {0} with the error {1}", smassembly, e.Message)); 465ToolConsole.WriteError(string.Format("Fail to load the assembly {0} with the error {1}", smpassembly, e.Message));

Microsoft\Tools\ServiceModel\SvcUtil\ToolConsole.cs (4)

106WriteError(e.Message, prefix); 110if (e.Message != e.InnerException.Message) 112WriteError(e.InnerException.Message, " ");

dotnet-svcutil.xmlserializer.IntegrationTests (10)

src\System.Private.ServiceModel\tests\Scenarios\Contract\XmlSerializer\XmlSerializerFormatTest.cs (10)

dotnet-svcutil-lib (122)

AppInsightsTelemetryClient.cs (1)

127ToolConsole.WriteWarning(ex.Message);

Bootstrapper\SvcutilBootstrapper.cs (1)

206throw new BootstrapException(string.Format(CultureInfo.CurrentCulture, "{0}{1}{2}", exception.Message, Environment.NewLine, Resource.BootstrapErrorDisableReferences));

CommandProcessorOptions.cs (1)

1000throw new ToolArgumentException(ex.Message);

FrameworkFork\Microsoft.Xml\Xml\BinaryXml\XmlBinaryReader.cs (1)

980throw new XmlException(e.Message, e);

FrameworkFork\Microsoft.Xml\Xml\Core\XmlTextReaderImpl.cs (2)

2790Throw(new XmlException(e.Message, (Exception)null, lineNo, linePos, _ps.baseUriStr)); 8072innerMessage = e.Message;

FrameworkFork\Microsoft.Xml\Xml\schema\DatatypeImplementation.cs (2)

553throw new XmlSchemaException(ResXml.Sch_InvalidValueDetailed, new string[] { s, GetTypeName(), exception.Message }, exception, null, 0, 0, null); 571throw new XmlSchemaException(ResXml.Sch_InvalidValueDetailed, new string[] { s, GetTypeName(), exception.Message }, exception, null, 0, 0, null);

FrameworkFork\Microsoft.Xml\Xml\schema\FacetChecker.cs (2)

370throw new XmlSchemaException(ResXml.Sch_PatternFacetInvalid, new string[] { e.Message }, e, _pattern_facet.SourceUri, _pattern_facet.LineNumber, _pattern_facet.LinePosition, _pattern_facet); 676throw new XmlSchemaException(code, new string[] { ex.Message }, ex, facet.SourceUri, facet.LineNumber, facet.LinePosition, facet);

FrameworkFork\Microsoft.Xml\Xml\schema\Preprocessor.cs (4)

571SendValidationEvent(ResXml.Sch_AttributeValueDataTypeDetailed, new string[] { "version", schema.Version, tokenDt.TypeCodeString, exception.Message }, exception, schema); 2028SendValidationEvent(ResXml.Sch_InvalidAnyDetailed, new string[] { fe.Message }, fe, particle); 2071SendValidationEvent(ResXml.Sch_InvalidAnyDetailed, new string[] { fe.Message }, fe, anyAttribute); 2145SendValidationEvent(ResXml.Sch_InvalidAttribute, new string[] { attributeName, fx.Message }, fx, xso);

FrameworkFork\Microsoft.Xml\Xml\schema\SchemaCollectionPreprocessor.cs (2)

1742SendValidationEvent(ResXml.Sch_InvalidIdAttribute, ex.Message, xso); 1782SendValidationEvent(ResXml.Sch_InvalidAttribute, attributeName, ex.Message, xso);

FrameworkFork\Microsoft.Xml\Xml\schema\xdrvalidator.cs (1)

358SendValidationEvent(ResXml.Sch_CannotLoadSchema, new string[] { uri, e.Message }, XmlSeverityType.Warning);

FrameworkFork\Microsoft.Xml\Xml\schema\XmlSchemaException.cs (1)

189return (_message == null) ? base.Message : _message;

FrameworkFork\Microsoft.Xml\Xml\schema\XmlSchemaValidator.cs (6)

1307SendValidationEvent(ResXml.Sch_InvalidValueDetailedAttribute, new string[] { "schemaLocation", xsiSchemaLocation, s_dtStringArray.TypeCodeString, exception.Message }, exception); 1505SendValidationEvent(ResXml.Sch_ElementValueDataTypeDetailed, new string[] { QNameString(_context.LocalName, _context.Namespace), stringValue, GetTypeName(decl), exception.Message }, exception); 1667SendValidationEvent(ResXml.Sch_InvalidValueDetailedAttribute, new string[] { "type", xsiType, s_dtQName.TypeCodeString, exception.Message }, exception); 1882SendValidationEvent(ResXml.Sch_CannotLoadSchema, new string[] { uri, e.Message }, e, XmlSeverityType.Warning); 1986SendValidationEvent(ResXml.Sch_AttributeValueDataTypeDetailed, new string[] { attdef.Name.ToString(), stringValue, GetTypeName(decl), exception.Message }, exception); 2001SendValidationEvent(ResXml.Sch_ElementValueDataTypeDetailed, new string[] { QNameString(_context.LocalName, _context.Namespace), stringValue, GetTypeName(decl), exception.Message }, exception);

FrameworkFork\Microsoft.Xml\Xml\schema\xsdvalidator.cs (1)

620SendValidationEvent(ResXml.Sch_CannotLoadSchema, new string[] { uri, e.Message }, XmlSeverityType.Warning);

FrameworkFork\Microsoft.Xml\Xml\XmlException.cs (1)

253return (_message == null) ? base.Message : _message;

FrameworkFork\Microsoft.Xml\Xml\XPath\XPathException.cs (1)

87return (_message == null) ? base.Message : _message;

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\DataContract.cs (5)

669throw DiagnosticUtility.ExceptionUtility.ThrowHelperFatal(ex.Message, ex); 1038throw DiagnosticUtility.ExceptionUtility.ThrowHelperFatal(ex.Message, ex); 1062throw DiagnosticUtility.ExceptionUtility.ThrowHelperFatal(ex.Message, ex); 1079throw DiagnosticUtility.ExceptionUtility.ThrowHelperFatal(ex.Message, ex); 1102throw DiagnosticUtility.ExceptionUtility.ThrowHelperFatal(ex.Message, ex);

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\DictionaryGlobals.cs (1)

137throw DiagnosticUtility.ExceptionUtility.ThrowHelperFatal(ex.Message, ex);

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\SchemaImporter.cs (2)

827ThrowTypeCannotBeImportedException(typeName.Name, typeName.Namespace, string.Format(SRSerialization.IsValueTypeFormattedIncorrectly, isValueTypeInnerText, fe.Message)); 1163ThrowTypeCannotBeImportedException(typeName.Name, typeName.Namespace, string.Format(SRSerialization.IsDictionaryFormattedIncorrectly, isDictionaryInnerText, fe.Message));

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\XmlObjectSerializer.cs (1)

384string innerExceptionMessage = (innerException == null) ? string.Empty : innerException.Message;

FrameworkFork\System.Runtime.Serialization\System\Xml\ValueHandle.cs (1)

474throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(exception.Message, exception.InnerException));

FrameworkFork\System.Runtime.Serialization\System\Xml\XmlBaseReader.cs (1)

1469throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(exception.Message, exception.InnerException));

FrameworkFork\System.ServiceModel\Internals\System\Runtime\AssertHelper.cs (1)

56newMessage = string.Concat(newMessage, " [", exception.GetType().Name, ": ", exception.Message, "] --> ", message);

FrameworkFork\System.ServiceModel\Internals\System\Runtime\Diagnostics\DiagnosticTraceBase.cs (1)

167xml.WriteElementString(DiagnosticStrings.MessageTag, XmlEncode(exception.Message));

FrameworkFork\System.ServiceModel\Internals\System\Runtime\Diagnostics\EtwDiagnosticTrace.cs (1)

282new Tuple<string, string> (DiagnosticStrings.MessageTag, XmlEncode(exception.Message)),

FrameworkFork\System.ServiceModel\System\ServiceModel\ActionNotSupportedException.cs (1)

20string reason = this.Message;

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\ClientWebSocketTransportDuplexSessionChannel.cs (3)

101new WebSocketException(WebSocketError.ConnectionClosedPrematurely).Message); 128WcfEventSource.Instance.WebSocketConnectionFailed(EventTraceActivity, ex.Message); 166throw FxTrace.Exception.AsError(new CommunicationException(ex.Message, ex));

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\Connection.cs (3)

520return new TimeoutException(ioException.InnerException.Message, ioException); 524return new CommunicationObjectAbortedException(ioException.InnerException.Message, ioException); 528return new CommunicationException(ioException.InnerException.Message, ioException);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\ConnectionPool.cs (1)

185WcfEventSource.Instance.CloseTimeout(exception.Message);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\FramingDecoders.cs (3)

284return new CommunicationException(inner.Message, inner); 297return new CommunicationException(inner.Message, inner); 302return new CommunicationException(inner.Message, inner);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpChannelHelpers.cs (2)

122throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(requestException.Message, requestException)); 143return new CommunicationException(exception.Message, exception);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\Message.cs (2)

1252new CommunicationException(versionMismatchException.Message, versionMismatchException), 1454new CommunicationException(versionMismatchException.Message, versionMismatchException),

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\MessageContent.cs (1)

113new ProtocolException(string.Format(SRServiceModel.HttpContentTypeFormatException, formatException.Message, Headers.ContentType.ToString()), formatException));

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\MessageHeader.cs (1)

271throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(exception.Message, (Exception)null));

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\RequestContextBase.cs (1)

322WcfEventSource.Instance.CloseTimeout(e.Message);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\ServiceChannel.cs (1)

858WcfEventSource.Instance.CloseTimeout(e.Message);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\SessionConnectionReader.cs (2)

254WcfEventSource.Instance.ReceiveTimeout(e.Message); 273WcfEventSource.Instance.ReceiveTimeout(e.Message);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\SslStreamSecurityUpgradeProvider.cs (5)

360throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException(exception.Message, 366string.Format(SRServiceModel.NegotiationFailedIO, ioException.Message), ioException)); 605throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException(tokenValidationException.Message, 610throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException(exception.Message, 616string.Format(SRServiceModel.NegotiationFailedIO, ioException.Message), ioException));

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\TransactionFlowBindingElementImporter.cs (1)

180string.Format(SRServiceModel.UnsupportedBooleanAttribute, TransactionPolicyStrings.OptionalLocal, e.Message)));

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\TransportDuplexSessionChannel.cs (2)

182WcfEventSource.Instance.ReceiveTimeout(e.Message); 202WcfEventSource.Instance.ReceiveTimeout(e.Message);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\WebSocketHelper.cs (3)

140CommunicationObjectAbortedException communicationObjectAbortedException = new CommunicationObjectAbortedException(ex.Message, ex); 183return new CommunicationObjectAbortedException(exception.Message, exception); 186return new CommunicationException(exception.Message, exception);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\WebSocketTransportDuplexSessionChannel.cs (1)

667WcfEventSource.Instance.ReceiveTimeout(exception.Message);

FrameworkFork\System.ServiceModel\System\ServiceModel\Description\MetadataExporter.cs (1)

146string errorMessage = string.Format(SRServiceModel.PolicyExtensionExportError, exporter.GetType(), e.Message);

FrameworkFork\System.ServiceModel\System\ServiceModel\Description\MetadataImporter.cs (1)

141string errorMessage = string.Format(SRServiceModel.PolicyExtensionImportError, importer.GetType(), e.Message);

FrameworkFork\System.ServiceModel\System\ServiceModel\Description\OperationGenerator.cs (1)

221method.Comments.Add(new CodeCommentStatement(string.Format(SRServiceModel.SFxCodeGenWarning, ex.Message)));

FrameworkFork\System.ServiceModel\System\ServiceModel\Description\WsdlImporter.cs (3)

1896string errorMessage = string.Format(SRServiceModel.WsdlExtensionBeforeImportError, importer.GetType().AssemblyQualifiedName, e.Message); 1909string errorMessage = string.Format(SRServiceModel.WsdlExtensionImportError, importer.GetType().FullName, e.Message); 1972return messageException.Message;

FrameworkFork\System.ServiceModel\System\ServiceModel\Dispatcher\DataContractSerializerOperationFormatter.cs (3)

240string.Format(SRServiceModel.SFxInvalidMessageBodyErrorSerializingParameter, part.Description.Namespace, part.Description.Name, sx.Message), sx)); 436part.Description.Namespace, part.Description.Name, e.Message), 444part.Description.Namespace, part.Description.Name, e.Message),

FrameworkFork\System.ServiceModel\System\ServiceModel\Dispatcher\ErrorBehavior.cs (2)

90fault = MessageFault.CreateFault(code, new FaultReason(error.Message), new ExceptionDetail(error)); 123WcfEventSource.Instance.FaultProviderInvoked(_handlers[i].GetType().FullName, e.Message);

FrameworkFork\System.ServiceModel\System\ServiceModel\Dispatcher\ImmutableDispatchRuntime.cs (2)

515throw DiagnosticUtility.ExceptionUtility.ThrowHelperFatal(e.Message, e); 615throw DiagnosticUtility.ExceptionUtility.ThrowHelperFatal(e.Message, e);

FrameworkFork\System.ServiceModel\System\ServiceModel\Dispatcher\MessageRpc.cs (1)

487throw DiagnosticUtility.ExceptionUtility.ThrowHelperFatal(e.Message, e);

FrameworkFork\System.ServiceModel\System\ServiceModel\Dispatcher\OperationFormatter.cs (4)

149string.Format(SRServiceModel.SFxErrorDeserializingReplyBodyMore, _operationName, fe.Message), fe)); 154string.Format(SRServiceModel.SFxErrorDeserializingReplyBodyMore, _operationName, se.Message), se)); 214string.Format(SRServiceModel.SFxErrorDeserializingRequestBodyMore, _operationName, fe.Message), 220string.Format(SRServiceModel.SFxErrorDeserializingRequestBodyMore, _operationName, se.Message),

FrameworkFork\System.ServiceModel\System\ServiceModel\Dispatcher\PrimitiveOperationFormatter.cs (4)

400string.Format(SRServiceModel.SFxErrorDeserializingReplyBodyMore, _operation.Name, fe.Message), fe)); 405string.Format(SRServiceModel.SFxErrorDeserializingReplyBodyMore, _operation.Name, se.Message), se)); 442string.Format(SRServiceModel.SFxErrorDeserializingRequestBodyMore, _operation.Name, fe.Message), 448string.Format(SRServiceModel.SFxErrorDeserializingRequestBodyMore, _operation.Name, se.Message),

FrameworkFork\System.ServiceModel\System\ServiceModel\Dispatcher\XmlSerializerOperationFormatter.cs (2)

127string.Format(SRServiceModel.SFxErrorSerializingHeader, messageDescription.MessageName, e.Message), e)); 301string.Format(SRServiceModel.SFxErrorSerializingBody, messageDescription.MessageName, e.Message), e));

FrameworkFork\System.ServiceModel\System\ServiceModel\ExceptionDetail.cs (1)

28_message = exception.Message;

FrameworkFork\System.ServiceModel\System\ServiceModel\Security\WSSecurityPolicy.cs (1)

1946importer.Errors.Add(new MetadataConversionError(string.Format(SRServiceModel.UnsupportedBooleanAttribute, OptionalName, e.Message), false));

FrameworkFork\System.ServiceModel\System\ServiceModel\Security\WSSecurityPolicy11.cs (1)

96importer.Errors.Add(new MetadataConversionError(string.Format(SRServiceModel.UnsupportedBooleanAttribute, RequireClientCertificateName, e.Message), false));

FrameworkFork\System.ServiceModel\System\ServiceModel\Security\WSSecurityTokenSerializer.cs (8)

FrameworkFork\System.ServiceModel\System\ServiceModel\WSAddressing10ProblemHeaderQNameFault.cs (2)

38_reason = new FaultReason(e.Message, CultureInfo.CurrentCulture); 48_reason = new FaultReason(e.Message, CultureInfo.CurrentCulture);

Shared\MSBuildProj.cs (2)

851await safeLogger.WriteWarningAsync(ex.Message, logToUI: false).ConfigureAwait(false); 932await safeLogger.WriteWarningAsync(ex.Message, logToUI: false).ConfigureAwait(false);

Shared\ProjectPropertyResolver.cs (2)

70await safeLogger.WriteMessageAsync(ex.Message, logToUI: false).ConfigureAwait(false); 98await safeLogger.WriteErrorAsync($"{ex.Message}{Environment.NewLine}{ex.StackTrace}", logToUI: false);

Shared\Utilities\PathHelper.cs (2)

221await safeLogger.WriteErrorAsync(ex.Message, logToUI: false).ConfigureAwait(false); 269await safeLogger.WriteMessageAsync($"Error: {ex.Message}", logToUI: false).ConfigureAwait(false);

Shared\Utilities\RuntimeEnvironmentHelper.cs (1)

118await safeLogger.WriteErrorAsync(ex.Message, logToUI: false);

Shared\Utilities\Utilities.cs (1)

40var exMsg = e.Message?.Trim();

Tool.cs (1)

324var ex = new AggregateException(options.Errors.Select(e => e as ToolArgumentException ?? new ToolArgumentException(e.Message, e.InnerException)));

TypeLoader.cs (2)

33ToolConsole.WriteWarning(string.Format(SR.ErrUnableToLoadReferenceFormat, path, ex.Message)); 61warning = ex.Message;

dotnet-svcutil-lib.Tests (2)

UnitTest.cs (2)

253Environment.NewLine + cmdOptions.Errors.Select(e => e.Message).Aggregate((errors, e) => $"{errors}{Environment.NewLine}{e}"); 299Environment.NewLine + cmdOptions.Errors.Select(e => e.Message).Aggregate((errors, e) => $"{errors}{Environment.NewLine}{e}");

dotnet-user-jwts (3)

Program.cs (2)

59_reporter.Error(parsingException.Message); 64_reporter.Error(ex.Message);

src\Tools\Shared\SecretsHelpers\ProjectIdResolver.cs (1)

41_reporter.Error(ex.Message);

dotnet-user-secrets (3)

Program.cs (2)

44reporter.Error(Resources.FormatError_Command_Failed(exception.Message)); 59CreateReporter(verbose: false).Error(ex.Message);

src\Tools\Shared\SecretsHelpers\ProjectIdResolver.cs (1)

41_reporter.Error(ex.Message);

EventHubsConsumer (1)

Processor.cs (1)

40logger.LogError(args.Exception, "Error processing message: {Error}", args.Exception.Message);

ExceptionHandlerSample (1)

Startup.cs (1)

28await context.Response.WriteAsync("<br>Error: " + HtmlEncoder.Default.Encode(error.Error.Message) + "<br>\r\n");

GenerateDocumentationAndConfigFiles (16)

CodeFixerExtensions.cs (2)

57Console.WriteLine($"Error creating instance of {typeInfo.FullName} in {analyzerFileReference.FullPath}\r\n{ex.Message}\r\n{ex}"); 64Console.WriteLine($"Error processing analyzer file reference: {analyzerFileReference.FullPath}\r\n{ex.Message}\r\n{ex}");

Program.cs (2)

887await Console.Error.WriteLineAsync(ex.Message).ConfigureAwait(false); 952await Console.Error.WriteLineAsync(ex.Message).ConfigureAwait(false);

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

262throw new IOException(e.Message, e); 266throw new IOException(e.Message, e); 306throw new IOException(e.Message, e); 330throw new IOException(e.Message, e); 347throw new IOException(e.Message, e); 389throw new IOException(e.Message, e); 407throw new IOException(e.Message, e); 426throw new IOException(e.Message, e); 451throw new IOException(e.Message, e);

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

259error = 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)

GenerateRulesMissingDocumentation (1)

Program.cs (1)

135Console.WriteLine($"##[warning]Failed while checking '{helpLink}' (${e.StatusCode}, ${e.HttpRequestError}): ${e.Message}");

GetDocument.Insider (1)

ProgramBase.cs (1)

58_reporter.WriteError(ex.Message);

HttpStress (2)

Program.cs (2)

149if (e.InnerException.Message.Contains("INTERNAL_ERROR") || e.InnerException.Message.Contains("CANCEL"))

IdentitySample.PasskeyConformance (2)

Program.cs (2)

89return Results.BadRequest(new FailedResponse($"Attestation failed: {attestationResult.Failure.Message}")); 160return Results.BadRequest(new FailedResponse($"Assertion failed: {assertionResult.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)

106Assert.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)

428e => Logger.LogError($"Failed to create app_offline : {e.Message}"), 585e => 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)

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

IIS.NewShim.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)

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

IIS.ShadowCopy.Tests (3)

ShadowCopyTests.cs (1)

388Console.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)

135Assert.Equal("The client has disconnected", exception.Message); 276Assert.Equal("The client has disconnected", exception.Message);

MaxRequestBodySizeTests.cs (5)

57Assert.Equal(CoreStrings.BadRequest_RequestBodyTooLarge, exception.Message); 100Assert.Equal(CoreStrings.BadRequest_RequestBodyTooLarge, exception.Message); 310Assert.Equal(CoreStrings.BadRequest_RequestBodyTooLarge, exception.Message); 346Assert.Equal(CoreStrings.BadRequest_RequestBodyTooLarge, requestRejectedEx1.Message); 347Assert.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)

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

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

428e => Logger.LogError($"Failed to create app_offline : {e.Message}"), 585e => 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); 954Context.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));

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)

src\Servers\IIS\IIS\test\testassets\InProcessWebSite\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)

979Assert.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); 1048Assert.Equal("The client reset the request stream.", serverEx.Message); 2084Assert.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)

103_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)

259error = 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)

259error = 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.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)

106exception.Message);

DefaultAntiforgeryTokenSerializerTest.cs (1)

51Assert.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)

173$"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 (16)

EndpointHtmlRendererTest.cs (6)

803Assert.Equal("Threw an exception synchronously", exception.Message); 823Assert.Equal("Threw an exception asynchronously", exception.Message); 846exception.Message); 884exception.Message); 951Assert.Equal(expectedError, exception.Message); 990Assert.Equal(expectedError.ReplaceLineEndings(), exception.Message.ReplaceLineEndings());

RazorComponentResultTest.cs (1)

255Assert.Contains("A navigation command was attempted during prerendering after the server already started sending the response", 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)

969exception.Message,

Circuits\CircuitRegistry.cs (2)

440=> UnhandledExceptionDisposingCircuitHost(logger, exception.Message, exception); 446=> 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)

430exception.Message); 449Assert.Equal("Exceeded the maximum number of allowed server interactive root components.", ex.Message); 465Assert.Equal("A root component with SSR component ID 0 already exists.", ex.Message); 486Assert.Equal("An invalid component marker key was provided.", ex.Message); 520Assert.Equal($"No root component exists with SSR component ID 1.", ex.Message); 540Assert.Equal("Cannot update components with mismatching keys.", ex.Message); 615Assert.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 (79)

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 (2)

72Assert.Equal($"The component activator returned a null value for a component of type {componentType.FullName}.", ex.Message); 228Assert.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);

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); 705Assert.Equal(exceptionMessage, ex.Message); 736Assert.Equal(exceptionMessage, ex.Message); 762Assert.Equal(exceptionMessage, ex.Message); 788Assert.StartsWith("To support navigation locks", ex.Message); 810Assert.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);

RendererTest.cs (10)

664Assert.Contains("declares more than one parameter", ex.Message); 687Assert.Contains($"must inherit from {typeof(EventArgs).FullName}", ex.Message); 720Assert.Equal("Error", exception.Message); 2925Assert.Equal("The render handle is not yet assigned.", ex.Message); 4432Assert.Contains("Cannot start a batch when one is already in progress.", ex.Message); 4465Assert.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); 4538Assert.StartsWith($"Render output is invalid for component of type '{typeof(TestComponent).FullName}'. A frame of type 'Element' was left unclosed.", ex.Message); 4885Assert.Equal("The specified component is not a root component", ex.Message); 5044Assert.Contains($"Cannot supply a component of type '{typeof(ComponentWithUnknownRenderMode)}' because the current platform does not support the render mode '{typeof(ComponentWithUnknownRenderMode.UnknownRenderMode)}'.", ex.Message); 5062Assert.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\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 (22)

Forms\BrowserFileTest.cs (1)

29Assert.Equal("Supplied file with size 100 bytes exceeds the maximum of 80 bytes.", 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\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 (6)

.packages\microsoft.dotnet.hotreload.agent\10.0.100-preview.7.25358.102\contentFiles\cs\net6.0\HotReloadAgent.cs (2)

83Reporter.Report($"Error retrieving capabilities: {e.Message}", AgentMessageSeverity.Error); 163Reporter.Report($"Failed to load type 0x{updatedType:X8}: {e.Message}", AgentMessageSeverity.Warning);

.packages\microsoft.dotnet.hotreload.agent\10.0.100-preview.7.25358.102\contentFiles\cs\net6.0\MetadataUpdateHandlerInvoker.cs (1)

311reporter.Report($"'{assembly.FullName}' is not loaded ({e.Message})", AgentMessageSeverity.Verbose);

Rendering\WebAssemblyRenderer.cs (2)

179Log.UnhandledExceptionRenderingComponent(_logger, innerException.Message, innerException); 184Log.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)

43ex.Message);

Hosting\WebAssemblyHostTest.cs (1)

56Assert.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 (19)

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 (11)

155Assert.Equal(Resources.ProtectionProvider_BadMagicHeader, ex.Message); 173Assert.Equal(Resources.ProtectionProvider_BadMagicHeader, ex.Message); 191Assert.Equal(Resources.ProtectionProvider_BadVersion, ex.Message); 222Assert.Equal(Error.Common_KeyNotFound(notFoundKeyId).Message, ex.Message); 275Assert.Equal(Error.Common_KeyNotFound(notFoundKeyId).Message, ex.Message); 311Assert.Equal(Error.Common_KeyNotFound(notFoundKeyId).Message, ex.Message); 409Assert.Equal(Error.Common_KeyRevoked(keyId).Message, 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 (13)

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

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

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

CertificateManagerTests.cs (1)

105Output.WriteLine(e.Message);

Microsoft.AspNetCore.Diagnostics (4)

DeveloperExceptionPage\DeveloperExceptionPageMiddlewareImpl.cs (1)

256Detail = 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 (10)

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 (1)

47context.ProblemDetails.Extensions.Add("OriginalExceptionMessage", context.Exception.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 (25)

ConverterTests\JsonConverterReadTests.cs (3)

253AssertReadJsonError<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); 485AssertReadJsonError<HelloRequest>(json, ex => Assert.Equal("Multiple values specified for oneof oneof_test", ex.Message.TrimEnd('.'))); 563AssertReadJsonError<NullValueContainer>(json, ex => Assert.Equal("Invalid enum value: MONKEY for enum type: google.protobuf.NullValue", ex.Message));

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 (4)

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)

78Assert.Equal("The specified factory returned null startup instance.", ex.Message); 425Assert.Equal("A public method named 'ConfigureProduction' or 'Configure' could not be found in the 'Microsoft.AspNetCore.Hosting.Fakes.StartupBoom' type.", exception.Message); 455Assert.Equal("A public method named 'ConfigureProduction' or 'Configure' could not be found in the 'Microsoft.AspNetCore.Hosting.Fakes.StartupBoom' type.", exception.Message); 720Assert.Contains("No application configured.", ex.Message); 842Assert.Equal("WebHostBuilder allows creation only of a single instance of WebHost", ex.Message); 1006Assert.Equal("Microsoft.AspNetCore.Hosting.IStartup isn't supported", exception.Message); 1022Assert.Equal("Building this implementation of IWebHostBuilder is not supported.", exception.Message); 1038Assert.Equal($"ConfigureServices returning an {typeof(IServiceProvider)} isn't supported.", exception.Message); 1230Assert.Contains(sink.Writes, w => w.Exception?.Message == "Startup exception"); 1254Assert.Contains(testSink.Writes, w => w.Exception?.Message == "Startup exception"); 1313Assert.Contains("No application configured.", exception.Message); 1355Assert.Equal("Hosted Service throws in StartAsync", startEx.Message); 1361Assert.Equal("Hosted Service throws in StopAsync", stopEx.Message); 1380Assert.Equal("Hosted Service throws in StartAsync", startEx.Message); 1387Assert.Equal("Hosted Service throws in StopAsync", stopEx.Message);

WebHostTests.cs (2)

28Assert.Equal("No service for type 'Microsoft.AspNetCore.Hosting.Server.IServer' has been registered.", ex.Message); 991Assert.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)

423transportExceptions.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.Extensions.Tests (62)

HttpRequestJsonExtensionsTests.cs (3)

46Assert.Equal(expectedMessage, ex.Message); 164Assert.Equal("Unable to read the request as JSON because the request content type charset 'invalid' is not a known encoding.", ex.Message); 208Assert.Equal("Unable to read the request as JSON because the request content type charset 'invalid' is not a known encoding.", ex.Message);

ParameterBindingMethodCacheTests.cs (14)

RequestDelegateFactoryTests.cs (18)

293Assert.Equal("'id' is not a route parameter.", ex.Message); 730Assert.Equal("notTryParsable must have a valid TryParse method to support converting from a string. No public static bool object.TryParse(string, out object) method found for notTryParsable.", ex.Message); 739Assert.Equal("Encountered a parameter of type 'System.Runtime.CompilerServices.Closure' without a name. Parameters must have a name.", ex.Message); 773Assert.Equal(@"Failed to bind parameter ""Nullable<int>[] values"" from """".", badHttpRequestException.Message); 910Assert.Equal("Unsupported return type: System.ReadOnlySpan<byte>", ex1.Message); 911Assert.Equal("Unsupported return type: System.Span<byte>", ex2.Message); 912Assert.Equal($"Unsupported return type: {typeof(RefStruct).FullName}", ex3.Message); 1022Assert.Equal(errorMessage, exception.Message); 1128Assert.Equal($"The by reference parameter 'out {typeName} foo' is not supported.", outParamException.Message); 1129Assert.Equal($"The by reference parameter 'in {typeName} foo' is not supported.", inParamException.Message); 1130Assert.Equal($"The by reference parameter 'ref {typeName} foo' is not supported.", refParamException.Message); 1163Assert.Equal("No service for type 'Microsoft.AspNetCore.Routing.Internal.RequestDelegateFactoryTests+MyService' has been registered.", ex.Message); 1521Assert.Contains(message, exception.Message); 2028Assert.Equal("Assigning a value to the IFromFormMetadata.Name property is not supported for parameters of type IFormFileCollection.", nse.Message); 2077Assert.Equal("Assigning a value to the IFromFormMetadata.Name property is not supported for parameters of type IFormCollection.", nse.Message); 2114Assert.Contains($"The nullable type '{TypeNameHelper.GetTypeDisplayName(parameter.ParameterType, fullName: false)}' is not supported, mark the parameter as non-nullable.", exception.Message); 3282Assert.Contains("Microsoft.AspNetCore.Routing.Internal.RequestDelegateFactoryTests+Todo", exception.Message); 3283Assert.Contains("JsonSerializableAttribute", exception.Message);

RequestDelegateFactoryTests.FormMapping.cs (4)

61Assert.Equal("The number of elements in the dictionary exceeded the maximum number of '2' elements allowed.", exception.Message); 108Assert.Equal("The number of elements in the dictionary exceeded the maximum number of '2' elements allowed.", exception.Message); 156Assert.Equal("The number of elements in the dictionary exceeded the maximum number of '2' elements allowed.", exception.Message); 282Assert.Equal("The maximum recursion depth of '3' was exceeded for 'Manager.Manager.Manager.Name'.", exception.Message);

RequestDelegateGenerator\CompileTimeCreationTests.cs (3)

47Assert.Equal("'invalidName' is not a route parameter.", exception.Message); 429Assert.Equal("JsonSerializerOptions instance must specify a TypeInfoResolver setting before being marked as read-only.", exception.Message); 460Assert.Equal(message, exception.Message);

RequestDelegateGenerator\RequestDelegateCreationTests.BindAsync.cs (3)

104Assert.Equal("The request is missing the required Referer header.", ex.Message); 133Assert.Equal("The request is missing the required Referer header.", ex.Message); 198Assert.Equal("BindAsync failed", ex.Message);

RequestDelegateGenerator\RequestDelegateCreationTests.Forms.cs (2)

336Assert.Equal("Expected a supported form media type but got \"application/xml\".", ex.Message); 1016Assert.Equal(@"Failed to read parameter ""IFormFile file"" from the request body as form.", badHttpRequestException.Message);

RequestDelegateGenerator\RequestDelegateCreationTests.JsonBodyOrService.cs (2)

203Assert.StartsWith("Implicit body inferred for parameter", ex.Message); 204Assert.EndsWith("but no body was provided. Did you mean to use a Service instead?", ex.Message);

RequestDelegateGenerator\RequestDelegateCreationTests.KeyServices.cs (4)

51Assert.Equal($"The {nameof(FromKeyedServicesAttribute)} is not supported on parameters that are also annotated with {nameof(IFromServiceMetadata)}.", exception.Message); 130Assert.Equal("No keyed service for type 'Microsoft.AspNetCore.Http.Generators.Tests.TestService' using key type 'System.String' has been registered.", exception.Message); 219Assert.Equal("Unable to resolve service referenced by FromKeyedServicesAttribute. The service provider doesn't support keyed services.", runtimeException.Message); 226Assert.Equal("Unable to resolve service referenced by FromKeyedServicesAttribute. The service provider doesn't support keyed services.", exception.Message);

RequestDelegateGenerator\RequestDelegateCreationTests.Logging.cs (8)

164Assert.Equal(@"Failed to bind parameter ""int tryParsable"" from ""invalid!"".", badHttpRequestException.Message); 201Assert.Equal(@"Failed to bind parameter ""int[] values"" from ""NAN"".", badHttpRequestException.Message); 281Assert.Equal(@"Required parameter ""MyBindAsyncRecord myBindAsyncParam1"" was not provided from MyBindAsyncRecord.BindAsync(HttpContext, ParameterInfo).", badHttpRequestException.Message); 360Assert.Equal(@"Required parameter ""MySimpleBindAsyncRecord mySimpleBindAsyncRecord1"" was not provided from MySimpleBindAsyncRecord.BindAsync(HttpContext).", badHttpRequestException.Message); 393Assert.Equal("Expected a supported JSON media type but got \"application/xml\".", ex.Message); 442Assert.Equal("Expected a supported JSON media type but got \"application/xml\".", ex.Message); 574Assert.Equal(@"Failed to read parameter ""Todo todo"" from the request body as JSON.", badHttpRequestException.Message); 653Assert.Equal(@"Failed to read parameter ""Todo todo"" from the request body as JSON.", badHttpRequestException.Message);

RequestDelegateGenerator\RuntimeCreationTests.cs (1)

27Assert.StartsWith($"BindAsync method found on {bindAsyncType} with incorrect format.", ex.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)

97Assert.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)

DefaultPasskeyHandler.cs (2)

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

PasskeyExceptionExtensions.cs (1)

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

SignInManager.cs (2)

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

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

UserStoreEncryptPersonalDataTest.cs (1)

291Assert.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)

1691Assert.Equal(error, ex.Message); 1694Assert.Equal(error, ex.Message); 1697Assert.Equal(error, ex.Message); 1700Assert.Equal(error, ex.Message);

Microsoft.AspNetCore.Identity.Test (161)

Passkeys\DefaultPasskeyHandlerAssertionTest.cs (72)

Passkeys\DefaultPasskeyHandlerAttestationTest.cs (82)

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)

686Assert.Contains(Extensions.Identity.Core.Resources.NullSecurityStamp, ex.Message); 713Assert.Contains(Extensions.Identity.Core.Resources.NullSecurityStamp, ex.Message); 1143Assert.Contains("Store does not implement IProtectedUserStore", e.Message); 1154Assert.Contains("No IPersonalDataProtector service was registered", e.Message); 1302Assert.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 (7)

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)

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

JsonPatchDocumentOfT.cs (1)

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

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

IntegrationTests\AnonymousObjectIntegrationTest.cs (6)

28exception.Message); 51exception.Message); 74exception.Message); 98exception.Message); 122exception.Message); 163exception.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)

143=> 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)

1540Assert.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)

299Assert.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)

26Assert.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)

Extensions\ApiDescriptionExtensionsTests.cs (1)

80Assert.Equal($"Unsupported HTTP method: {methodName}", exception.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)

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

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

Internal\Http2\Http2Connection.cs (3)

348AbortStream(_incomingFrame.StreamId, new IOException(ex.Message, ex)); 1645throw new Http2ConnectionErrorException(bre.Message, Http2ErrorCode.PROTOCOL_ERROR, ConnectionEndReason.MaxRequestHeaderCountExceeded); 1650throw 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); 454Log.Http3StreamAbort(CoreStrings.FormatUnidentifiedStream(ex.StreamId), Http3ErrorCode.StreamCreationError, new(ex.Message)); 731Abort(new ConnectionAbortedException(connectionError.Message, connectionError), connectionError.ErrorCode, ConnectionEndReason.ClosedCriticalStream); 864Abort(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)

178abortReason = new ConnectionAbortedException(exception.Message, exception); 363throw new Http3StreamErrorException(bre.Message, Http3ErrorCode.MessageError); 669Abort(new ConnectionAbortedException(ex.Message, ex), ex.ErrorCode); 834throw 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 (10)

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

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 (14)

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 (15)

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 (1)

296Assert.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 (7)

ConfigurationReaderTests.cs (1)

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

KestrelConfigurationLoaderTests.cs (6)

682Assert.StartsWith("Error getting private key from", ex.Message); 803Assert.Equal(CoreStrings.FormatEndpointHasUnusedHttpsConfig("End1", "Certificate"), ex.Message); 812Assert.Equal(CoreStrings.FormatEndpointHasUnusedHttpsConfig("End1", "Certificate"), ex.Message); 821Assert.Equal(CoreStrings.FormatEndpointHasUnusedHttpsConfig("End1", "ClientCertificateMode"), ex.Message); 830Assert.Equal(CoreStrings.FormatEndpointHasUnusedHttpsConfig("End1", "SslProtocols"), ex.Message); 839Assert.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 (35)

CommandLineApplicationTests.cs (14)

ObjectMethodExecutorTest.cs (2)

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

runtime\Http2\HPackDecoderTest.cs (15)

runtime\Http2\HuffmanDecodingTests.cs (3)

runtime\Http3\QPackDecoderTest.cs (1)

296Assert.Equal(SR.net_http_hpack_incomplete_header_block, exception.Message);

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 (13)

HttpContextBuilderTests.cs (1)

344Assert.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)

257Assert.Equal("HttpContent exception", ex.Message); 446Assert.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);

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.Framework (8)

BuildException\BuildExceptionBase.cs (1)

84writer.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)

ITaskItemExtensions.cs (1)

58valueOrError = e.Message;

NativeMethods.cs (1)

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

Telemetry\BuildCheckTelemetry.cs (2)

33if (exception.Message != null) 35properties["ExceptionMessage"] = exception.Message;

Microsoft.Build.Tasks.CodeAnalysis (11)

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)

535Log.LogErrorWithCodeFromResources("General_CouldNotSetHostObjectParameter", param, e.Message); 669Log.LogErrorWithCodeFromResources("General_CouldNotSetHostObjectParameter", param, e.Message);

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

334Log.LogErrorWithCodeFromResources("VBC_RenamePDB", PdbFile, e.Message); 963Log.LogErrorWithCodeFromResources("General_CouldNotSetHostObjectParameter", param, e.Message);

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

289return new RejectedBuildResponse($"Error writing build request: {e.Message}"); 314response = new RejectedBuildResponse($"Error reading response: {e.Message}");

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

84builder.AppendLine($"Error: '{exception.GetType().Name}' '{exception.Message}' occurred during '{reason}'"); 140Debug.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 (11)

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)

334Log.LogErrorWithCodeFromResources("VBC_RenamePDB", PdbFile, e.Message); 963Log.LogErrorWithCodeFromResources("General_CouldNotSetHostObjectParameter", param, e.Message);

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

289return new RejectedBuildResponse($"Error writing build request: {e.Message}"); 314response = new RejectedBuildResponse($"Error reading response: {e.Message}");

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

84builder.AppendLine($"Error: '{exception.GetType().Name}' '{exception.Message}' occurred during '{reason}'"); 140Debug.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.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)

519diagnosticInfo = new DiagnosticInfo(messageProvider, messageProvider.ERR_NoSourceFile, filePath, e.Message); 1674diagnostics.Add(messageProvider.CreateDiagnostic(messageProvider.ERR_ErrorBuildingWin32Resource, Location.None, ex.Message)); 1708diagnostics.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)

259diagnostics.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)

1296var messageArguments = new[] { analyzerName, e.GetType().ToString(), e.Message, contextInformation }; 1328return string.Format(CodeAnalysisResources.CompilerAnalyzerThrows, analyzerName, ex.GetType().ToString(), ex.Message, ex.CreateDiagnosticDescription()); 1343var 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)

302e.Message 387e.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)

259error = 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)

1771throw 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)

259error = 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)

259error = 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)

259error = 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)

259error = 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)

112diagnostics.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)

108diagnostics.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)

924&& e.Exception.Message == message) 960&& e.Exception.Message == message) 1074&& 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.Features.UnitTests (2)

SemanticSearch\CSharpSemanticSearchServiceTests.cs (2)

333var expectedMessage = new InsufficientExecutionStackException().Message; 402var expectedMessage = new NullReferenceException().Message;

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

CommandLineRunnerTests.cs (4)

187{exception.GetType()}: {exception.Message} 193$@"{exception.GetType()}: {exception.Message} 216{exception.GetType()}: {exception.Message} 222$@"{exception.GetType()}: {exception.Message}

InteractiveSessionTests.cs (5)

1932Assert.Equal("Bang!", state1.Exception.Message); 1959Assert.Equal("Bang!", state2.Exception.Message); 1987Assert.Equal("Bang!", state3.Exception.Message); 2007Assert.Equal("Bang 1!", state1.Exception.Message); 2015Assert.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)

4767Assert.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)

2021Assert.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)

599=> 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)

1025ErrorMessage: 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)

1025ErrorMessage: e.Message,

Microsoft.CodeAnalysis.Extensions.Package (3)

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

259error = 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 (19)

Diagnostics\Service\DocumentAnalysisExecutor_Helpers.cs (1)

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

EditAndContinue\CommittedSolution.cs (3)

456log.Write($"Source file of project '{projectName}' doesn't match output PDB: error opening PDB '{compilationOutputs.PdbDisplayPath}' (assembly: '{compilationOutputs.AssemblyDisplayPath}'): {e.Message}", LogMessageSeverity.Warning); 506log.Write($"Error calculating checksum for source file '{sourceFilePath}': '{e.Message}'", LogMessageSeverity.Error); 566log.Write($"Source '{sourceFilePath}' doesn't match output PDB: error reading symbols: {e.Message}", LogMessageSeverity.Error);

EditAndContinue\DebuggingSession.cs (3)

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

EditAndContinue\EditAndContinueMethodDebugInfoReader.cs (2)

82throw new InvalidDataException(e.Message, e); 104throw new InvalidDataException(e.Message, e);

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)

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

SemanticSearch\AbstractSemanticSearchService.cs (2)

268errorMessageArgs = [WellKnownMemberNames.TopLevelStatementsEntryPointTypeName, e.Message]; 335error = e.Message;

SemanticSearch\QueryExecutionContext.cs (1)

195await resultsObserver.OnUserCodeExceptionAsync(new UserCodeExceptionInfo(projectDisplay, e.Message, exceptionNameTaggedText, stackTraceTaggedText, span), cancellationToken).ConfigureAwait(false);

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)

491expectedErrorMessage = 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)

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

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

HandlerTests.cs (10)

150if (exception.Message == nameof(HandlerTests) || exception.InnerException?.Message == nameof(HandlerTests)) 178if (exception.Message == nameof(HandlerTests) || exception.InnerException?.Message == nameof(HandlerTests)) 206if (exception.Message == nameof(HandlerTests) || exception.InnerException?.Message == nameof(HandlerTests)) 236if (exception.Message == nameof(HandlerTests) || exception.InnerException?.Message == nameof(HandlerTests)) 264if (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)

259error = 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)

494Debug.Assert(false, ex.Message);

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

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

259error = 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 (1)

Services\EditAndContinue\RemoteEditAndContinueService.cs (1)

156return 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)

305results = EmitSolutionUpdateResults.Data.CreateFromInternalError(solution, e.Message, runningProjectInfos);

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)

91hubClient.Logger.TraceEvent(TraceEventType.Error, 1, $"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)

259error = 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)

212pePath = $"<unable to write file: '{pePath}' -- {e.Message}>"; 230pdbPath = $"<unable to write file: '{pdbPath}' -- {e.Message}>"; 498return (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 (17)

AnalyzerAssemblyLoaderTests.cs (4)

247analyzerMainReference.AnalyzerLoadFailed += (_, e) => AssertEx.Fail(e.Exception!.Message); 249analyzerDependencyReference.AnalyzerLoadFailed += (_, e) => AssertEx.Fail(e.Exception!.Message); 763analyzerMainReference.AnalyzerLoadFailed += (_, e) => AssertEx.Fail(e.Exception!.Message); 765analyzerDependencyReference.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);

InvokeUtil.cs (1)

158throw new Exception(inner.Message + inner.StackTrace);

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)

259error = 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)

360_reporter.Report(new ProjectDiagnostic(WorkspaceDiagnosticKind.Failure, exception.Message, projectChanges.ProjectId)); 377_reporter.Report(new ProjectDiagnostic(WorkspaceDiagnosticKind.Failure, exception.Message, projectChanges.ProjectId)); 507_reporter.Report(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, exception.Message, id)); 535_reporter.Report(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, exception.Message, documentId)); 539_reporter.Report(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, exception.Message, documentId)); 543_reporter.Report(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, exception.Message, documentId));

Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (16)

MSBuild\Logging\DiagnosticLog.cs (1)

32=> _items.Add(new DiagnosticLogItem(kind, exception.Message, projectFilePath));

Rpc\RpcServer.cs (1)

166response = 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)

259error = ex.Message;

src\Compilers\Core\Portable\InternalUtilities\XmlUtilities.cs (2)

82errorMessage = e.Message; 87errorMessage = 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.CodeAnalysis.Workspaces.MSBuild.UnitTests (9)

NewlyCreatedProjectsFromDotNetNew.cs (2)

195catch (InvalidOperationException ex) when (ex.Message.Contains("command: dotnet workload restore")) 197throw new InvalidOperationException($"The '{templateName}' template requires additional dotnet workloads to be installed. It should be excluded during template discovery. " + ex.Message);

RpcTests.cs (1)

201Assert.Contains("Exception thrown by test method!", exception.Message);

src\Workspaces\MSBuild\BuildHost\Rpc\RpcServer.cs (1)

166response = new Response { Id = request.Id, Exception = $"An exception of type {e.GetType()} was thrown: {e.Message}" };

VisualStudioMSBuildWorkspaceTests.cs (5)

869Assert.Equal(expected, e.Message); 887Assert.Equal(expected, e.Message); 1138Assert.Equal(expected, e.Message); 1160Assert.Equal(expected, e.Message); 1193Assert.Equal(expected, e.Message);

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

TestErrorReportingService.cs (1)

29=> OnError(exception.Message);

Microsoft.CodeAnalysis.Workspaces.UnitTests (10)

SolutionTests\SolutionTests.cs (2)

4571Assert.Equal(expected, ex.Message); 4585Assert.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.Package (3)

RequestExecutionQueue.cs (1)

290var 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 (5)

src\CheckRequiredDotNetVersion.cs (2)

52Log.LogError($"Error accessing file '{globalJsonPath}': {e.Message}"); 77Log.LogError($"Error reading file '{globalJsonPath}': {e.Message}");

src\Common\Internal\AssemblyResolution.cs (1)

42Log?.LogWarning($"AssemblyResolve: exception while loading '{fullPath}': {e.Message}");

src\DownloadFile.cs (2)

217Log.LogMessage($"Failed to download '{uri}' to '{DestinationPath}': {e.Message}"); 221Log.LogMessage($"Retrying download of '{uri}' to '{DestinationPath}' due to failure: '{e.Message}' ({attempt}/{Retries})");

Microsoft.DotNet.ArcadeAzureIntegration (1)

AzureCliCredentialWithAzNoUpdateWrapper.cs (1)

111Console.WriteLine($"Warning - Disable auto update of Azure CLI failed: {e.Message}");

Microsoft.DotNet.Build.Tasks.Feed (6)

src\AzureStorageAssetPublisher.cs (1)

65_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)

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

src\PublishArtifactsInManifestBase.cs (2)

1794Log.LogWarning(ex.Message); 1819Log.LogMessage(MessageImportance.Low, $"Unable to delete the directory because of {ex.Message} after {attempts} attempts.");

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)

121Log.LogMessage($"Unable to access dotnet cli {PackageType} version {Version} from feed {feed}, {SanitizeString(ex.Message)}"); 163Log.LogWarning($"Unable to resolve download link from feed {feed}; {SanitizeString(ex.Message)}"); 248Log.LogMessage(MessageImportance.Low, $"Hit exception in GetAsync(); will retry up to 10 times ({SanitizeString(toLog.Message)})"); 272Log.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)

198Log.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)

68string errorMessage = new Win32Exception(Marshal.GetLastWin32Error()).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 (2)

src\Common\Internal\AssemblyResolution.cs (1)

42Log?.LogWarning($"AssemblyResolve: exception while loading '{fullPath}': {e.Message}");

src\SignCheck.cs (1)

498Log.WriteError(e.Message);

Microsoft.DotNet.SignTool (2)

src\BatchSignUtil.cs (1)

457_log.LogError($"Updating '{dst}' with signed content failed: '{e.Message}'");

src\ZipData.cs (1)

526log.LogError(e.Message);

Microsoft.DotNet.Tar (1)

Program.cs (1)

47Console.Error.Write(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)

134e.Message);

Microsoft.DotNet.XUnitV3Extensions (1)

src\Microsoft.DotNet.XUnitExtensions.Shared\Discoverers\ConditionalTestDiscoverer.cs (1)

127errorTestCase = new ExecutionErrorTestCase(testMethod, details.TestCaseDisplayName, details.UniqueID, e.Message);

Microsoft.Extensions.AI (4)

ChatCompletion\FunctionInvokingChatClient.cs (2)

785message = $"{message} Exception: {result.Exception.Message}"; 842.SetStatus(ActivityStatusCode.Error, e.Message);

ChatCompletion\OpenTelemetryChatClient.cs (1)

375.SetStatus(ActivityStatusCode.Error, error.Message);

Embeddings\OpenTelemetryEmbeddingGenerator.cs (1)

247.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)

142Assert.Contains("JsonTypeInfo metadata", ex.Message); 143Assert.Contains(nameof(CustomType), ex.Message); 146Assert.Contains("JsonTypeInfo metadata", ex.Message); 147Assert.Contains(nameof(CustomType), ex.Message);

Microsoft.Extensions.AI.Ollama.Tests (3)

OllamaChatClientIntegrationTests.cs (2)

100Assert.Contains("inexistent-model", ex.Message); 103Assert.Contains("inexistent-model", ex.Message);

OllamaEmbeddingGeneratorIntegrationTests.cs (1)

30Assert.Contains("inexistent-model", ex.Message);

Microsoft.Extensions.AI.Templates.Tests (1)

Infrastructure\ProcessExtensions.cs (1)

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

Microsoft.Extensions.AI.Tests (21)

ChatCompletion\ChatClientBuilderTest.cs (1)

78Assert.Contains("entry at index 0", ex.Message);

ChatCompletion\ChatClientStructuredOutputExtensionsTests.cs (2)

230Assert.Equal("The deserialized response is null.", ex.Message); 249Assert.Equal("The response did not contain JSON to be deserialized.", ex.Message);

ChatCompletion\DistributedCachingChatClientTest.cs (4)

186Assert.Equal("some failure", ex1.Message); 194Assert.Equal("some failure", ex2.Message); 497Assert.Equal("some failure", ex1.Message); 506Assert.Equal("some failure", ex2.Message);

ChatCompletion\FunctionInvokingChatClientTests.cs (8)

383Assert.Equal("Exception from call 11", ex.InnerExceptions[0].Message); 384Assert.Equal("Exception from call 12", ex.InnerExceptions[1].Message); 389Assert.Equal("Exception from call 11", ex.InnerExceptions[0].Message); 390Assert.Equal("Exception from call 12", ex.InnerExceptions[1].Message); 398Assert.Equal("Exception from call 11", ex.Message); 402Assert.Equal("Exception from call 11", ex.Message); 440Assert.Equal("It failed", ex.Message); 444Assert.Equal("It failed", ex.Message);

Embeddings\DistributedCachingEmbeddingGeneratorTest.cs (2)

191Assert.Equal("some failure", ex1.Message); 199Assert.Equal("some failure", ex2.Message);

Embeddings\EmbeddingGeneratorBuilderTests.cs (1)

78Assert.Contains("entry at index 0", ex.Message);

Functions\AIFunctionFactoryTest.cs (3)

76Assert.Contains("'theParam'", e.Message); 608Assert.Contains("Unable to resolve", e.Message); 615Assert.Contains("Unable to resolve", e.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)

175Debug.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.DependencyInjection (1)

ServiceProvider.cs (1)

236throw 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); 186_logger.HandleDiskStatsException(ex.Message);

Windows\Disk\WindowsDiskMetrics.cs (2)

102_logger.DiskIoPerfCounterException(WindowsDiskPerfCounterNames.DiskIdleTimeCounter, ex.Message); 128_logger.DiskIoPerfCounterException(counterName, ex.Message);

Microsoft.Extensions.Diagnostics.ResourceMonitoring.Tests (10)

Linux\LinuxUtilizationParserCgroupV1Tests.cs (10)

92Assert.Contains("/sys/fs/cgroup/memory/memory.stat", r.Message); 93Assert.Contains("total_inactive_file", r.Message); 119Assert.Contains("/sys/fs/cgroup/memory/memory.usage_in_bytes", r.Message); 138Assert.Contains("lesser than", r.Message); 164Assert.Contains("/proc/meminfo", r.Message); 238Assert.Contains("/sys/fs/cgroup/cpuset/cpuset.cpus", r.Message); 259Assert.Contains("/sys/fs/cgroup/cpuset/cpuset.cpus", r.Message); 287Assert.Contains("/sys/fs/cgroup/cpu/cpu.cfs_", r.Message); 337Assert.Contains("proc/stat", r.Message); 354Assert.Contains("/sys/fs/cgroup/cpu/cpu.shares", r.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 (5)

ServiceEndpointResolverTests.cs (5)

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); 262Assert.Equal("throwing", exception.Message);

Microsoft.Extensions.Telemetry (3)

Logging\ExtendedLogger.cs (2)

152tags.Add(ExceptionMessage, exception.Message); 202_ = 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.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)

315throw Contracts.ExceptParam(nameof(folder), $"Failed to create folder for the provided path: {folder}. \nException: {exc.Message}"); 339ch.Info("Error deleting folder. {0}. Retry,", e.Message); 384throw 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.LanguageServices (13)

CallHierarchy\Finders\AbstractCallFinder.cs (1)

76completionErrorMessage = e.Message;

ErrorReporting\VisualStudioErrorReportingService.cs (1)

63new 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)

104result = new ExecuteQueryResult(e.Message);

MiddlewareAnalysisSample (1)

Startup.cs (1)

109Console.WriteLine($"MiddlewareException: {name}; {exception.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)

206string 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)

422RethrowAsParseException(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)

1869throw 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)

985AddValidationError(new ValidationError(rule, this, vue.Message, vue)); 1220AddValidationError(new ValidationError(rule, this, vue.Message, vue)); 1248ValidationError 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 (6)

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

289return new RejectedBuildResponse($"Error writing build request: {e.Message}"); 314response = new RejectedBuildResponse($"Error reading response: {e.Message}");

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

84builder.AppendLine($"Error: '{exception.GetType().Name}' '{exception.Message}' occurred during '{reason}'"); 140Debug.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)

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)

259error = 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)

257ConsoleUtil.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)

88errorBuilder.AppendFormat("Exception message: {0}{1}", Environment.NewLine, exception.Message); 165errorBuilder.AppendFormat("Exception message: {0}{1}", Environment.NewLine, exception.Message); 249errorBuilder.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)

174Log.LogError($"Unable to read '{outputFilePath}': {e.Message}"); 196Log.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 (81)

JsonSchemaExporter\JsonSchemaExporterTests.cs (2)

158Assert.Contains("The depth of the generated JSON schema exceeds the JsonSerializerOptions.MaxDepth setting.", ex.Message); 168Assert.Contains("ReferenceHandler.Preserve", ex.Message);

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) + "<br>").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)

309throw 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)

3617SR.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)

310Name, ex.Message)); 341ex.Message)); 364SR.Format(SR.Top_level_conversion_error_to_string, Name, ex.Message)); 377SR.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)

512string 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)

594_dataSet.RaiseMergeFailed(null, e.Message, _missingSchemaAction);

System.Data.Odbc (2)

src\libraries\Common\src\System\Data\Common\DbConnectionOptions.Common.cs (1)

512string msg1 = e.Message;

System\Data\Odbc\DbDataRecord.cs (1)

66throw new OverflowException(innerException.Message, innerException);

System.Diagnostics.DiagnosticSource (1)

System\Diagnostics\Activity.cs (1)

587exceptionTags.Add(new KeyValuePair<string, object?>(ExceptionMessageTag, exception.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)

292throw new OperationCanceledException(ex.Message, ex, cancellationToken);

System.IO.Ports (1)

System\IO\Ports\InternalResources.cs (1)

19return new Win32Exception(errorCode).Message;

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.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)

1724ReportOutOfBandMessage("ERROR: Exception during construction of EventSource " + Name + ": " + e.Message); 2204+ e.Message); 2449ReportOutOfBandMessage(errorPrefix + ": " + innerEx.GetType() + ":" + innerEx.Message); 2816ReportOutOfBandMessage("ERROR: Exception in Command Processing for EventSource " + Name + ": " + e.Message); 3458msg = "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)

652if (ex != null && !string.IsNullOrEmpty(ex.Message)) 654ex = 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)

421throw new Exception(ex.Message, ex); 892throw new Exception(ex.Message, ex); 910throw new Exception(ex.Message, ex); 922throw new Exception(ex.Message, ex);

System\Runtime\Serialization\SchemaImporter.cs (2)

815ThrowTypeCannotBeImportedException(typeName.Name, typeName.Namespace, SR.Format(SR.IsValueTypeFormattedIncorrectly, isValueTypeInnerText, fe.Message)); 1162ThrowTypeCannotBeImportedException(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 (14)

System\ExceptionExtensions.cs (1)

38new SerializationException(ex.Message, ex),

System\Private\Windows\BinaryFormat\BinaryFormatWriter.cs (2)

657new BinaryObjectString(3, exception.Message), 802Debug.WriteLine($"Failed to binary format: {ex.Message}");

System\Private\Windows\JsonData.cs (1)

124result = new NotSupportedException(ex.Message);

System\Private\Windows\Nrbf\SerializationRecordExtensions.cs (2)

59new NotSupportedException(ex.Message, ex), ex.StackTrace ?? string.Empty); 74Debug.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)

278Debug.Assert(e is NotSupportedException, e.Message);

System\TypeExtensions.cs (1)

281Debug.Fail(e.Message);

Windows\Win32\PInvokeCore.GetWindowText.cs (2)

33Debug.Fail($"GetWindowTextLength failed. Error: {new Win32Exception(error).Message}"); 52Debug.Fail($"GetWindowText failed. Error: {new Win32Exception().Message}");

Windows\Win32\System\Com\ComHelpers.cs (2)

109Debug.WriteLine($"Did not find IUnknown for {@object.GetType().Name}. {ex.Message}"); 223Debug.WriteLine($"{nameof(TryGetObjectForIUnknown)}: Failed to get object for {typeof(TObject).Name}. {ex.Message}");

Windows\Win32\System\Com\WinFormsComWrappers.cs (1)

86Debug.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)); 7929string 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)

1728SendValidationEvent(SR.Sch_InvalidIdAttribute, ex.Message, xso); 1769SendValidationEvent(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)

1278SendValidationEvent(SR.Sch_InvalidValueDetailedAttribute, new string[] { "schemaLocation", xsiSchemaLocation, s_dtStringArray.TypeCodeString, exception.Message }, exception); 1479SendValidationEvent(SR.Sch_ElementValueDataTypeDetailed, new string[] { QNameString(_context.LocalName!, _context.Namespace!), stringValue, GetTypeName(decl), exception.Message }, exception); 1650SendValidationEvent(SR.Sch_InvalidValueDetailedAttribute, new string[] { "type", xsiType, s_dtQName.TypeCodeString, exception.Message }, exception); 1861SendValidationEvent(SR.Sch_CannotLoadSchema, new string[] { uri, e.Message }, e, XmlSeverityType.Warning); 1963SendValidationEvent(SR.Sch_AttributeValueDataTypeDetailed, new string[] { attdef.Name.ToString(), stringValue, GetTypeName(decl), exception.Message }, exception); 1978SendValidationEvent(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.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.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)

80return new DiagnosticData(DiagnosticDescriptors.InvalidRegexArguments, method.DiagnosticLocation, e.Message);

RegexGenerator.Parser.cs (1)

157return new DiagnosticData(DiagnosticDescriptors.InvalidRegexArguments, GetComparableLocation(memberSyntax), e.Message);

System.Threading.Tasks.Dataflow (1)

Internal\Common.cs (1)

141return exception.Message;

System.Windows.Forms (42)

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)

379string newMessage = string.Format(SR.SerializationException, reader[ResXResourceWriter.TypeStr], pt.Y, pt.X, se.Message); 386string newMessage = string.Format(SR.InvocationException, reader[ResXResourceWriter.TypeStr], pt.Y, pt.X, tie.InnerException?.Message); 403XmlException 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)

3396Debug.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)

135Debug.Assert(false, $"Exception in PaintOver: {ex.Message}");

System\Windows\Forms\Controls\DataGridView\DataGridView.Methods.cs (1)

16725Debug.Fail($"DataGridView.OnPaint exception: {ex.Message} stack trace {ex.StackTrace}");

System\Windows\Forms\Controls\PropertyGrid\PropertyGrid.cs (2)

1645Debug.Fail($"{nameof(CreatePropertyTab)} failed. {exception.Message}"); 1682Debug.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)

1104e.Message, 1403Debug.Fail($"Failed to get properties: {e.GetType().Name},{e.Message}\n{e.StackTrace}"); 1447Debug.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)

3352Debug.Fail(ex.Message); 3379Debug.Fail(ex.Message); 4929string? exMessage = ex?.Message; 4941exMessage = ex.Message; 5002string? message = ex?.Message; 5014message = 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)

347string 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)

840string 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)

710string 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)

131string message = e.Message;

System\Windows\Forms\Design\SplitContainerDesigner.cs (1)

327uiService?.ShowError(ex.Message);

System\Windows\Forms\Design\StandardMenuStripVerb.cs (2)

225uiService.ShowError(e.Message); 368uiService.ShowError(e.Message);

System\Windows\Forms\Design\TableLayoutPanelDesigner.cs (5)

1704uiService.ShowError(ex.Message); 1781uiService.ShowError(ex.Message); 1943uiService.ShowError(ex.Message); 2038uiService.ShowError(ex.Message); 2057uiService.ShowError(ex.Message);

System\Windows\Forms\Design\ToolStripDesigner.cs (1)

2477GetService<IUIService>().ShowError(ex.Message);

System\Windows\Forms\Design\ToolStripItemCustomMenuItemCollection.cs (2)

246uiService.ShowError(ex.Message); 614uiService.ShowError(ex.Message);

System\Windows\Forms\Design\ToolStripMenuItemDesigner.cs (1)

824GetService<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.Interop.Tests (2)

PropertyGridTests.cs (2)

38Assert.Equal("Error From StandardErrorInfoUsageTest", ex.Message); 69Assert.Equal("Error From RawErrorInfoUsageTest", ex.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 (3)

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\DataGridViewLinkCellTests.cs (1)

675ex.InnerException!.Message.Should().Contain("cellStyle");

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 (16)

src\ProjectTemplates\Shared\Project.cs (1)

453DiagnosticsMessageSink.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 (10)

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 (17)

src\ProjectTemplates\Shared\Project.cs (1)

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

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

src\Shared\E2ETesting\BrowserFixture.cs (1)

214output.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 (17)

src\ProjectTemplates\Shared\Project.cs (1)

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

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

src\Shared\E2ETesting\BrowserFixture.cs (1)

214output.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 (17)

src\ProjectTemplates\Shared\Project.cs (1)

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

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

src\Shared\E2ETesting\BrowserFixture.cs (1)

214output.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 (17)

src\ProjectTemplates\Shared\Project.cs (1)

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

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

src\Shared\E2ETesting\BrowserFixture.cs (1)

214output.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)

259error = 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)

99Console.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)

259error = 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 (4)

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

289return new RejectedBuildResponse($"Error writing build request: {e.Message}"); 314response = new RejectedBuildResponse($"Error reading response: {e.Message}");

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

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

VBCSCompiler (6)

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 (2)

289return new RejectedBuildResponse($"Error writing build request: {e.Message}"); 314response = new RejectedBuildResponse($"Error reading response: {e.Message}");

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

84builder.AppendLine($"Error: '{exception.GetType().Name}' '{exception.Message}' occurred during '{reason}'"); 140Debug.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}");