Equal

AspireAzureAIOpenAIExtensionsTests.cs (1)

194Assert.Equal(applicationId, options.ApplicationId);

AspireTablesExtensionsTests.cs (6)

40Assert.Equal("aspirestoragetests", client.AccountName); 67Assert.Equal("aspirestoragetests", client.AccountName); 97Assert.Equal("aspirestoragetests", client.AccountName); 125Assert.Equal("aspirestoragetests", client.AccountName); 154Assert.Equal("account2", client2.AccountName); 155Assert.Equal("account3", client3.AccountName);

AspireEventHubsExtensionsTests.cs (4)

176Assert.Equal("customidentifier", assignedIdentifier); 238Assert.Equal("customidentifier", assignedIdentifier); 304Assert.Equal("customidentifier", assignedIdentifier); 473Assert.Equal(expectedNamespace, client switch

AspireServiceBusExtensionsTests.cs (7)

AspireWebPubSubExtensionsTests.cs (15)

41Assert.Equal(ConformanceTests.Endpoint, client.Endpoint.AbsoluteUri); 42Assert.Equal("hub1", client.Hub); 76Assert.Equal(ConformanceTests.Endpoint, client.Endpoint.AbsoluteUri); 77Assert.Equal("hub1", client.Hub); 107Assert.Equal(ConformanceTests.Endpoint, client.Endpoint.AbsoluteUri); 108Assert.Equal("hub1", client.Hub); 136Assert.Equal(ConformanceTests.Endpoint, client.Endpoint.AbsoluteUri); 137Assert.Equal("hub1", client.Hub); 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); 177Assert.Equal(ConformanceTests.Endpoint, client.Endpoint.AbsoluteUri); 178Assert.Equal("key", client.Hub); 196Assert.Equal("hub1", client1.Hub); 197Assert.Equal(ConformanceTests.Endpoint, client1.Endpoint.AbsoluteUri); 199Assert.Equal("hub2", client2.Hub); 200Assert.Equal(ConformanceTests.Endpoint, client2.Endpoint.AbsoluteUri);

AspireKeyVaultExtensionsTests.cs (2)

142Assert.Equal("Secret 1 Value", builder.Configuration["super-secret-1"]); 143Assert.Equal("Secret 2 Value", builder.Configuration["super-secret-2"]);

AspireBlobStorageExtensionsTests.cs (6)

40Assert.Equal("aspirestoragetests", client.AccountName); 67Assert.Equal("aspirestoragetests", client.AccountName); 97Assert.Equal("aspirestoragetests", client.AccountName); 125Assert.Equal("aspirestoragetests", client.AccountName); 154Assert.Equal("aspirestoragetests2", client2.AccountName); 155Assert.Equal("aspirestoragetests3", client3.AccountName);

AspireQueueStorageExtensionsTests.cs (6)

40Assert.Equal("aspirestoragetests", client.AccountName); 67Assert.Equal("aspirestoragetests", client.AccountName); 97Assert.Equal("aspirestoragetests", client.AccountName); 125Assert.Equal("aspirestoragetests", client.AccountName); 154Assert.Equal("aspirestoragetests2", client2.AccountName); 155Assert.Equal("aspirestoragetests3", client3.AccountName);

ConformanceTests.cs (1)

345Assert.Equal(error, detail.Errors!.First().Value);

ConsumerConfigurationTests.cs (7)

44Assert.Equal(CommonHelpers.TestingEndpoint, config.BootstrapServers); 77Assert.Equal(CommonHelpers.TestingEndpoint, config.BootstrapServers); 110Assert.Equal(CommonHelpers.TestingEndpoint, config.BootstrapServers); 199Assert.Equal(CommonHelpers.TestingEndpoint, config.BootstrapServers); 258Assert.Equal("consumer-group", config.GroupId); 259Assert.Equal("user", config.SaslUsername); 260Assert.Equal("password", config.SaslPassword);

ProducerConfigurationTests.cs (6)

41Assert.Equal(CommonHelpers.TestingEndpoint, config.BootstrapServers); 71Assert.Equal(CommonHelpers.TestingEndpoint, config.BootstrapServers); 103Assert.Equal(CommonHelpers.TestingEndpoint, config.BootstrapServers); 189Assert.Equal(CommonHelpers.TestingEndpoint, config.BootstrapServers); 247Assert.Equal("user", config.SaslUsername); 248Assert.Equal("password", config.SaslPassword);

Controls\PlotlyChartTests.cs (5)

43Assert.Equal("import", i.Identifier); 96Assert.Equal("import", i.Identifier); 101Assert.Equal("initializeChart", i.Identifier); 105Assert.Equal("Unit-<b>Bold</b>", trace.Name); 106Assert.Equal("<b>Name-<b>Bold</b></b><br />Unit-<b>Bold</b>: 1<br />Time: 12:59:57 AM", trace.Tooltips[0]);

Controls\TextVisualizerDialogTests.cs (10)

47Assert.Equal(expectedJson, instance.FormattedText); 48Assert.Equal(TextVisualizerDialog.JsonFormat, instance.FormatKind); 69Assert.Equal(TextVisualizerDialog.XmlFormat, instance.FormatKind); 70Assert.Equal(expectedXml, instance.FormattedText); 76Assert.Equal(TextVisualizerDialog.PlaintextFormat, instance.FormatKind); 77Assert.Equal(rawXml, instance.FormattedText); 95Assert.Equal(TextVisualizerDialog.XmlFormat, instance.FormatKind); 96Assert.Equal(expectedXml, instance.FormattedText); 110Assert.Equal(TextVisualizerDialog.PlaintextFormat, instance.FormatKind); 111Assert.Equal(rawText, instance.FormattedText);

GridColumnManagerTests.cs (5)

36Assert.Equal("1fr 1fr 3fr", manager.GetGridTemplateColumns()); 39Assert.Equal("1fr 0.5fr 2fr 4fr", manager.GetGridTemplateColumns()); 101Assert.Equal("1fr 1fr 3fr", manager.GetGridTemplateColumns()); 105Assert.Equal("1fr 0.5fr 2fr 4fr", manager.GetGridTemplateColumns()); 109Assert.Equal("1fr 1fr 3fr", manager.GetGridTemplateColumns());

Pages\ConsoleLogsTests.cs (2)

87Assert.Equal("test-resource", Assert.Single(subscribedResourceNames)); 131Assert.Equal("test-resource", subscribedResource);

Pages\MetricsTests.cs (10)

111Assert.Equal("/metrics/resource/TestApp", loadRedirect.AbsolutePath); 114Assert.Equal("test-meter", query["meter"]); 115Assert.Equal("test-instrument", query["instrument"]); 116Assert.Equal("720", query["duration"]); 117Assert.Equal(MetricViewKind.Table.ToString(), query["view"]); 173Assert.Equal("test-meter", viewModel.SelectedMeter!.MeterName); 174Assert.Equal(app1InstrumentName, viewModel.SelectedInstrument!.Name); 181cut.WaitForAssertion(() => Assert.Equal("TestApp2", viewModel.SelectedApplication.Name), TestConstants.WaitTimeout); 183Assert.Equal(expectedInstrumentNameAfterChange, viewModel.SelectedInstrument?.Name); 187Assert.Equal("test-meter", viewModel.SelectedMeter!.MeterName);

Pages\StructuredLogsTests.cs (12)

55Assert.Equal(KnownStructuredLogFields.TraceIdField, f.Field); 56Assert.Equal("123", f.Value); 60Assert.Equal(KnownStructuredLogFields.SpanIdField, f.Field); 61Assert.Equal("456", f.Value); 95Assert.Equal(filter.Field, f.Field); 97Assert.Equal(filter.Value, f.Value); 133Assert.Equal(filter1.Field, f.Field); 135Assert.Equal(filter1.Value, f.Value); 139Assert.Equal(filter2.Field, f.Field); 141Assert.Equal(filter2.Value, f.Value); 145Assert.Equal(filter3.Field, f.Field); 147Assert.Equal(filter3.Value, f.Value);

tests\Shared\Telemetry\TelemetryTestHelpers.cs (1)

28Assert.Equal(expected, resolvedActual);

BrowserLinkOutgoingPeerResolverTests.cs (1)

111Assert.Equal("Browser Link", name);

ConsoleLogsTests\AnsiParserTests.cs (25)

ConsoleLogsTests\CreateResourceSelectModelsTests.cs (14)

55Assert.Equal("App1", entry.Id.ReplicaSetName); 57Assert.Equal("App1", entry.Name); 63Assert.Equal("App1-r1", entry.Id.InstanceId); 64Assert.Equal("App1", entry.Id.ReplicaSetName); 66Assert.Equal("App1-r1", entry.Name); 72Assert.Equal("App1-r2", entry.Id.InstanceId); 73Assert.Equal("App1", entry.Id.ReplicaSetName); 75Assert.Equal($"App1-r2 ({unknownStateText})", entry.Name); 81Assert.Equal("App2", entry.Id.InstanceId); 83Assert.Equal("App2 (Starting)", entry.Name); 89Assert.Equal("App3", entry.Id.InstanceId); 91Assert.Equal("App3 (Finished)", entry.Name); 97Assert.Equal("App4", entry.Id.InstanceId); 99Assert.Equal("App4", entry.Name);

ConsoleLogsTests\LogEntriesTests.cs (24)

ConsoleLogsTests\UrlParserTests.cs (2)

32Assert.Equal(expectedOutput, modifiedText); 48Assert.Equal(expectedOutput, modifiedText);

DashboardOptionsTests.cs (17)

DashboardUrlsTests.cs (6)

25Assert.Equal($"/consolelogs/resource/resource{PlaceholderAllCharactersEncoded}", DashboardUrls.ConsoleLogsUrl(resource: $"resource{PlaceholderInput}")); 40Assert.Equal($"/structuredlogs/resource/resource{PlaceholderAllCharactersEncoded}?logLevel=error&filters=test%3Acontains%3Avalue&traceId={PlaceholderAllButExclamationMarkEncoded}&spanId={PlaceholderAllButExclamationMarkEncoded}", singleFilterUrl); 52Assert.Equal($"/structuredlogs/resource/resource{PlaceholderAllCharactersEncoded}?logLevel=error&filters=test%3Acontains%3Avalue%20fieldWithSpacedValue%3Agt%3A!!%2Bmultiple%2Bwords%2Bhere%2B!!%20name%3A!equals%3AnameValue&traceId={PlaceholderAllButExclamationMarkEncoded}&spanId={PlaceholderAllButExclamationMarkEncoded}", multipleFiltersIncludingSpacesUrl); 58Assert.Equal($"/traces/resource/resource{PlaceholderAllCharactersEncoded}", DashboardUrls.TracesUrl(resource: $"resource{PlaceholderInput}")); 64Assert.Equal($"/traces/detail/traceId{PlaceholderAllCharactersEncoded}", DashboardUrls.TraceDetailUrl(traceId: $"traceId{PlaceholderInput}")); 77Assert.Equal($"/metrics/resource/resource{PlaceholderAllCharactersEncoded}?meter=meter{PlaceholderAllButExclamationMarkEncoded}&instrument=meter{PlaceholderAllButExclamationMarkEncoded}&duration=10&view=table", url);

DurationFormatterTests.cs (10)

FormatHelpersTests.cs (6)

22Assert.Equal(expected, FormatHelpers.FormatNumberWithOptionalDecimalPlaces(value, maxDecimalPlaces: 6, CultureInfo.InvariantCulture)); 33Assert.Equal(expected, FormatHelpers.FormatNumberWithOptionalDecimalPlaces(value, maxDecimalPlaces: 6, CultureInfo.GetCultureInfo("de-DE"))); 45Assert.Equal(expected, FormatHelpers.FormatDateTime(CreateTimeProvider(), date, includeMilliseconds, cultureInfo: CultureInfo.InvariantCulture)); 57Assert.Equal(expected, FormatHelpers.FormatDateTime(CreateTimeProvider(), date, includeMilliseconds, cultureInfo: CultureInfo.GetCultureInfo("de-DE"))); 69Assert.Equal(expected, FormatHelpers.FormatDateTime(CreateTimeProvider(), date, includeMilliseconds, cultureInfo: CultureInfo.GetCultureInfo("fi-FI"))); 81Assert.Equal(expected, FormatHelpers.FormatDateTime(CreateTimeProvider(), date, includeMilliseconds, cultureInfo: CultureInfo.GetCultureInfo("en-NZ")));

Integration\FrontendBrowserTokenAuthTests.cs (3)

46Assert.Equal(DashboardUrls.LoginUrl(returnUrl: DashboardUrls.StructuredLogsUrl()), response.RequestMessage!.RequestUri!.PathAndQuery); 101Assert.Equal("FrontendComposite was not authenticated. Failure message: Connection type Frontend is not enabled on this connection.", log.Message); 240Assert.Equal(linkHost, uri.Host);

Integration\FrontendOpenIdConnectAuthTests.cs (6)

48Assert.Equal("localhost", redirectedTo.Host); 49Assert.Equal("/authorize", redirectedTo.AbsolutePath); 52Assert.Equal("MyClientId", query.Get("client_id")); 53Assert.Equal("code", query.Get("response_type")); 54Assert.Equal("openid profile", query.Get("scope")); 90Assert.Equal("FrontendComposite was not authenticated. Failure message: Connection type Frontend is not enabled on this connection.", log.Message);

Integration\OtlpCorsHttpServiceTests.cs (9)

Integration\OtlpGrpcServiceTests.cs (2)

224Assert.Equal("Different", options.Otlp.PrimaryApiKey); 262Assert.Equal(TestCertificateLoader.GetTestCertificate().Thumbprint, clientCallbackCert.Thumbprint);

Integration\OtlpHttpServiceTests.cs (6)

53Assert.Equal(OtlpHttpEndpointsBuilder.ProtobufContentType, responseMessage.Content.Headers.GetValues("content-type").Single()); 179Assert.Equal(OtlpHttpEndpointsBuilder.ProtobufContentType, responseMessage.Content.Headers.GetValues("content-type").Single()); 212Assert.Equal(TestCertificateLoader.GetTestCertificate().Thumbprint, clientCallbackCert.Thumbprint); 294Assert.Equal(OtlpHttpEndpointsBuilder.ProtobufContentType, responseMessage.Content.Headers.GetValues("content-type").Single()); 323Assert.Equal(OtlpHttpEndpointsBuilder.ProtobufContentType, responseMessage.Content.Headers.GetValues("content-type").Single()); 352Assert.Equal(OtlpHttpEndpointsBuilder.ProtobufContentType, responseMessage.Content.Headers.GetValues("content-type").Single());

Integration\Playwright\BrowserTokenAuthenticationTests.cs (3)

40Assert.Equal("/login?returnUrl=%2F", uri.PathAndQuery); 65Assert.Equal("/login?returnUrl=%2F", uri.PathAndQuery); 109Assert.Equal("submit-token", name);

Integration\StartupTests.cs (6)

167Assert.Equal(frontendBrowserToken, localBuilder.Configuration[DashboardConfigNames.DashboardFrontendBrowserTokenName.ConfigKey]); 256Assert.Equal("TestKey123!", app.DashboardOptionsMonitor.CurrentValue.Otlp.PrimaryApiKey); 409Assert.Equal(OtlpHttpEndpointsBuilder.ProtobufContentType, responseMessage.Content.Headers.GetValues("content-type").Single()); 474Assert.Equal("MySubject", app.DashboardOptionsMonitor.CurrentValue.ResourceServiceClient.ClientCertificate.Subject); 580Assert.Equal("https", uri.Scheme); 581Assert.Equal("localhost", uri.Host);

LocalBrowserStorageTests.cs (4)

38Assert.Equal("localStorage.setItem", identifier); 65Assert.Equal("localStorage.getItem", identifier); 90Assert.Equal("localStorage.getItem", identifier); 115Assert.Equal("localStorage.getItem", identifier);

Middleware\ValidateTokenMiddlewareTests.cs (6)

22Assert.Equal("/", response.Headers.Location?.OriginalString); 30Assert.Equal("/test", response.Headers.Location?.OriginalString); 38Assert.Equal("/login", response.Headers.Location?.OriginalString); 46Assert.Equal("/login?returnUrl=%2ftest", response.Headers.Location?.OriginalString); 54Assert.Equal("/", response.Headers.Location?.OriginalString); 62Assert.Equal("/test", response.Headers.Location?.OriginalString);

Model\ApplicationsSelectHelpersTests.cs (26)

Model\DefaultInstrumentUnitResolverTests.cs (1)

42Assert.Equal(expected, result);

Model\ResourceEndpointHelpersTests.cs (44)

Model\ResourceViewModelTests.cs (8)

40Assert.Equal("Value!", e.Value); 57Assert.Equal(@"Error converting resource ""TestName-abc"" to ResourceViewModel.", ex.Message); 87Assert.Equal("Property1", p.Key); 88Assert.Equal("Property1", p.Value.Name); 89Assert.Equal("Value1", p.Value.Value.StringValue); 97Assert.Equal("Property2", p.Key); 98Assert.Equal("Property2", p.Value.Name); 99Assert.Equal("Value2", p.Value.Value.StringValue);

Model\TargetLocationInterceptorTests.cs (4)

15Assert.Equal(TargetLocationInterceptor.StructuredLogsPath, newTargetLocation); 22Assert.Equal(TargetLocationInterceptor.StructuredLogsPath, newTargetLocation); 29Assert.Equal(TargetLocationInterceptor.StructuredLogsPath, newTargetLocation); 36Assert.Equal(TargetLocationInterceptor.StructuredLogsPath, newTargetLocation);

OtlpApiKeyAuthenticationHandlerTests.cs (2)

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

ResourceOutgoingPeerResolverTests.cs (7)

72Assert.Equal("test", value); 86Assert.Equal("test", value); 100Assert.Equal("test", value); 114Assert.Equal("test", value); 173Assert.Equal("test", value); 188Assert.Equal("test-abc", value1); 191Assert.Equal("test-def", value2);

StringExtensionsTests.cs (1)

36Assert.Equal(expectedResult, actual);

TelemetryFilterFormatterTests.cs (4)

28Assert.Equal("test:name", filter.Field); 29Assert.Equal("test:value", filter.Value); 48Assert.Equal("test+name", filter.Field); 49Assert.Equal("test+value", filter.Value);

TelemetryRepositoryTests\ApplicationTests.cs (20)

TelemetryRepositoryTests\LogTests.cs (66)

61Assert.Equal("TestService", app.ApplicationName); 62Assert.Equal("TestId", app.InstanceId); 75Assert.Equal("546573745370616e4964", app.SpanId); 76Assert.Equal("5465737454726163654964", app.TraceId); 77Assert.Equal("Test {Log}", app.OriginalFormat); 78Assert.Equal("Test Value!", app.Message); 79Assert.Equal("TestLogger", app.Scope.ScopeName); 83Assert.Equal("Log", p.Key); 84Assert.Equal("Value!", p.Value); 90s => Assert.Equal("Log", s)); 141Assert.Equal("1", l.Message); 142Assert.Equal("", l.Scope.ScopeName); 144l => Assert.Equal("2", l.Message), 145l => Assert.Equal("3", l.Message), 146l => Assert.Equal("4", l.Message), 147l => Assert.Equal("5", l.Message), 148l => Assert.Equal("6", l.Message), 149l => Assert.Equal("7", l.Message), 150l => Assert.Equal("8", l.Message), 151l => Assert.Equal("9", l.Message), 152l => Assert.Equal("10", l.Message)); 443Assert.Equal("TestService", app.ApplicationName); 444Assert.Equal("TestId", app.InstanceId); 570Assert.Equal("CustomValue", callbackValue); 615Assert.Equal("TestService", app.ApplicationName); 616Assert.Equal("TestId", app.InstanceId); 629Assert.Equal("Test {Log}", app.OriginalFormat); 630Assert.Equal("0123456789012345", app.Message); 634Assert.Equal("Key0", p.Key); 635Assert.Equal("01234", p.Value); 639Assert.Equal("Key1", p.Key); 640Assert.Equal("0123456789", p.Value); 644Assert.Equal("Key2", p.Key); 645Assert.Equal("012345678901234", p.Value); 649Assert.Equal("Key3", p.Key); 650Assert.Equal("0123456789012345", p.Value); 654Assert.Equal("Key4", p.Key); 655Assert.Equal("0123456789012345", p.Value); 827Assert.Equal("App1", app.ApplicationName); 828Assert.Equal("computer-name", app.InstanceId); 832Assert.Equal("App2", app.ApplicationName); 833Assert.Equal("computer-name", app.InstanceId); 846Assert.Equal("546573745370616e4964", app.SpanId); 847Assert.Equal("5465737454726163654964", app.TraceId); 848Assert.Equal("Test {Log}", app.OriginalFormat); 849Assert.Equal("Test Value!", app.Message); 850Assert.Equal("TestLogger", app.Scope.ScopeName); 854Assert.Equal("Log", p.Key); 855Assert.Equal("Value!", p.Value); 869Assert.Equal("546573745370616e4964", app.SpanId); 870Assert.Equal("5465737454726163654964", app.TraceId); 871Assert.Equal("Test {Log}", app.OriginalFormat); 872Assert.Equal("Test Value!", app.Message); 873Assert.Equal("TestLogger", app.Scope.ScopeName); 877Assert.Equal("Log", p.Key); 878Assert.Equal("Value!", p.Value); 945Assert.Equal("message-1", app.Message); 946Assert.Equal("TestLogger", app.Scope.ScopeName); 950Assert.Equal("key-1", p.Key); 951Assert.Equal("value-1", p.Value); 956Assert.Equal("message-2", app.Message); 957Assert.Equal("TestLogger", app.Scope.ScopeName); 961Assert.Equal("key-2", p.Key); 962Assert.Equal("value-2", p.Value); 968s => Assert.Equal("key-1", s), 969s => Assert.Equal("key-2", s));

TelemetryRepositoryTests\MetricsTests.cs (79)

TelemetryRepositoryTests\OtlpHelpersTests.cs (5)

23Assert.Equal("string!", s); 39Assert.Equal("48656c6c6f20776f726c64", s); 52Assert.Equal("", s); 75Assert.Equal("[true,null]", s); 138Assert.Equal(@"{""prop1"":[""string!"",1.1,1],""prop2"":""48656c6c6f20776f726c64"",""prop3"":{""nestedProp1"":""nested!""}}", s);

TelemetryRepositoryTests\TraceTests.cs (62)

71Assert.Equal("TestService", app.ApplicationName); 72Assert.Equal("TestId", app.InstanceId); 145Assert.Equal("TestService", app.ApplicationName); 146Assert.Equal("TestId", app.InstanceId); 166span => Assert.Equal("scope1", span.Scope.ScopeName), 167span => Assert.Equal("scope2", span.Scope.ScopeName)); 222Assert.Equal("TestService", app.ApplicationName); 223Assert.Equal("TestId", app.InstanceId); 281Assert.Equal("", trace.FirstSpan.Scope.ScopeName); 288Assert.Equal("", trace.FirstSpan.Scope.ScopeName); 408Assert.Equal("Event 1", e.Name); 412Assert.Equal("key1", a.Key); 413Assert.Equal("Value!", a.Value); 418Assert.Equal("Event 2", e.Name); 490Assert.Equal("key2", a.Key); 491Assert.Equal("Value!", a.Value); 501Assert.Equal("key1", a.Key); 502Assert.Equal("Value!", a.Value); 515Assert.Equal("key2", a.Key); 516Assert.Equal("Value!", a.Value); 526Assert.Equal("key1", a.Key); 527Assert.Equal("Value!", a.Value); 639Assert.Equal("TestService", app.ApplicationName); 640Assert.Equal("TestId", app.InstanceId); 659Assert.Equal("Key0", p.Key); 660Assert.Equal("01234", p.Value); 664Assert.Equal("Key1", p.Key); 665Assert.Equal("0123456789", p.Value); 669Assert.Equal("Key2", p.Key); 670Assert.Equal("012345678901234", p.Value); 674Assert.Equal("Key3", p.Key); 675Assert.Equal("0123456789012345", p.Value); 679Assert.Equal("Key4", p.Key); 680Assert.Equal("0123456789012345", p.Value); 763Assert.Equal("TestService", app.ApplicationName); 764Assert.Equal("TestId", app.InstanceId); 779Assert.Equal("1988", first); 780Assert.Equal("2000", last); 964s => Assert.Equal("key-1", s), 965s => Assert.Equal("key-2", s)); 1170Assert.Equal("TestService: Test span. Id: 1-3", trace.FullName); 1195Assert.Equal("TestService: Test span. Id: 1-2", trace.FullName); 1220Assert.Equal("TestService: Test span. Id: 1-1", trace.FullName); 1245Assert.Equal("TestService: Test span. Id: 1-1", trace.FullName); 1310Assert.Equal("TestService", application.ApplicationName); 1311Assert.Equal("TestId", application.InstanceId); 1321Assert.Equal("prop1", p.Key); 1322Assert.Equal("value1", p.Value); 1330Assert.Equal("prop1", p.Key); 1331Assert.Equal("value2", p.Value); 1335Assert.Equal("prop2", p.Key); 1336Assert.Equal("value1", p.Value); 1357Assert.Equal("prop1", p.Key); 1358Assert.Equal("value1", p.Value); 1367Assert.Equal("prop1", p.Key); 1368Assert.Equal("value2", p.Value); 1372Assert.Equal("prop2", p.Key); 1373Assert.Equal("value1", p.Value); 1382Assert.Equal("prop1", p.Key); 1383Assert.Equal("value2", p.Value); 1387Assert.Equal("prop2", p.Key); 1388Assert.Equal("value1", p.Value);

tests\Shared\Telemetry\TelemetryTestHelpers.cs (1)

28Assert.Equal(expected, resolvedActual);

AspireElasticClientExtensionsTest.cs (1)

164Assert.Equal("ping", activity.OperationName);

ElasticsearchClientPublicApiTests.cs (6)

21Assert.Equal(nameof(builder), exception.ParamName); 34Assert.Equal(nameof(connectionName), exception.ParamName); 47Assert.Equal(nameof(connectionName), exception.ParamName); 60Assert.Equal(nameof(builder), exception.ParamName); 73Assert.Equal(nameof(name), exception.ParamName); 86Assert.Equal(nameof(name), exception.ParamName);

AWSCDKResourceTests.cs (10)

30Assert.Equal("Stack", resource.Name); 33Assert.Equal("test-profile", resource.AWSSDKConfig.Profile); 54Assert.Equal("Other", resource.Name); 57Assert.Equal("test-profile", resource.AWSSDKConfig.Profile); 80Assert.Equal("Other", stackResource.Name); 83Assert.Equal("other-test-profile", stackResource.AWSSDKConfig.Profile); 86Assert.Equal("Stack", cdkResource.Name); 89Assert.Equal("test-profile", cdkResource.AWSSDKConfig.Profile); 102Assert.Equal("Construct", resource.Name); 136Assert.Equal(expectedManifest, manifest.ToString());

AWSCloudFormationResourceTests.cs (6)

26Assert.Equal("ExistingStack", resource.Name); 29Assert.Equal("test-profile", resource.AWSSDKConfig.Profile); 48Assert.Equal("NewStack", resource.Name); 49Assert.Equal("cf.template", resource.TemplatePath); 55Assert.Equal("value1", resource.CloudFormationParameters["key1"]); 56Assert.Equal("value2", resource.CloudFormationParameters["key2"]);

CloudFormationAWSConsoleUrlTests.cs (2)

22Assert.Equal( 38Assert.Equal(

StackOutputReferenceTests.cs (3)

31Assert.Equal("key1", reference.Name); 38Assert.Equal("value1", value); 57Assert.Equal("{NewStack.output.key1}", reference.ValueExpression);

AzureBicepProvisionerTests.cs (9)

27Assert.Equal("david", parameters["name"]?["value"]?.ToString()); 63Assert.Equal("john", parameters["name"]?["value"]?.ToString()); 66Assert.Equal("connection string", parameters["conn"]?["value"]?.ToString()); 67Assert.Equal("value", parameters["jsonObj"]?["value"]?["key"]?.ToString()); 68Assert.Equal("paramValue", parameters["param"]?["value"]?.ToString()); 69Assert.Equal("paramValue/1", parameters["expr"]?["value"]?.ToString()); 70Assert.Equal("http://localhost:1023", parameters["endpoint"]?["value"]?.ToString()); 98Assert.Equal(checkSum0, checkSum1); 116Assert.Equal("Bicep parameter names must only contain alpha, numeric, and _ characters and must start with an alpha or _ characters. (Parameter 'bicepParameterName')", ex.Message);

AzureBicepResourceTests.cs (143)

AzureContainerAppsTests.cs (20)

AzureEventHubsExtensionsTests.cs (11)

24Assert.Equal(Path.Combine(builder.AppHostDirectory, ".eventhubs", "eh"), volumeAnnotation.Source); 25Assert.Equal("/data", volumeAnnotation.Target); 41Assert.Equal(Path.Combine(builder.AppHostDirectory, "mydata"), volumeAnnotation.Source); 42Assert.Equal("/data", volumeAnnotation.Target); 58Assert.Equal($"{builder.GetVolumePrefix()}-eh-data", volumeAnnotation.Source); 59Assert.Equal("/data", volumeAnnotation.Target); 75Assert.Equal("mydata", volumeAnnotation.Source); 76Assert.Equal("/data", volumeAnnotation.Target); 119Assert.Equal(imageTag ?? EventHubsEmulatorContainerImageTags.Tag, containerImageAnnotation.Tag); 120Assert.Equal(EventHubsEmulatorContainerImageTags.Registry, containerImageAnnotation.Registry); 121Assert.Equal(EventHubsEmulatorContainerImageTags.Image, containerImageAnnotation.Image);

AzurePostgresExtensionsTests.cs (5)

36Assert.Equal(expectedManifest, manifest.ManifestNode.ToString()); 126Assert.Equal(expectedBicep, manifest.BicepText); 158Assert.Equal(expectedManifest, manifest.ManifestNode.ToString()); 234Assert.Equal(expectedBicep, manifest.BicepText); 307Assert.Equal("Host=localhost;Port=12455;Username=user;Password=p@ssw0rd1", await postgres.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None));

AzureRedisExtensionsTests.cs (5)

33Assert.Equal(expectedManifest, manifest.ManifestNode.ToString()); 77Assert.Equal(expectedBicep, manifest.BicepText); 100Assert.Equal(expectedManifest, manifest.ManifestNode.ToString()); 139Assert.Equal(expectedBicep, manifest.BicepText); 155Assert.Equal("localhost:12455", await redis.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None));

AzureResourceExtensionsTests.cs (10)

34Assert.Equal(Path.Combine(builder.AppHostDirectory, ".azurite", "storage"), volumeAnnotation.Source); 35Assert.Equal("/data", volumeAnnotation.Target); 60Assert.Equal(Path.Combine(builder.AppHostDirectory, "mydata"), volumeAnnotation.Source); 61Assert.Equal("/data", volumeAnnotation.Target); 86Assert.Equal($"{builder.GetVolumePrefix()}-storage-data", volumeAnnotation.Source); 87Assert.Equal("/data", volumeAnnotation.Target); 112Assert.Equal("mydata", volumeAnnotation.Source); 113Assert.Equal("/data", volumeAnnotation.Target); 176Assert.Equal(imageTag ?? "latest", actualTag); 191Assert.Equal(partitionCount.ToString(CultureInfo.InvariantCulture), config["AZURE_COSMOS_EMULATOR_PARTITION_COUNT"]);

AzureResourceOptionsTests.cs (1)

77Assert.Equal(expectedBicep, actualBicep);

AzureServiceBusExtensionsTests.cs (1)

64Assert.Equal(expectedBicep, manifest.BicepText);

AzureStorageEmulatorFunctionalTests.cs (1)

92Assert.Equal("testValue", downloadResult.Content.ToString());

ResourceGroupNameHelpersTests.cs (1)

23Assert.Equal(expected, result);

ContainerImageAnnotationTests.cs (2)

22Assert.Equal("latest", annotation.Tag); 37Assert.Equal("pretendthisisasha", annotation.SHA256);

ContainerResourceBuilderTests.cs (13)

ContainerResourceTests.cs (16)

26Assert.Equal("container", containerResource.Name); 28Assert.Equal("latest", containerAnnotation.Tag); 29Assert.Equal("none", containerAnnotation.Image); 45Assert.Equal("container", containerResource.Name); 47Assert.Equal("nightly", containerAnnotation.Tag); 48Assert.Equal("none", containerAnnotation.Image); 79arg => Assert.Equal("arg1", arg), 80arg => Assert.Equal("http://localhost:1234", arg), 81arg => Assert.Equal("connectionString", arg)); 98Assert.Equal(expectedManifest, manifest.ToString()); 131Assert.Equal(expectedManifest, manifest.ToString()); 158Assert.Equal(expectedManifest, manifest.ToString()); 177Assert.Equal(Path.Combine(basePath, "source"), mountAnnotation.Source); 219Assert.Equal(expectedManifest, manifest.ToString()); 274Assert.Equal("containerwithbindmounts", containerResource.Name); 275Assert.Equal(expectedManifest, manifest.ToString());

WithDockerfileTests.cs (8)

44Assert.Equal("open sesame from env", envSecretMessage); 109Assert.Equal($"{DefaultMessage}\n", message); 141Assert.Equal($"{DefaultMessage}\n", message); 369Assert.Equal($"hello\n", message); 439Assert.Equal($"hello\n", message); 492Assert.Equal("contextPath", ex.ParamName); 506Assert.Equal("contextPath", ex.ParamName); 603Assert.Equal(

DaprTests.cs (6)

62Assert.Equal("3500", config["DAPR_HTTP_PORT"]); 63Assert.Equal("50001", config["DAPR_GRPC_PORT"]); 65Assert.Equal("http://localhost:3500", config["DAPR_HTTP_ENDPOINT"]); 66Assert.Equal("http://localhost:50001", config["DAPR_GRPC_ENDPOINT"]); 161Assert.Equal("http://localhost:3500", config["DAPR_HTTP_ENDPOINT"]); 162Assert.Equal("http://localhost:50001", config["DAPR_GRPC_ENDPOINT"]);

AddElasticsearchTests.cs (35)

27Assert.Equal("elasticsearch", containerResource.Name); 35Assert.Equal("http", primaryEndpoint.Name); 38Assert.Equal("http", primaryEndpoint.Transport); 39Assert.Equal("http", primaryEndpoint.UriScheme); 44Assert.Equal("internal", internalEndpoint.Name); 47Assert.Equal("tcp", internalEndpoint.Transport); 48Assert.Equal("tcp", internalEndpoint.UriScheme); 51Assert.Equal(ElasticsearchContainerImageTags.Tag, containerAnnotation.Tag); 52Assert.Equal(ElasticsearchContainerImageTags.Image, containerAnnotation.Image); 53Assert.Equal(ElasticsearchContainerImageTags.Registry, containerAnnotation.Registry); 60Assert.Equal("discovery.type", env.Key); 61Assert.Equal("single-node", env.Value); 65Assert.Equal("xpack.security.enabled", env.Key); 66Assert.Equal("true", env.Value); 70Assert.Equal("ELASTIC_PASSWORD", env.Key); 89Assert.Equal("elasticsearch", containerResource.Name); 97Assert.Equal("http", primaryEndpoint.Name); 100Assert.Equal("http", primaryEndpoint.Transport); 101Assert.Equal("http", primaryEndpoint.UriScheme); 106Assert.Equal("internal", internalEndpoint.Name); 109Assert.Equal("tcp", internalEndpoint.Transport); 110Assert.Equal("tcp", internalEndpoint.UriScheme); 113Assert.Equal(ElasticsearchContainerImageTags.Tag, containerAnnotation.Tag); 114Assert.Equal(ElasticsearchContainerImageTags.Image, containerAnnotation.Image); 115Assert.Equal(ElasticsearchContainerImageTags.Registry, containerAnnotation.Registry); 122Assert.Equal("discovery.type", env.Key); 123Assert.Equal("single-node", env.Value); 127Assert.Equal("xpack.security.enabled", env.Key); 128Assert.Equal("true", env.Value); 132Assert.Equal("ELASTIC_PASSWORD", env.Key); 133Assert.Equal("pass", env.Value); 152Assert.Equal($"http://elastic:{elasticsearch.Resource.PasswordParameter.Value}@localhost:27020", connectionString); 153Assert.Equal("http://elastic:{elasticsearch-password.value}@{elasticsearch.bindings.http.host}:{elasticsearch.bindings.http.port}", connectionStringResource.ConnectionStringExpression.ValueExpression); 191Assert.Equal(expectedManifest, manifest.ToString()); 237Assert.Equal(expectedManifest, manifest.ToString());

ElasticsearchPublicApiTests.cs (6)

20Assert.Equal(nameof(builder), exception.ParamName); 32Assert.Equal(nameof(name), exception.ParamName); 56Assert.Equal(nameof(builder), exception.ParamName); 70Assert.Equal(nameof(source), exception.ParamName); 84Assert.Equal(nameof(name), exception.ParamName); 95Assert.Equal(nameof(password), exception.ParamName);

AddGarnetTests.cs (20)

25Assert.Equal("myGarnet", containerResource.Name); 30Assert.Equal("tcp", endpoint.Name); 33Assert.Equal("tcp", endpoint.Transport); 34Assert.Equal("tcp", endpoint.UriScheme); 37Assert.Equal(GarnetContainerImageTags.Tag, containerAnnotation.Tag); 38Assert.Equal(GarnetContainerImageTags.Image, containerAnnotation.Image); 39Assert.Equal(GarnetContainerImageTags.Registry, containerAnnotation.Registry); 53Assert.Equal("myGarnet", containerResource.Name); 58Assert.Equal("tcp", endpoint.Name); 61Assert.Equal("tcp", endpoint.Transport); 62Assert.Equal("tcp", endpoint.UriScheme); 65Assert.Equal(GarnetContainerImageTags.Tag, containerAnnotation.Tag); 66Assert.Equal(GarnetContainerImageTags.Image, containerAnnotation.Image); 67Assert.Equal(GarnetContainerImageTags.Registry, containerAnnotation.Registry); 83Assert.Equal("{myGarnet.bindings.tcp.host}:{myGarnet.bindings.tcp.port}", connectionStringResource.ConnectionStringExpression.ValueExpression); 110Assert.Equal(expectedManifest, manifest.ToString()); 132Assert.Equal($"{builder.GetVolumePrefix()}-myGarnet-data", volumeAnnotation.Source); 133Assert.Equal("/data", volumeAnnotation.Target); 157Assert.Equal(Path.Combine(builder.AppHostDirectory, "mygarnetdata"), volumeAnnotation.Source); 158Assert.Equal("/data", volumeAnnotation.Target);

GarnetFunctionalTests.cs (3)

96Assert.Equal("value", value); 178Assert.Equal("value", value); 224Assert.Equal("value", value);

GarnetPublicApiTests.cs (7)

21Assert.Equal(nameof(builder), exception.ParamName); 33Assert.Equal(nameof(name), exception.ParamName); 44Assert.Equal(nameof(name), exception.ParamName); 56Assert.Equal(nameof(builder), exception.ParamName); 69Assert.Equal(nameof(source), exception.ParamName); 80Assert.Equal(nameof(builder), exception.ParamName); 91Assert.Equal(nameof(builder), exception.ParamName);

AddKafkaTests.cs (17)

26Assert.Equal("kafka", containerResource.Name); 34Assert.Equal("tcp", primaryEndpoint.Name); 37Assert.Equal("tcp", primaryEndpoint.Transport); 38Assert.Equal("tcp", primaryEndpoint.UriScheme); 43Assert.Equal("internal", internalEndpoint.Name); 46Assert.Equal("tcp", internalEndpoint.Transport); 47Assert.Equal("tcp", internalEndpoint.UriScheme); 50Assert.Equal(KafkaContainerImageTags.Tag, containerAnnotation.Tag); 51Assert.Equal(KafkaContainerImageTags.Image, containerAnnotation.Image); 52Assert.Equal(KafkaContainerImageTags.Registry, containerAnnotation.Registry); 70Assert.Equal("localhost:27017", connectionString); 71Assert.Equal("{kafka.bindings.tcp.host}:{kafka.bindings.tcp.port}", connectionStringResource.ConnectionStringExpression.ValueExpression); 109Assert.Equal(expectedManifest, manifest.ToString()); 125Assert.Equal("kafka-data", volumeAnnotation.Source); 126Assert.Equal("/var/lib/kafka/data", volumeAnnotation.Target); 143Assert.Equal(Path.Combine(appBuilder.AppHostDirectory, "kafka-data"), volumeAnnotation.Source); 144Assert.Equal("/var/lib/kafka/data", volumeAnnotation.Target);

KafkaFunctionalTests.cs (4)

109Assert.Equal($"test-key", result.Message.Key); 110Assert.Equal($"test-value{i}", result.Message.Value); 244Assert.Equal($"test-key", result.Message.Key); 245Assert.Equal($"test-value{i}", result.Message.Value);

KafkaPublicApiTests.cs (9)

21Assert.Equal(nameof(builder), exception.ParamName); 33Assert.Equal(nameof(name), exception.ParamName); 44Assert.Equal(nameof(builder), exception.ParamName); 56Assert.Equal(nameof(builder), exception.ParamName); 69Assert.Equal(nameof(source), exception.ParamName); 80Assert.Equal(nameof(builder), exception.ParamName); 91Assert.Equal(nameof(builder), exception.ParamName); 102Assert.Equal(nameof(name), exception.ParamName); 113Assert.Equal(nameof(name), exception.ParamName);

KeycloakPublicApiTests.cs (9)

KeycloakResourceBuilderTests.cs (15)

27Assert.Equal(resourceName, containerResource.Name); 32Assert.Equal("http", endpoint.Name); 35Assert.Equal("http", endpoint.Transport); 36Assert.Equal("http", endpoint.UriScheme); 39Assert.Equal(KeycloakContainerImageTags.Tag, containerAnnotation.Tag); 40Assert.Equal(KeycloakContainerImageTags.Image, containerAnnotation.Image); 41Assert.Equal(KeycloakContainerImageTags.Registry, containerAnnotation.Registry); 55Assert.Equal($"{builder.GetVolumePrefix()}-{resourceName}-data", volumeAnnotation.Source); 56Assert.Equal("/opt/keycloak/data", volumeAnnotation.Target); 70Assert.Equal(Path.Combine(builder.AppHostDirectory, "mydata"), volumeAnnotation.Source); 71Assert.Equal("/opt/keycloak/data", volumeAnnotation.Target); 101Assert.Equal(tempDirectory, containerAnnotation.Source); 102Assert.Equal("/opt/keycloak/data/import", containerAnnotation.Target); 114Assert.Equal("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", rmq.Resource.AdminPasswordParameter.Default?.GetType().FullName); 157Assert.Equal(expectedManifest, manifest.ToString());

AddMilvusTests.cs (16)

30Assert.Equal("my-milvus", containerResource.Name); 33Assert.Equal(MilvusContainerImageTags.Tag, containerAnnotation.Tag); 34Assert.Equal(MilvusContainerImageTags.Image, containerAnnotation.Image); 35Assert.Equal(MilvusContainerImageTags.Registry, containerAnnotation.Registry); 42Assert.Equal("grpc", endpoint.Name); 61Assert.Equal("my-milvus", containerResource.Name); 64Assert.Equal(MilvusContainerImageTags.Tag, containerAnnotation.Tag); 65Assert.Equal(MilvusContainerImageTags.Image, containerAnnotation.Image); 66Assert.Equal(MilvusContainerImageTags.Registry, containerAnnotation.Registry); 73Assert.Equal("grpc", endpoint.Name); 92Assert.Equal($"Endpoint=http://localhost:19530;Key=root:pass", connectionString); 168Assert.Equal(expectedManifest, serverManifest.ToString()); 176Assert.Equal(expectedManifest, dbManifest.ToString()); 194Assert.Equal("my-milvus", milvusResource.Name); 203Assert.Equal("http2", grpcEndpoint.Transport); 204Assert.Equal("http", grpcEndpoint.UriScheme);

MilvusPublicApiTests.cs (12)

AddMongoDBTests.cs (40)

MongoDBPublicApiTests.cs (16)

AddMySqlTests.cs (34)

23Assert.Equal("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", mysql.Resource.PasswordParameter.Default?.GetType().FullName); 47Assert.Equal("mysql", containerResource.Name); 50Assert.Equal(MySqlContainerImageTags.Tag, containerAnnotation.Tag); 51Assert.Equal(MySqlContainerImageTags.Image, containerAnnotation.Image); 52Assert.Equal(MySqlContainerImageTags.Registry, containerAnnotation.Registry); 57Assert.Equal("tcp", endpoint.Name); 60Assert.Equal("tcp", endpoint.Transport); 61Assert.Equal("tcp", endpoint.UriScheme); 68Assert.Equal("MYSQL_ROOT_PASSWORD", env.Key); 87Assert.Equal("mysql", containerResource.Name); 90Assert.Equal(MySqlContainerImageTags.Tag, containerAnnotation.Tag); 91Assert.Equal(MySqlContainerImageTags.Image, containerAnnotation.Image); 92Assert.Equal(MySqlContainerImageTags.Registry, containerAnnotation.Registry); 97Assert.Equal("tcp", endpoint.Name); 100Assert.Equal("tcp", endpoint.Transport); 101Assert.Equal("tcp", endpoint.UriScheme); 108Assert.Equal("MYSQL_ROOT_PASSWORD", env.Key); 109Assert.Equal("pass", env.Value); 127Assert.Equal("Server={mysql.bindings.tcp.host};Port={mysql.bindings.tcp.port};User ID=root;Password={mysql-password.value}", connectionStringResource.ConnectionStringExpression.ValueExpression); 150Assert.Equal(mySqlConnectionString + ";Database=db", dbConnectionString); 151Assert.Equal("{mysql.connectionString};Database=db", mySqlDatabaseResource.ConnectionStringExpression.ValueExpression); 182Assert.Equal(expectedManifest, mySqlManifest.ToString()); 190Assert.Equal(expectedManifest, dbManifest.ToString()); 220Assert.Equal(expectedManifest, serverManifest.ToString()); 249Assert.Equal($"{mysql.Resource.Name}:{mysql.Resource.PrimaryEndpoint.TargetPort}", config["PMA_HOST"]); 264Assert.Equal("/etc/phpmyadmin/config.user.inc.php", volume.Target); 334Assert.Equal("customers1", db1.Resource.DatabaseName); 335Assert.Equal("customers2", db2.Resource.DatabaseName); 337Assert.Equal("{mysql1.connectionString};Database=customers1", db1.Resource.ConnectionStringExpression.ValueExpression); 338Assert.Equal("{mysql1.connectionString};Database=customers2", db2.Resource.ConnectionStringExpression.ValueExpression); 352Assert.Equal("imports", db1.Resource.DatabaseName); 353Assert.Equal("imports", db2.Resource.DatabaseName); 355Assert.Equal("{mysql1.connectionString};Database=imports", db1.Resource.ConnectionStringExpression.ValueExpression); 356Assert.Equal("{mysql2.connectionString};Database=imports", db2.Resource.ConnectionStringExpression.ValueExpression);

MySqlFunctionalTests.cs (2)

369Assert.Equal("BatMobile", results.GetString("brand")); 449Assert.Equal("BatMobile", cars[0].Brand);

MySqlPublicApiTests.cs (13)

AddNatsTests.cs (17)

26Assert.Equal("nats", containerResource.Name); 31Assert.Equal("tcp", endpoint.Name); 34Assert.Equal("tcp", endpoint.Transport); 35Assert.Equal("tcp", endpoint.UriScheme); 38Assert.Equal(NatsContainerImageTags.Tag, containerAnnotation.Tag); 39Assert.Equal(NatsContainerImageTags.Image, containerAnnotation.Image); 40Assert.Equal(NatsContainerImageTags.Registry, containerAnnotation.Registry); 56Assert.Equal("nats", containerResource.Name); 59Assert.Equal(path, mountAnnotation.Source); 60Assert.Equal("/var/lib/nats", mountAnnotation.Target); 76Assert.Equal("tcp", endpoint.Name); 79Assert.Equal("tcp", endpoint.Transport); 80Assert.Equal("tcp", endpoint.UriScheme); 83Assert.Equal(NatsContainerImageTags.Tag, containerAnnotation.Tag); 84Assert.Equal(NatsContainerImageTags.Image, containerAnnotation.Image); 85Assert.Equal(NatsContainerImageTags.Registry, containerAnnotation.Registry); 121Assert.Equal(expectedManifest, manifest.ToString());

NatsFunctionalTests.cs (2)

224Assert.Equal($"test-event-{i}", @event.Name); 225Assert.Equal($"test-event-description-{i}", @event.Description);

NatsPublicApiTests.cs (7)

21Assert.Equal(nameof(builder), exception.ParamName); 33Assert.Equal(nameof(name), exception.ParamName); 44Assert.Equal(nameof(builder), exception.ParamName); 55Assert.Equal(nameof(builder), exception.ParamName); 67Assert.Equal(nameof(builder), exception.ParamName); 80Assert.Equal(nameof(source), exception.ParamName); 91Assert.Equal(nameof(name), exception.ParamName);

AddNodeAppTests.cs (2)

44Assert.Equal(expectedManifest, manifest.ToString()); 74Assert.Equal(expectedManifest, manifest.ToString());

NodeFunctionalTests.cs (2)

28Assert.Equal("Hello from node!", response); 40Assert.Equal("Hello from npm!", response);

NodeJsPublicApiTests.cs (10)

AddOracleTests.cs (41)

OracleFunctionalTests.cs (2)

68Assert.Equal("BatMobile", cars[0].Brand); 330Assert.Equal("BatMobile", brands[0].Brand);

AddPostgresTests.cs (76)

PostgrePublicApiTests.cs (17)

PostgresFunctionalTests.cs (2)

319Assert.Equal("BatMobile", results.GetString("brand")); 419Assert.Equal("BatMobile", results.GetString("brand"));

AddPythonAppTests.cs (16)

PythonPublicApiTests.cs (14)

AddQdrantTests.cs (33)

QdrantPublicApiTests.cs (9)

21Assert.Equal(nameof(builder), exception.ParamName); 33Assert.Equal(nameof(name), exception.ParamName); 44Assert.Equal(nameof(builder), exception.ParamName); 56Assert.Equal(nameof(builder), exception.ParamName); 69Assert.Equal(nameof(source), exception.ParamName); 82Assert.Equal(nameof(builder), exception.ParamName); 95Assert.Equal(nameof(qdrantResource), exception.ParamName); 109Assert.Equal(nameof(name), exception.ParamName); 121Assert.Equal(nameof(apiKey), exception.ParamName);

AddRabbitMQTests.cs (18)

21Assert.Equal("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", rmq.Resource.PasswordParameter.Default?.GetType().FullName); 54Assert.Equal("rabbit", containerResource.Name); 59Assert.Equal("tcp", primaryEndpoint.Name); 62Assert.Equal("tcp", primaryEndpoint.Transport); 63Assert.Equal("tcp", primaryEndpoint.UriScheme); 70Assert.Equal("management", mangementEndpoint.Name); 72Assert.Equal("http", mangementEndpoint.Transport); 73Assert.Equal("http", mangementEndpoint.UriScheme); 86Assert.Equal(RabbitMQContainerImageTags.Image, containerAnnotation.Image); 87Assert.Equal(withManagementPlugin ? RabbitMQContainerImageTags.TagManagement : RabbitMQContainerImageTags.Tag, containerAnnotation.Tag); 88Assert.Equal(RabbitMQContainerImageTags.Registry, containerAnnotation.Registry); 110Assert.Equal("amqp://guest:p@ssw0rd1@localhost:27011", connectionString); 111Assert.Equal("amqp://guest:{pass.value}@{rabbit.bindings.tcp.host}:{rabbit.bindings.tcp.port}", connectionStringResource.ConnectionStringExpression.ValueExpression); 142Assert.Equal(expectedTag, containerAnnotation.Tag); 239Assert.Equal(expectedManifest, manifest.ToString()); 272Assert.Equal(expectedManifest, manifest.ToString()); 296Assert.Equal(expectedManifest, manifest.ToString()); 320Assert.Equal(expectedManifest, manifest.ToString());

RabbitMQFunctionalTests.cs (2)

93Assert.Equal(message, Encoding.UTF8.GetString(result.Body.Span)); 207Assert.Equal("Hello World!", Encoding.UTF8.GetString(result.Body.Span));

RabbitMQPublicApiTests.cs (9)

21Assert.Equal(nameof(builder), exception.ParamName); 33Assert.Equal(nameof(name), exception.ParamName); 44Assert.Equal(nameof(builder), exception.ParamName); 56Assert.Equal(nameof(builder), exception.ParamName); 69Assert.Equal(nameof(source), exception.ParamName); 80Assert.Equal(nameof(builder), exception.ParamName); 91Assert.Equal(nameof(builder), exception.ParamName); 104Assert.Equal(nameof(name), exception.ParamName); 117Assert.Equal(nameof(password), exception.ParamName);

AddRedisTests.cs (22)

34Assert.Equal("myRedis", containerResource.Name); 39Assert.Equal("tcp", endpoint.Name); 42Assert.Equal("tcp", endpoint.Transport); 43Assert.Equal("tcp", endpoint.UriScheme); 62Assert.Equal("myRedis", containerResource.Name); 67Assert.Equal("tcp", endpoint.Name); 70Assert.Equal("tcp", endpoint.Transport); 71Assert.Equal("tcp", endpoint.UriScheme); 92Assert.Equal("{myRedis.bindings.tcp.host}:{myRedis.bindings.tcp.port}", connectionStringResource.ConnectionStringExpression.ValueExpression); 119Assert.Equal(expectedManifest, manifest.ToString()); 155Assert.Equal("example.mycompany.com", containerAnnotation.Registry); 156Assert.Equal("customrediscommander", containerAnnotation.Image); 157Assert.Equal("someothertag", containerAnnotation.Tag); 173Assert.Equal("example.mycompany.com", containerAnnotation.Registry); 174Assert.Equal("customrediscommander", containerAnnotation.Image); 175Assert.Equal("someothertag", containerAnnotation.Tag); 225Assert.Equal($"myredis1:{redis.Resource.Name}:6379:0", config["REDIS_HOSTS"]); 249Assert.Equal($"myredis1:{redis1.Resource.Name}:6379:0,myredis2:myredis2:6379:0", config["REDIS_HOSTS"]); 271Assert.Equal($"{builder.GetVolumePrefix()}-myRedis-data", volumeAnnotation.Source); 272Assert.Equal("/data", volumeAnnotation.Target); 296Assert.Equal(Path.Combine(builder.AppHostDirectory, "mydata"), volumeAnnotation.Source); 297Assert.Equal("/data", volumeAnnotation.Target);

RedisFunctionalTests.cs (9)

121Assert.Equal("value", value); 155Assert.Equal(redis1.Resource.Name, db.Name); 156Assert.Equal(redis1.Resource.Name, db.Host); 158Assert.Equal("STANDALONE", db.ConnectionType); 163Assert.Equal(redis2.Resource.Name, db.Name); 164Assert.Equal(redis2.Resource.Name, db.Host); 166Assert.Equal("STANDALONE", db.ConnectionType); 305Assert.Equal("value", value); 390Assert.Equal("value", value);

RedisPublicApiTests.cs (12)

NuGetUtils.Tests.cs (1)

34Assert.Equal(expectedRID, result);

AddSqlServerTests.cs (26)

22Assert.Equal("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", sql.Resource.PasswordParameter.Default?.GetType().FullName); 47Assert.Equal("sqlserver", containerResource.Name); 52Assert.Equal("tcp", endpoint.Name); 55Assert.Equal("tcp", endpoint.Transport); 56Assert.Equal("tcp", endpoint.UriScheme); 59Assert.Equal(SqlServerContainerImageTags.Tag, containerAnnotation.Tag); 60Assert.Equal(SqlServerContainerImageTags.Image, containerAnnotation.Image); 61Assert.Equal(SqlServerContainerImageTags.Registry, containerAnnotation.Registry); 68Assert.Equal("ACCEPT_EULA", env.Key); 69Assert.Equal("Y", env.Value); 73Assert.Equal("MSSQL_SA_PASSWORD", env.Key); 97Assert.Equal("Server=127.0.0.1,1433;User ID=sa;Password=p@ssw0rd1;TrustServerCertificate=true", connectionString); 98Assert.Equal("Server={sqlserver.bindings.tcp.host},{sqlserver.bindings.tcp.port};User ID=sa;Password={pass.value};TrustServerCertificate=true", connectionStringResource.ConnectionStringExpression.ValueExpression); 121Assert.Equal("Server=127.0.0.1,1433;User ID=sa;Password=p@ssw0rd1;TrustServerCertificate=true;Database=mydb", connectionString); 122Assert.Equal("{sqlserver.connectionString};Database=mydb", connectionStringResource.ConnectionStringExpression.ValueExpression); 154Assert.Equal(expectedManifest, serverManifest.ToString()); 162Assert.Equal(expectedManifest, dbManifest.ToString()); 194Assert.Equal(expectedManifest, serverManifest.ToString()); 230Assert.Equal("customers1", db1.Resource.DatabaseName); 231Assert.Equal("customers2", db2.Resource.DatabaseName); 233Assert.Equal("{sqlserver1.connectionString};Database=customers1", db1.Resource.ConnectionStringExpression.ValueExpression); 234Assert.Equal("{sqlserver1.connectionString};Database=customers2", db2.Resource.ConnectionStringExpression.ValueExpression); 248Assert.Equal("imports", db1.Resource.DatabaseName); 249Assert.Equal("imports", db2.Resource.DatabaseName); 251Assert.Equal("{sqlserver1.connectionString};Database=imports", db1.Resource.ConnectionStringExpression.ValueExpression); 252Assert.Equal("{sqlserver2.connectionString};Database=imports", db2.Resource.ConnectionStringExpression.ValueExpression);

SqlServerFunctionalTests.cs (2)

115Assert.Equal("BatMobile", cars[0].Brand); 292Assert.Equal("BatMobile", results.GetString(0));

SqlServerPublicApiTests.cs (14)

PublicApiTests.cs (3)

15Assert.Equal("entryPoint", ane.ParamName); 28Assert.Equal("args", ane.ParamName); 41Assert.Equal("configureBuilder", ane.ParamName);

ResourceLoggerForwarderServiceTests.cs (12)

119log => { Assert.Equal(LogLevel.Information, log.Level); Assert.Equal("1: 2000-12-29T20:59:59.0000000Z Test trace message", log.Message); Assert.Equal("TestApp.AppHost.Resources.myresource", log.Category); }, 120log => { Assert.Equal(LogLevel.Information, log.Level); Assert.Equal("2: 2000-12-29T20:59:59.0000000Z Test debug message", log.Message); Assert.Equal("TestApp.AppHost.Resources.myresource", log.Category); }, 121log => { Assert.Equal(LogLevel.Information, log.Level); Assert.Equal("3: 2000-12-29T20:59:59.0000000Z Test information message", log.Message); Assert.Equal("TestApp.AppHost.Resources.myresource", log.Category); }, 122log => { Assert.Equal(LogLevel.Information, log.Level); Assert.Equal("4: 2000-12-29T20:59:59.0000000Z Test warning message", log.Message); Assert.Equal("TestApp.AppHost.Resources.myresource", log.Category); }, 123log => { Assert.Equal(LogLevel.Error, log.Level); Assert.Equal("5: 2000-12-29T20:59:59.0000000Z Test error message", log.Message); Assert.Equal("TestApp.AppHost.Resources.myresource", log.Category); }, 124log => { Assert.Equal(LogLevel.Error, log.Level); Assert.Equal("6: 2000-12-29T20:59:59.0000000Z Test critical message", log.Message); Assert.Equal("TestApp.AppHost.Resources.myresource", log.Category); });

TestingBuilderTests.cs (2)

91Assert.Equal(nonExistantRegistry, containerImageAnnotation!.Registry); 198Assert.Equal("https", profileName);

TestingFactoryTests.cs (1)

72Assert.Equal("https", profileName);

AddParameterTests.cs (18)

38Assert.Equal("parameter.secret", prop.Name); 43Assert.Equal(CustomResourceKnownProperties.Source, prop.Name); 48Assert.Equal("Value", prop.Name); 72Assert.Equal("Configuration missing", state.State.Text); 73Assert.Equal(KnownResourceStateStyles.Error, state.State.Style); 77Assert.Equal("parameter.secret", prop.Name); 82Assert.Equal(CustomResourceKnownProperties.Source, prop.Name); 87Assert.Equal("Value", prop.Name); 112Assert.Equal("ValueFromConfiguration", parameterResource.Value); 147Assert.Equal($"DefaultValue", parameterResource.Value); 162Assert.Equal(expectedManifest, paramManifest.ToString()); 197Assert.Equal($"DefaultValue", parameterResource.Value); 215Assert.Equal(expectedManifest, paramManifest.ToString()); 225Assert.Equal($"A parameter cannot be both secret and published as a default value. (Parameter 'secret')", ex1.Message); 227Assert.Equal($"A parameter cannot be both secret and published as a default value. (Parameter 'secret')", ex2.Message); 275Assert.Equal(expectedManifest, paramManifest.ToString()); 310Assert.Equal($"MyAccessToken", parameterResource.Value); 325Assert.Equal(expectedManifest, paramManifest.ToString());

Dashboard\DashboardLifecycleHookTests.cs (2)

69Assert.Equal(expectedCategory, logContext.LoggerName); 70Assert.Equal(expectedMessage, logContext.Message);

Dashboard\DashboardResourceTests.cs (25)

47Assert.Equal("aspire-dashboard", dashboard.Name); 48Assert.Equal(dashboardPath, dashboard.Command); 66r => Assert.Equal("aspire-dashboard", r.Name), 67r => Assert.Equal("my-container", r.Name) 103Assert.Equal("ASPNETCORE_ENVIRONMENT", e.Key); 104Assert.Equal("Production", e.Value); 108Assert.Equal("ASPNETCORE_URLS", e.Key); 109Assert.Equal("http://localhost", e.Value); 113Assert.Equal("DOTNET_RESOURCE_SERVICE_ENDPOINT_URL", e.Key); 114Assert.Equal("http://localhost:5000", e.Value); 118Assert.Equal("DOTNET_DASHBOARD_OTLP_ENDPOINT_URL", e.Key); 119Assert.Equal("http://localhost", e.Value); 123Assert.Equal("DASHBOARD__FRONTEND__AUTHMODE", e.Key); 124Assert.Equal("Unsecured", e.Value); 128Assert.Equal("DASHBOARD__RESOURCESERVICECLIENT__AUTHMODE", e.Key); 129Assert.Equal("Unsecured", e.Value); 133Assert.Equal("DASHBOARD__OTLP__AUTHMODE", e.Key); 134Assert.Equal("Unsecured", e.Value); 138Assert.Equal("LOGGING__CONSOLE__FORMATTERNAME", e.Key); 139Assert.Equal("json", e.Value); 167Assert.Equal("aspire-dashboard", dashboard.Name); 168Assert.Equal("dotnet", dashboard.Command); 427Assert.Equal("aspire-dashboard", dashboard.Name); 456Assert.Equal("Test dashboard message", log.Message); 482Assert.Equal("aspire-dashboard", dashboard.Name);

Dashboard\TransportOptionsValidatorTests.cs (10)

26Assert.Equal( 99Assert.Equal( 118Assert.Equal( 138Assert.Equal( 160Assert.Equal( 182Assert.Equal( 205Assert.Equal( 230Assert.Equal( 254Assert.Equal( 276Assert.Equal(

Dcp\ApplicationExecutorTests.cs (7)

432Assert.Equal("2024-08-19T06:10:33.4732759Z Hello world", logLine.Content); 443Assert.Equal("2024-08-19T06:10:32.6610000Z Next", logLine.Content); 449l => Assert.Equal("Next", l.Content), 450l => Assert.Equal("Hello world", l.Content)); 940a => Assert.Equal(CommandsConfigurationExtensions.StartType, a.Type), 941a => Assert.Equal(CommandsConfigurationExtensions.StopType, a.Type), 942a => Assert.Equal(CommandsConfigurationExtensions.RestartType, a.Type));

Dcp\DcpCliArgsTests.cs (3)

57Assert.Equal("not-a-valid-container-runtime", dcpOptions.ContainerRuntime); 59Assert.Equal("/not/a/valid/path", dcpOptions.CliPath); 60Assert.Equal("/not/a/valid/path", dcpOptions.DashboardPath);

DistributedApplicationBuilderTests.cs (9)

70Assert.Equal("manifest", publishOptions.Value.Publisher); 71Assert.Equal("/tmp/", publishOptions.Value.OutputPath); 83Assert.Equal("docker", publishOptions.Value.Publisher); 84Assert.Equal("/path/", publishOptions.Value.OutputPath); 95Assert.Equal(appHostDirectory, config["AppHost:Directory"]); 106Assert.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); 117Assert.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); 129Assert.Equal("Multiple resources with the name 'Test'. Resource names are case-insensitive.", ex.Message); 141Assert.Equal("Multiple resources with the name 'Test'. Resource names are case-insensitive.", ex.Message);

DistributedApplicationTests.cs (16)

61Assert.Equal(exceptionMessage, ex.Message); 102Assert.Equal(exceptionMessage, ex.Message); 125Assert.Equal(exceptionMessage, ex.InnerExceptions.First().Message); 385Assert.Equal("6379", GetEnv(redisContainer.Spec.Env, "REDIS_PORT")); 386Assert.Equal("6379", GetEnv(redisContainer.Status!.EffectiveEnv, "REDIS_PORT")); 388Assert.Equal($"{{{{- portForServing \"servicea-http0-{suffix}\" -}}}}", GetEnv(serviceA.Spec.Env, "PORT0")); 393Assert.Equal($"{{{{- portForServing \"nodeapp-{suffix}\" -}}}}", GetEnv(nodeApp.Spec.Env, "PORT")); 434Assert.Equal("BrowserToken", GetEnv(aspireDashboard.Spec.Env, "DASHBOARD__FRONTEND__AUTHMODE")); 435Assert.Equal("ThisIsATestToken", GetEnv(aspireDashboard.Spec.Env, "DASHBOARD__FRONTEND__BROWSERTOKEN")); 437Assert.Equal("ApiKey", GetEnv(aspireDashboard.Spec.Env, "DASHBOARD__OTLP__AUTHMODE")); 476Assert.Equal("Unsecured", GetEnv(aspireDashboard.Spec.Env, "DASHBOARD__FRONTEND__AUTHMODE")); 477Assert.Equal("Unsecured", GetEnv(aspireDashboard.Spec.Env, "DASHBOARD__OTLP__AUTHMODE")); 699Assert.Equal($"Resource 'servicea-{suffix}' uses multiple replicas and a proxy-less endpoint 'http'. These features do not work together.", ex.Message); 718Assert.Equal($"Service 'servicea-{suffix}' needs to specify a port for endpoint 'http' since it isn't using a proxy.", ex.Message); 808Assert.Equal(urls, value); 887Assert.Equal($"The endpoint 'tcp' for container resource 'dummyRedis-{suffix}' must specify the TargetPort value", ex.Message);

ExecutableResourceTests.cs (8)

41arg => Assert.Equal("app.py", arg), 42arg => Assert.Equal("http://localhost:1234", arg), 43arg => Assert.Equal("arg1", arg), 44arg => Assert.Equal("connectionString", arg), 45arg => Assert.Equal("arg2", arg), 46arg => Assert.Equal("http://localhost:1234", arg), 47arg => Assert.Equal("anotherConnectionString", arg) 70Assert.Equal(expectedManifest, manifest.ToString());

HealthCheckTests.cs (1)

34Assert.Equal("A health check registration is missing. Check logs for more details.", ex.Message);

KestrelConfigTests.cs (29)

ManifestGenerationTests.cs (4)

106Assert.Equal(expectedManifest, redisManifest.ToString()); 197verify.Add(arg => Assert.Equal(addExecutableArg, arg.GetString())); 202verify.Add(arg => Assert.Equal(withArgsArg, arg.GetString())); 556Assert.Equal(expectedManifest, manifest.ToString());

ModelNameTests.cs (9)

ProjectResourceTests.cs (58)

ReferenceExpressionTests.cs (6)

21Assert.Equal(expectedFormat, refExpression.Format); 25Assert.Equal(expectedExpression, expr); 39Assert.Equal(expected, expr); 50Assert.Equal(expected, expr); 62Assert.Equal(expected, expr); 70Assert.Equal("Test", expr);

ResourceExtensionsTests.cs (19)

76Assert.Equal("grafana/grafana@sha256:1adbcc2df3866ff5ec1d836e9d2220c904c7f98901b918d3cc5e1118ab1af991", imageName); 86Assert.Equal("grafana/grafana:10.3.1", imageName); 106Assert.Equal("discovery.type", env.Key); 107Assert.Equal("single-node", env.Value); 111Assert.Equal("xpack.security.enabled", env.Key); 112Assert.Equal("true", env.Value); 116Assert.Equal("ELASTIC_PASSWORD", env.Key); 117Assert.Equal("p@ssw0rd1", env.Value); 139Assert.Equal("discovery.type", env.Key); 140Assert.Equal("single-node", env.Value); 144Assert.Equal("xpack.security.enabled", env.Key); 145Assert.Equal("true", env.Value); 149Assert.Equal("ELASTIC_PASSWORD", env.Key); 150Assert.Equal("p@ssw0rd1", env.Value); 172Assert.Equal("discovery.type", env.Key); 173Assert.Equal("single-node", env.Value); 177Assert.Equal("xpack.security.enabled", env.Key); 178Assert.Equal("true", env.Value); 182Assert.Equal("{ElasticPassword.value}", env.Value);

ResourceLoggerServiceTests.cs (21)

ResourceNotificationTests.cs (12)

34Assert.Equal("MyResource", state.ResourceType); 38Assert.Equal("A", c.Name); 80Assert.Equal("myResource", c.ResourceId); 81Assert.Equal("CustomResource", c.Snapshot.ResourceType); 87Assert.Equal("myResource", c.ResourceId); 88Assert.Equal("CustomResource", c.Snapshot.ResourceType); 133Assert.Equal("myResource1", c.ResourceId); 134Assert.Equal("CustomResource", c.Snapshot.ResourceType); 140Assert.Equal("myResource2", c.ResourceId); 141Assert.Equal("CustomResource", c.Snapshot.ResourceType); 147Assert.Equal("replica1", c.ResourceId); 148Assert.Equal("CustomResource", c.Snapshot.ResourceType);

UserSecretsParameterDefaultTests.cs (1)

31Assert.Equal(initialValue, userSecrets["Parameters:param1"]);

WaitForTests.cs (4)

25Assert.Equal("The 'test' resource cannot wait for itself.", waitForEx.Message); 32Assert.Equal("The 'test' resource cannot wait for itself.", waitForCompletionEx.Message); 47Assert.Equal("The 'child' resource cannot wait for its parent 'parent'.", waitForEx.Message); 54Assert.Equal("The 'child' resource cannot wait for its parent 'parent'.", waitForCompletionEx.Message);

WithEndpointTests.cs (17)

WithEnvironmentTests.cs (19)

34Assert.Equal("true", config["SP_AVAILABLE"]); 54Assert.Equal("https://localhost:2000", config["myName"]); 67Assert.Equal("value", config["myName"]); 83Assert.Equal("value", config["myName"]); 99Assert.Equal("value2", config["myName"]); 116Assert.Equal("MY_PARAMETER_VALUE", config["MY_PARAMETER"]); 132Assert.Equal("{parameter.value}", config["MY_PARAMETER"]); 151Assert.Equal("Parameter resource could not be used because configuration key 'Parameters:parameter' is missing and the Parameter has no default value.", exception.Message); 171Assert.Equal("value2", config["myName"]); 200Assert.Equal($"http://localhost:90/foo", config["URL"]); 201Assert.Equal("90", config["PORT"]); 202Assert.Equal("10005", config["TARGET_PORT"]); 203Assert.Equal("connectionString;name=1", config["HOST"]); 206Assert.Equal("{container1.bindings.primary.url}/foo", manifestConfig["URL"]); 207Assert.Equal("{container1.bindings.primary.port}", manifestConfig["PORT"]); 208Assert.Equal("{container1.bindings.primary.targetPort}", manifestConfig["TARGET_PORT"]); 209Assert.Equal("{test.connectionString};name=1", manifestConfig["HOST"]); 232Assert.Equal("TARGET_PORT", pair.Key); 233Assert.Equal("""{{- portForServing "container1_primary" -}}""", pair.Value);

WithReferenceTests.cs (13)

AddValkeyTests.cs (20)

25Assert.Equal("myValkey", containerResource.Name); 30Assert.Equal("tcp", endpoint.Name); 33Assert.Equal("tcp", endpoint.Transport); 34Assert.Equal("tcp", endpoint.UriScheme); 37Assert.Equal(ValkeyContainerImageTags.Tag, containerAnnotation.Tag); 38Assert.Equal(ValkeyContainerImageTags.Image, containerAnnotation.Image); 39Assert.Equal(ValkeyContainerImageTags.Registry, containerAnnotation.Registry); 53Assert.Equal("myValkey", containerResource.Name); 58Assert.Equal("tcp", endpoint.Name); 61Assert.Equal("tcp", endpoint.Transport); 62Assert.Equal("tcp", endpoint.UriScheme); 65Assert.Equal(ValkeyContainerImageTags.Tag, containerAnnotation.Tag); 66Assert.Equal(ValkeyContainerImageTags.Image, containerAnnotation.Image); 67Assert.Equal(ValkeyContainerImageTags.Registry, containerAnnotation.Registry); 83Assert.Equal("{myValkey.bindings.tcp.host}:{myValkey.bindings.tcp.port}", connectionStringResource.ConnectionStringExpression.ValueExpression); 110Assert.Equal(expectedManifest, manifest.ToString()); 132Assert.Equal($"{builder.GetVolumePrefix()}-myValkey-data", volumeAnnotation.Source); 133Assert.Equal("/data", volumeAnnotation.Target); 157Assert.Equal(Path.Combine(builder.AppHostDirectory, "myValkeydata"), volumeAnnotation.Source); 158Assert.Equal("/data", volumeAnnotation.Target);

ValkeyFunctionalTests.cs (2)

55Assert.Equal("value", value); 165Assert.Equal("value", value);

AspireKeycloakExtensionTests.cs (8)

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); 73Assert.Equal(options.Authority, $"https+http://{DefaultKeyName}/realms/{realm}"); 95Assert.Equal(options.Authority, $"https+http://{DefaultKeyName}/realms/{realm}"); 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); 155Assert.Equal(options.Authority, $"https+http://{DefaultKeyName}/realms/{realm}"); 178Assert.Equal(options.Authority, $"https+http://{DefaultKeyName}/realms/{realm}");

ConformanceTests.cs (3)

100Assert.Equal("https://example1.documents.azure.com/", client1.Endpoint.ToString()); 101Assert.Equal("https://example2.documents.azure.com/", client2.Endpoint.ToString()); 102Assert.Equal("https://example3.documents.azure.com/", client3.Endpoint.ToString());

AspireSqlServerSqlClientExtensionsTests.cs (3)

40Assert.Equal(ConnectionString, connection.ConnectionString); 68Assert.Equal(ConnectionString, connection.ConnectionString); 100Assert.Equal(ConnectionString, dataSource.ConnectionString);

AspireAzureEfCoreCosmosDBExtensionsTests.cs (4)

47Assert.Equal("westus", extension.Region); 148Assert.Equal("test", actualConnectionString); 151Assert.Equal("test2", actualConnectionString); 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);

EnrichCosmosDbTests.cs (3)

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

AspireSqlServerEFCoreSqlClientExtensionsTests.cs (8)

33Assert.Equal(ConnectionString, context.Database.GetDbConnection().ConnectionString); 50Assert.Equal(ConnectionString, actualConnectionString); 70Assert.Equal(ConnectionString, actualConnectionString); 106Assert.Equal(ConnectionString, actualConnectionString); 150Assert.Equal(ConnectionString, actualConnectionString); 249Assert.Equal(ConnectionString, actualConnectionString); 252Assert.Equal(connectionString2, actualConnectionString); 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)

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

AspireMilvusExtensionTests.cs (2)

53Assert.Equal(NormalizedConnectionString, $"Endpoint=http://{dataSource.Address}/;Key={DefaultApiKey}"); 107Assert.Equal(ConnectionString, $"Endpoint=http://{connection.Address}/;Key={DefaultApiKey}");

MilvusClientPublicApiTests.cs (6)

21Assert.Equal(nameof(builder), exception.ParamName); 34Assert.Equal(nameof(connectionName), exception.ParamName); 47Assert.Equal(nameof(connectionName), exception.ParamName); 60Assert.Equal(nameof(builder), exception.ParamName); 73Assert.Equal(nameof(name), exception.ParamName); 86Assert.Equal(nameof(name), exception.ParamName);

AspireMongoDBDriverExtensionsTests.cs (13)

44Assert.Equal(uri.Server.Host, mongoClient.Settings.Server.Host); 50Assert.Equal(uri.AuthenticationSource, mongoClient.Settings.Credential.Source); 51Assert.Equal(uri.AuthenticationMechanism, mongoClient.Settings.Credential.Mechanism); 52Assert.Equal(uri.Username, mongoClient.Settings.Credential.Username); 63Assert.Equal(uri.DatabaseName, mongoDatabase.DatabaseNamespace.DatabaseName); 90Assert.Equal(uri.Server.Host, mongoClient.Settings.Server.Host); 96Assert.Equal(uri.AuthenticationSource, mongoClient.Settings.Credential.Source); 97Assert.Equal(uri.AuthenticationMechanism, mongoClient.Settings.Credential.Mechanism); 98Assert.Equal(uri.Username, mongoClient.Settings.Credential.Username); 110Assert.Equal(uri.DatabaseName, mongoDatabase.DatabaseNamespace.DatabaseName); 227Assert.Equal("mydatabase1", connection1.DatabaseNamespace.DatabaseName); 228Assert.Equal("mydatabase2", connection2.DatabaseNamespace.DatabaseName); 229Assert.Equal("mydatabase3", connection3.DatabaseNamespace.DatabaseName);

MongoDBDriverPublicApiTests.cs (6)

20Assert.Equal(nameof(builder), exception.ParamName); 32Assert.Equal(nameof(connectionName), exception.ParamName); 44Assert.Equal(nameof(connectionName), exception.ParamName); 56Assert.Equal(nameof(builder), exception.ParamName); 68Assert.Equal(nameof(name), exception.ParamName); 80Assert.Equal(nameof(name), exception.ParamName);

AspireMySqlConnectorExtensionsTests.cs (3)

48Assert.Equal(NormalizedConnectionString, dataSource.ConnectionString); 76Assert.Equal(NormalizedConnectionString, dataSource.ConnectionString); 108Assert.Equal(NormalizedConnectionString, dataSource.ConnectionString);

ConformanceTests.cs (2)

118Assert.Equal(dbConnection.ConnectionString, mySqlConnection.ConnectionString); 119Assert.Equal(mySqlDataSource.ConnectionString, mySqlConnection.ConnectionString);

AspireNatsClientExtensionsTests.cs (4)

55Assert.Equal(_connectionString, connection.Opts.Url); 84Assert.Equal(_connectionString, connection.Opts.Url); 116Assert.Equal(_connectionString, connection.Opts.Url); 201Assert.Equal("test publish", activity.OperationName);

NatsClientPublicApiTests.cs (7)

21Assert.Equal(nameof(builder), exception.ParamName); 34Assert.Equal(nameof(connectionName), exception.ParamName); 47Assert.Equal(nameof(connectionName), exception.ParamName); 60Assert.Equal(nameof(builder), exception.ParamName); 73Assert.Equal(nameof(name), exception.ParamName); 86Assert.Equal(nameof(name), exception.ParamName); 97Assert.Equal(nameof(builder), exception.ParamName);

AspireEFPostgreSqlExtensionsTests.cs (8)

41Assert.Equal(ConnectionString, context.Database.GetDbConnection().ConnectionString); 60Assert.Equal(ConnectionString, actualConnectionString); 80Assert.Equal(ConnectionString, actualConnectionString); 116Assert.Equal(ConnectionString, actualConnectionString); 158Assert.Equal(ConnectionString, actualConnectionString); 256Assert.Equal(ConnectionString, actualConnectionString); 259Assert.Equal(connectionString2, actualConnectionString); 282Assert.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)

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

AspirePostgreSqlNpgsqlExtensionsTests.cs (3)

40Assert.Equal(ConnectionString, dataSource.ConnectionString); 68Assert.Equal(ConnectionString, dataSource.ConnectionString); 100Assert.Equal(ConnectionString, dataSource.ConnectionString);

ConformanceTests.cs (2)

120Assert.Equal(dbConnection.ConnectionString, npgsqlConnection.ConnectionString); 121Assert.Equal(npgsqlDataSource.ConnectionString, npgsqlConnection.ConnectionString);

AspireOpenAIExtensionsTests.cs (3)

106Assert.Equal("An OpenAIClient could not be configured. Ensure valid connection information was provided in " + 177Assert.Equal("myproject", options.ProjectId); 178Assert.Equal("myapplication", options.ApplicationId);

AspireOracleEFCoreDatabaseExtensionsTests.cs (8)

34Assert.Equal(ConnectionString, context.Database.GetDbConnection().ConnectionString); 51Assert.Equal(ConnectionString, actualConnectionString); 71Assert.Equal(ConnectionString, actualConnectionString); 107Assert.Equal(ConnectionString, actualConnectionString); 151Assert.Equal(ConnectionString, actualConnectionString); 250Assert.Equal(ConnectionString, actualConnectionString); 253Assert.Equal(connectionString2, actualConnectionString); 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)

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

AspireEFMySqlExtensionsTests.cs (6)

48Assert.Equal(expectedConnectionString, actualConnectionString); 67Assert.Equal(expectedConnectionString, actualConnectionString); 89Assert.Equal(expectedConnectionString, actualConnectionString); 126Assert.Equal(expectedConnectionString, actualConnectionString); 169Assert.Equal(expectedConnectionString, actualConnectionString); 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);

AspireRabbitMQExtensionsTests.cs (2)

159Assert.Equal("aspire-app", connectionFactory.ClientProvidedName); 198Assert.Equal(uri.Host, endpoint.HostName);

AspireRabbitMQLoggingTests.cs (5)

135Assert.Equal("message", errorEvent[0].Key); 138Assert.Equal("exception.type", errorEvent[1].Key); 141Assert.Equal("exception.message", errorEvent[2].Key); 144Assert.Equal("exception.stacktrace", errorEvent[3].Key); 147Assert.Equal("exception.innerexception", errorEvent[4].Key);

SeqEndpointCanBeConfigured.cs (2)

64Assert.Equal("speed=fast,quality=good,X-Seq-ApiKey=TestKey123!", settings.Logs.Headers); 65Assert.Equal("quality=good,speed=fast,X-Seq-ApiKey=TestKey123!", settings.Traces.Headers);

DistributedCacheConformanceTests.cs (3)

72Assert.Equal("CLIENT", activity.OperationName); 77Assert.Equal("CLIENT", activity.OperationName); 82Assert.Equal("HMGET", activity.OperationName);

OutputCacheConformanceTests.cs (3)

72Assert.Equal("CLIENT", activity.OperationName); 77Assert.Equal("CLIENT", activity.OperationName); 82Assert.Equal("GET", activity.OperationName);

AspireRedisExtensionsTests.cs (6)

294Assert.Equal("GET", activity.OperationName); 328Assert.Equal(container2.GetConnectionString(), connection2.Configuration); 329Assert.Equal(container3.GetConnectionString(), connection3.Configuration); 366Assert.Equal(container1.GetConnectionString(), connection1.Configuration); 367Assert.Equal(container2.GetConnectionString(), connection2.Configuration); 368Assert.Equal(container3.GetConnectionString(), connection3.Configuration);

ClaimsTransformTests.cs (1)

41Assert.Equal("http://localhost/account/login?ReturnUrl=%2FHome%2FMyClaims", response.Headers.Location.ToString());

CookiesTests.cs (1)

40Assert.Equal("http://localhost/account/login?ReturnUrl=%2FHome%2FMyClaims", response.RequestMessage.RequestUri.ToString());

CustomAuthorizationFailureResponseTests.cs (2)

28Assert.Equal(CustomAuthorizationFailureResponse.Startup.CustomForbiddenMessage, content); 38Assert.Equal(CustomAuthorizationFailureResponse.Startup.CustomForbiddenMessage, content);

CustomPolicyProviderTests.cs (2)

44Assert.Equal("http://localhost/account/signin?ReturnUrl=%2FHome%2FMinimumAge10", response.RequestMessage.RequestUri.ToString()); 118Assert.Equal("http://localhost/account/signin?ReturnUrl=%2FHome%2FMinimumAge50", response.RequestMessage.RequestUri.ToString());

IdentityExternalClaimsTests.cs (1)

41Assert.Equal("http://localhost/Account/Login?ReturnUrl=%2FMyClaims", response.Headers.Location.ToString());

PathSchemeSelectionTests.cs (1)

53Assert.Equal("http://localhost/account/login?ReturnUrl=%2FHome%2FMyClaims", response.RequestMessage.RequestUri.ToString());

StaticFilesAuthTests.cs (1)

39Assert.Equal("http://localhost/Account/Login?ReturnUrl=%2F" + scenario, response.Headers.Location.ToString());

TestAssert.cs (1)

76Assert.Equal("text/html", response.Content.Headers.ContentType.MediaType);

CustomBindingTests.4.0.0.cs (1)

35Assert.Equal(testString, result);

CustomBindingTests.4.1.0.cs (2)

43Assert.Equal(testString, result); 81Assert.Equal(testString, result);

BasicHttpBindingTests.4.0.0.cs (1)

270Assert.Equal(userAgent, userAgentHeader);

NetHttpBindingTests.4.0.0.cs (1)

36Assert.Equal(testString, result);

NetHttpsBindingTests.4.1.0.cs (1)

105Assert.Equal(testString, result);

NetHttpBindingTests.cs (1)

43Assert.Equal(testString, result);

NetTcpBindingTests.cs (3)

38Assert.Equal(testString, result); 113Assert.Equal(testString, result); 114Assert.Equal(testString, callbackService.LastReceivedEcho);

WSHttpBindingTests.cs (1)

43Assert.Equal(testString, result);

NetTcpBindingTests.4.0.0.cs (8)

34Assert.Equal(testString, result); 65Assert.Equal(testString, result); 70Assert.Equal(testString, result); 72Assert.Equal(testString, result); 103Assert.Equal(testString, result); 111Assert.Equal(testString, result); 148Assert.Equal(testString, result); 186Assert.Equal(testString, result);

NetTcpBindingTests.4.1.0.cs (2)

36Assert.Equal(testString, result); 73Assert.Equal(testString, result);

UDSBindingTests.cs (4)

49Assert.Equal(testString, result); 84Assert.Equal(testString, result); 131Assert.Equal(testString, result); 164Assert.Equal(testString, result);

WSFederationHttpBindingTests.cs (3)

65Assert.Equal(testString, result); 116Assert.Equal(testString, result); 167Assert.Equal(testString, result);

DuplexChannelShapeTests.4.0.0.cs (4)

58Assert.Equal(requestMessage.Headers.MessageId.ToString(), replyMessage.Headers.RelatesTo.ToString()); 64Assert.Equal(expectedResponse, actualResponse); 115Assert.Equal(requestMessage.Headers.MessageId.ToString(), replyMessage.Headers.RelatesTo.ToString()); 121Assert.Equal(expectedResponse, actualResponse);

DuplexChannelShapeTests.4.1.0.cs (3)

63Assert.Equal(expectedResponse, actualResponse); 115Assert.Equal(requestMessage.Headers.MessageId.ToString(), replyMessage.Headers.RelatesTo.ToString()); 121Assert.Equal(expectedResponse, actualResponse);

DuplexChannelWithSynchronizationContext.cs (1)

242Assert.Equal(testString, result);

RequestReplyChannelShapeTests.4.0.0.cs (6)

59Assert.Equal(expectedResponse, actualResponse); 109Assert.Equal(action + "Response", replyMessageAction); 114Assert.Equal(expectedResponse, actualResponse); 167Assert.Equal(expectedResponse, actualResponse); 219Assert.Equal(action + "Response", replyMessageAction); 224Assert.Equal(expectedResponse, actualResponse);

RequestReplyChannelShapeTests.4.1.0.cs (1)

56Assert.Equal(expectedResponse, actualResponse);

ClientBaseTests.4.0.0.cs (10)

40Assert.Equal("POST", property.Method); 41Assert.Equal("My%20address", property.QueryString); 43Assert.Equal("my value", property.Headers["customer"]); 87Assert.Equal("POST", property.Method); 88Assert.Equal("My%20address", property.QueryString); 90Assert.Equal("my value", property.Headers["customer"]); 133Assert.Equal("Hello", result); 708Assert.Equal("Hello", result); 743Assert.Equal("Hello", result); 790Assert.Equal(customHeaderValue, result);

ExpectedExceptionTests.4.1.1.cs (1)

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

GeneratorTests.cs (8)

83Assert.Equal(expected, description); 100Assert.Equal(expected, description); 114Assert.Equal(expected, description); 132Assert.Equal(expected, description); 143Assert.Equal(expected, description); 154Assert.Equal(expected, description); 1585Assert.Equal(expectedText, actualText); 1604Assert.Equal(baseline, actual);

FaultExceptionTests.4.0.0.cs (3)

154Assert.Equal(faultMsg, exception.Detail.Message); 191Assert.Equal(faultMsg, exception.Detail.Message); 228Assert.Equal(faultMsg, exception.Detail.Message);

MessageContractTests.4.1.0.cs (1)

106Assert.Equal(MessageContractConstants.customerElementValue, reader.Value);

ServiceContractTests.4.1.0.cs (12)

44Assert.Equal(testString, result); 80Assert.Equal(testString, result); 115Assert.Equal(testString, result); 152Assert.Equal(testString, result); 189Assert.Equal(testString, result); 374Assert.Equal(testString, result); 410Assert.Equal(testString, result); 445Assert.Equal(testString, result); 482Assert.Equal(testString, result); 519Assert.Equal(testString, result); 556Assert.Equal(testString, result); 593Assert.Equal(testString, result);

ServiceKnownTypeTests.4.0.0.cs (2)

117Assert.Equal(expectedId, ((Widget)response[0]).Id); 118Assert.Equal(expectedCatalog, ((Widget)response[0]).Catalog);

XmlSerializerFormatSoapTest.cs (3)

26Assert.Equal(message1 + message2, response); 43Assert.Equal(value.StringValue, response.StringValue); 58Assert.Equal("MyNameFoo", response);

XmlSerializerFormatTest.4.0.0.cs (8)

26Assert.Equal("message", response); 39Assert.Equal("message", response); 59Assert.Equal(errorMessage, e.Message); 77Assert.Equal("message", response); 93Assert.Equal("message", response.Result); 111Assert.Equal("message", response.StringValue); 137Assert.Equal("123", response.@return); 206Assert.Equal("message", response);

XmlSerializerFormatTest.4.1.0.cs (3)

31Assert.Equal(input.Message, response.Message); 58Assert.Equal(input.Message, response.Message); 96Assert.Equal(customHeaderValue.Message, result);

XmlSerializerFormatTest.cs (11)

183Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 231Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 279Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 332Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 345Assert.Equal(testStr, serviceProxy2.GetAndRemoveString(guid2)); 389Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 402Assert.Equal(testStr, serviceProxy2.GetAndRemoveString(guid2)); 446Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 459Assert.Equal(testStr, serviceProxy2.GetAndRemoveString(guid2)); 496Assert.Equal(echoText, response.EchoResult); 497Assert.Equal(expectedHeaderText, response.StringHeader.HeaderValue);

DatabaseErrorPageMiddlewareTest.cs (5)

45Assert.Equal("Request Handled", await response.Content.ReadAsStringAsync()); 83Assert.Equal("Exception requested from TestMiddleware", ex.Message); 109Assert.Equal("SQLite Error 1: 'no such table: Blogs'.", ex.InnerException.Message); 184Assert.Equal("DbUpdateException", e.GetType().Name); 308Assert.Equal("Saved a Blog", content);

MigrationsEndPointMiddlewareTest.cs (4)

42Assert.Equal("Request Handled", await response.Content.ReadAsStringAsync()); 135Assert.Equal("111111111111111_MigrationOne", appliedMigrations.ElementAt(0).MigrationId); 136Assert.Equal("222222222222222_MigrationTwo", appliedMigrations.ElementAt(1).MigrationId); 265Assert.Equal("Welcome to the invalid snapshot!", ex.InnerException.Message);

DeveloperExceptionPageSampleTest.cs (6)

56Assert.Equal("application/json", exceptionNode.GetProperty("headers").GetProperty("Accept")[0].GetString()); 57Assert.Equal("localhost", exceptionNode.GetProperty("headers").GetProperty("Host")[0].GetString()); 58Assert.Equal("/", exceptionNode.GetProperty("path").GetString()); 59Assert.Equal("Endpoint display name", exceptionNode.GetProperty("endpoint").GetString()); 60Assert.Equal("Value1", exceptionNode.GetProperty("routeValues").GetProperty("routeValue1").GetString()); 61Assert.Equal("Value2", exceptionNode.GetProperty("routeValues").GetProperty("routeValue2").GetString());

src\System.Private.ServiceModel\tests\Scenarios\Contract\XmlSerializer\XmlSerializerFormatSoapTest.cs (3)

26Assert.Equal(message1 + message2, response); 43Assert.Equal(value.StringValue, response.StringValue); 58Assert.Equal("MyNameFoo", response);

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

26Assert.Equal("message", response); 39Assert.Equal("message", response); 59Assert.Equal(errorMessage, e.Message); 77Assert.Equal("message", response); 93Assert.Equal("message", response.Result); 111Assert.Equal("message", response.StringValue); 137Assert.Equal("123", response.@return); 206Assert.Equal("message", response);

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

31Assert.Equal(input.Message, response.Message); 58Assert.Equal(input.Message, response.Message); 96Assert.Equal(customHeaderValue.Message, result);

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

183Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 231Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 279Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 332Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 345Assert.Equal(testStr, serviceProxy2.GetAndRemoveString(guid2)); 389Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 402Assert.Equal(testStr, serviceProxy2.GetAndRemoveString(guid2)); 446Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 459Assert.Equal(testStr, serviceProxy2.GetAndRemoveString(guid2)); 496Assert.Equal(echoText, response.EchoResult); 497Assert.Equal(expectedHeaderText, response.StringHeader.HeaderValue);

TextTests.4.1.0.cs (1)

46Assert.Equal(result, testString);

TestConnections.cs (2)

112Assert.Equal(expected, Encoding.ASCII.GetString((await ReceiveChunk()).Span)); 120Assert.Equal(expected, Encoding.ASCII.GetString(actual.Span));

Http2TrailersResetTests.cs (20)

76Assert.Equal("TrailerValue", response.TrailingHeaders.GetValues("TrailerName").Single()); 87Assert.Equal("Hello World", await response.Content.ReadAsStringAsync()); 89Assert.Equal("Trailer Value", response.TrailingHeaders.GetValues("TrailerName").Single()); 102Assert.Equal(body, await response.Content.ReadAsStringAsync()); 104Assert.Equal("Trailer Value", response.TrailingHeaders.GetValues("TrailerName").Single()); 119Assert.Equal((2 * body.Length).ToString(CultureInfo.InvariantCulture), contentLength.First()); 120Assert.Equal(body + body, await response.Content.ReadAsStringAsync()); 122Assert.Equal("Trailer Value", response.TrailingHeaders.GetValues("TrailerName").Single()); 137Assert.Equal(body.Length.ToString(CultureInfo.InvariantCulture), contentLength.First()); 138Assert.Equal("TrailerName", response.Headers.Trailer.Single()); 139Assert.Equal(body, await response.Content.ReadAsStringAsync()); 141Assert.Equal("Trailer Value", response.TrailingHeaders.GetValues("TrailerName").Single()); 167Assert.Equal("TrailerValue", response.TrailingHeaders.GetValues("TrailerName").Single()); 182Assert.Equal("Hello World", await response.Content.ReadAsStringAsync()); 184Assert.Equal("Trailer Value", response.TrailingHeaders.GetValues("TrailerName").Single()); 206Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 266Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 327Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 440Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 470Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]);

Http3Tests.cs (9)

54Assert.Equal("HTTP/3", await response.Content.ReadAsStringAsync()); 72Assert.Equal("HTTP/1.1", await response1.Content.ReadAsStringAsync()); 73Assert.Equal(altsvc, response1.Headers.GetValues(HeaderNames.AltSvc).SingleOrDefault()); 78Assert.Equal("HTTP/3", await response3.Content.ReadAsStringAsync()); 94Assert.Equal(altsvc, response2.Headers.GetValues(HeaderNames.AltSvc).SingleOrDefault()); 95Assert.Equal("HTTP/2", await response2.Content.ReadAsStringAsync()); 99Assert.Equal("HTTP/3", response3); 112Assert.Equal("HTTP/3", result); 113Assert.Equal("value", response.TrailingHeaders.GetValues("custom").SingleOrDefault());

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

76Assert.Equal("Windows", responseText);

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

143Assert.Equal(messages, await response.Content.ReadAsStringAsync());

src\Servers\IIS\IIS\test\Common.FunctionalTests\GlobalVersionTests.cs (6)

54Assert.Equal(_helloWorldResponse, responseText); 78Assert.Equal(_helloWorldResponse, responseText); 124Assert.Equal(_helloWorldResponse, responseText); 149Assert.Equal(_helloWorldResponse, responseText); 170Assert.Equal(_helloWorldResponse, responseText); 186Assert.Equal(_helloWorldResponse, responseText);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Http2Tests.cs (11)

83Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 120Assert.Equal("411", decodedHeaders[InternalHeaderNames.Status]); 173Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 190Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 242Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 259Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 287Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 304Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 343Assert.Equal("500", decodedHeaders[InternalHeaderNames.Status]); 363Assert.Equal("Hello World", response); 377Assert.Equal("Hello World", response);

src\Servers\IIS\IIS\test\Common.FunctionalTests\HttpsTests.cs (2)

97Assert.Equal($"Enabled;{cert.GetCertHashString()}", responseText); 101Assert.Equal("Disabled", responseText);

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

33Assert.Equal("Hello World", responseText);

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

54Assert.Equal(expectedResponse, await response.Content.ReadAsStringAsync()); 70Assert.Equal("Hello World", responseText);

src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestPathBaseTests.cs (2)

52Assert.Equal($"PathBase: {expectedPathBase}; Path: {expectedPath}", body); 82Assert.Equal($"PathBase: {expectedPathBase}; Path: {expectedPath}", body);

src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (44)

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

33Assert.Equal("Hello World", responseText);

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

54Assert.Equal(expectedResponse, await response.Content.ReadAsStringAsync()); 70Assert.Equal("Hello World", responseText);

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

48Assert.Equal("Hello World", await deploymentResult.HttpClient.GetStringAsync("/HelloWorld"));

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (21)

NewHandlerTests.cs (1)

38Assert.Equal("12.2.18316.0", handle.FileVersionInfo.FileVersion);

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

33Assert.Equal("Hello World", responseText);

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

54Assert.Equal(expectedResponse, await response.Content.ReadAsStringAsync()); 70Assert.Equal("Hello World", responseText);

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

48Assert.Equal("Hello World", await deploymentResult.HttpClient.GetStringAsync("/HelloWorld"));

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (21)

NewShimTests.cs (1)

31Assert.Equal("12.2.19169.6", handle.FileVersionInfo.FileVersion);

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

33Assert.Equal("Hello World", responseText);

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

54Assert.Equal(expectedResponse, await response.Content.ReadAsStringAsync()); 70Assert.Equal("Hello World", responseText);

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

48Assert.Equal("Hello World", await deploymentResult.HttpClient.GetStringAsync("/HelloWorld"));

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (21)

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

33Assert.Equal("Hello World", responseText);

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

54Assert.Equal(expectedResponse, await response.Content.ReadAsStringAsync()); 70Assert.Equal("Hello World", responseText);

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

TestServerTest.cs (2)

31Assert.Equal(helloWorld, await result.Content.ReadAsStringAsync()); 32Assert.Equal(expectedPath, path);

TlsHandshakeFeatureTests.cs (1)

57Assert.Equal("localhost", hostName);

InProcess\AuthenticationTests.cs (2)

35Assert.Equal("Anonymous?True", responseText); 60Assert.Equal("Anonymous?True", responseText);

InProcess\WebSocketTests.cs (1)

161Assert.Equal(expectedMessage, Encoding.ASCII.GetString(received));

OutOfProcess\MultipleAppTests.cs (1)

57Assert.Equal("Hello World", responseText);

OutOfProcess\NtlmAuthentationTest.cs (4)

49Assert.Equal("Hello World", responseText); 55Assert.Equal("Anonymous?True", responseText); 77Assert.Equal("Anonymous?True", responseText); 82Assert.Equal("Windows", responseText);

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

76Assert.Equal("Windows", responseText);

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

143Assert.Equal(messages, await response.Content.ReadAsStringAsync());

src\Servers\IIS\IIS\test\Common.FunctionalTests\GlobalVersionTests.cs (6)

54Assert.Equal(_helloWorldResponse, responseText); 78Assert.Equal(_helloWorldResponse, responseText); 124Assert.Equal(_helloWorldResponse, responseText); 149Assert.Equal(_helloWorldResponse, responseText); 170Assert.Equal(_helloWorldResponse, responseText); 186Assert.Equal(_helloWorldResponse, responseText);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Http2Tests.cs (11)

83Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 120Assert.Equal("411", decodedHeaders[InternalHeaderNames.Status]); 173Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 190Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 242Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 259Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 287Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 304Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 343Assert.Equal("500", decodedHeaders[InternalHeaderNames.Status]); 363Assert.Equal("Hello World", response); 377Assert.Equal("Hello World", response);

src\Servers\IIS\IIS\test\Common.FunctionalTests\HttpsTests.cs (2)

97Assert.Equal($"Enabled;{cert.GetCertHashString()}", responseText); 101Assert.Equal("Disabled", responseText);

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

33Assert.Equal("Hello World", responseText);

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

54Assert.Equal(expectedResponse, await response.Content.ReadAsStringAsync()); 70Assert.Equal("Hello World", responseText);

src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestPathBaseTests.cs (2)

52Assert.Equal($"PathBase: {expectedPathBase}; Path: {expectedPath}", body); 82Assert.Equal($"PathBase: {expectedPathBase}; Path: {expectedPath}", body);

src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (44)

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

48Assert.Equal("Hello World", await deploymentResult.HttpClient.GetStringAsync("/HelloWorld"));

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (21)

UpgradeFeatureDetectionTests.cs (1)

76Assert.Equal(expected, responseText);

BadHttpRequestTests.cs (3)

184Assert.Equal("www.foo.com:80", receivedHost); 353Assert.Equal(expectedExceptionMessage, loggedException.Message); 357Assert.Equal("Microsoft.AspNetCore.Server.Kestrel.BadRequest", eventProviderName);

ChunkedRequestTests.cs (19)

180Assert.Equal("POST", request.Method); 251Assert.Equal("X-Trailer-Header", request.GetDeclaredTrailers().ToString()); 273Assert.Equal(string.Empty, request.GetDeclaredTrailers().ToString()); 274Assert.Equal(string.Empty, request.GetTrailer("X-Trailer-Header").ToString()); 281Assert.Equal("X-Trailer-Header", request.GetDeclaredTrailers().ToString()); 282Assert.Equal(new string('a', requestsReceived), request.GetTrailer("X-Trailer-Header").ToString()); 289Assert.Equal(string.Empty, request.GetDeclaredTrailers().ToString()); 290Assert.Equal(string.Empty, request.GetTrailer("X-Trailer-Header").ToString()); 377Assert.Equal("X-Trailer-Header", request.GetDeclaredTrailers().ToString()); 404Assert.Equal(string.Empty, request.GetDeclaredTrailers().ToString()); 405Assert.Equal(string.Empty, request.GetTrailer("X-Trailer-Header").ToString()); 412Assert.Equal("X-Trailer-Header", request.GetDeclaredTrailers().ToString()); 413Assert.Equal(new string('a', requestsReceived), request.GetTrailer("X-Trailer-Header").ToString()); 420Assert.Equal(string.Empty, request.GetDeclaredTrailers().ToString()); 421Assert.Equal(string.Empty, request.GetTrailer("X-Trailer-Header").ToString()); 596Assert.Equal(new string('a', requestsReceived), request.GetTrailer("X-Trailer-Header").ToString()); 916Assert.Equal("POST", request.Method); 972Assert.Equal("POST", request.Method); 1085Assert.Equal("POST", request.Method);

EventSourceTests.cs (31)

Http2\Http2ConnectionTests.cs (27)

Http2\Http2EndToEndTests.cs (1)

74Assert.Equal("hello, world", await responseMessage.Content.ReadAsStringAsync());

Http2\Http2StreamTests.cs (235)

Http2\Http2TestBase.cs (4)

1356Assert.Equal(header.Value, _receivedRequestFields.Method); 1361Assert.Equal(header.Value, host); 1365Assert.Equal(header.Value, _receivedRequestFields.Scheme); 1369Assert.Equal(header.Value, _receivedRequestFields.RawTarget);

Http2\Http2WebSocketTests.cs (42)

Http3\Http3ConnectionTests.cs (7)

70Assert.Equal("Hello world", Encoding.ASCII.GetString(responseData.ToArray())); 113Assert.Equal("Hello world", Encoding.ASCII.GetString(responseData.ToArray())); 119Assert.Equal($"End", Encoding.ASCII.GetString(responseData.ToArray())); 161Assert.Equal("a=0; b=1; c=2", receivedHeaders); 485Assert.Equal("application/json", contentTypeValue1); 797Assert.Equal($"Hello world {index}", Encoding.ASCII.GetString(responseData.ToArray())); 803Assert.Equal($"End {index}", Encoding.ASCII.GetString(responseData.ToArray()));

Http3\Http3StreamTests.cs (128)

HttpsConnectionMiddlewareTests.cs (23)

66Assert.Equal("content=Hello+World%3F", result); 100Assert.Equal("content=Hello+World%3F", result); 122Assert.Equal("hello world", result); 147Assert.Equal(expectedHostname, tlsFeature.HostName); 161Assert.Equal("hello world", result); 197Assert.Equal("hello world", result); 239Assert.Equal("hello world", result); 267Assert.Equal("hello world", result); 308Assert.Equal("localhost", name); 338Assert.Equal("localhost", clientHelloInfo.ServerName); 372Assert.Equal("localhost", name); 445Assert.Equal("localhost", name); 899Assert.Equal("Client stream needs to be drained before renegotiation.", ex.Message); 1036Assert.Equal(expectedBody, body); 1083Assert.Equal("Client stream needs to be drained before renegotiation.", ioe.Message); 1101Assert.Equal("HTTP/1.1 200 OK", await reader.ReadLineAsync().DefaultTimeout()); 1102Assert.Equal("Content-Length: 11", await reader.ReadLineAsync().DefaultTimeout()); 1103Assert.Equal("Connection: close", await reader.ReadLineAsync().DefaultTimeout()); 1105Assert.Equal("", await reader.ReadLineAsync().DefaultTimeout()); 1106Assert.Equal("hello world", await reader.ReadLineAsync().DefaultTimeout()); 1121Assert.Equal("https", result); 1351Assert.Equal(CoreStrings.FormatInvalidServerCertificateEku(cert.Thumbprint), ex.Message); 1526Assert.Equal("HTTP/1.1 200 OK", line);

HttpsTests.cs (1)

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

KestrelMetricsTests.cs (16)

LoggingConnectionMiddlewareTests.cs (1)

36Assert.Equal("Hello World!", response);

MaxRequestBodySizeTests.cs (12)

RequestTargetProcessingTests.cs (3)

24Assert.Equal("/\u0041\u030A/B/\u0041\u030A", context.Request.Path.Value); 69Assert.Equal(requestTarget, context.Features.Get<IHttpRequestFeature>().RawTarget); 101Assert.Equal(requestTarget, context.Features.Get<IHttpRequestFeature>().RawTarget);

RequestTests.cs (22)

48Assert.Equal(string.Empty, await server.HttpClientSlim.GetStringAsync($"http://localhost:{server.Port}/")); 49Assert.Equal(string.Empty, await server.HttpClientSlim.GetStringAsync($"http://localhost:{server.Port}/")); 72Assert.Equal("hello, world", await server.HttpClientSlim.GetStringAsync($"http://localhost:{server.Port}/")); 73Assert.Equal("hello, world", await server.HttpClientSlim.GetStringAsync($"http://localhost:{server.Port}/")); 105Assert.Equal("hello, world", await server.HttpClientSlim.GetStringAsync($"http://localhost:{server.Port}/")); 123Assert.Equal("Hello ", Encoding.ASCII.GetString(data)); 268Assert.Equal(requestUrl, await rawTargetTcs.Task); 275Assert.Equal(queryValue, (await queryTcs.Task)["q"]); 582Assert.Equal(knownId, requestId); 1699Assert.Equal(CoreStrings.SynchronousReadsDisallowed, ioEx.Message); 1702Assert.Equal(CoreStrings.SynchronousReadsDisallowed, ioEx2.Message); 1710Assert.Equal("Hello", Encoding.ASCII.GetString(buffer, 0, 5)); 1753Assert.Equal("Hello", Encoding.ASCII.GetString(buffer, 0, 5)); 1792Assert.Equal(CoreStrings.SynchronousReadsDisallowed, ioEx.Message); 1795Assert.Equal(CoreStrings.SynchronousReadsDisallowed, ioEx2.Message); 1801Assert.Equal("Hello", Encoding.ASCII.GetString(buffer)); 1843Assert.Equal("Hello", Encoding.ASCII.GetString(buffer, 0, 5)); 1908Assert.Equal("POST", request.Method); 1958Assert.Equal("POST", request.Method); 2043Assert.Equal("POST", request.Method); 2201Assert.Equal("£", context.Request.Headers["X-Test"]); 2294Assert.Equal("£", context.Request.Headers["X-Test"]);

ResponseDrainingTests.cs (1)

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

ResponseTests.cs (10)

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); 984Assert.Equal( 1022Assert.Equal( 1062Assert.Equal( 1097Assert.Equal( 3425Assert.Equal(CoreStrings.SynchronousWritesDisallowed, ioEx.Message); 3521Assert.Equal(CoreStrings.SynchronousWritesDisallowed, ioEx.Message);

src\Servers\Kestrel\shared\test\MetricsAssert.cs (1)

14Assert.Equal(KestrelMetrics.GetErrorType(expectedReason), errorType);

src\Servers\Kestrel\shared\test\StreamBackedTestConnection.cs (2)

126Assert.Equal(expected, actualText); 135Assert.Equal("", text);

UpgradeTests.cs (7)

32Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, ex.Message); 35Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, ex.Message); 84Assert.Equal(send, line); 155Assert.Equal(CoreStrings.UpgradeCannotBeCalledMultipleTimes, ex.Message); 239Assert.Equal("chunked", context.Request.Headers.TransferEncoding); 297Assert.Equal(CoreStrings.CannotUpgradeNonUpgradableRequest, ex.Message); 348Assert.Equal(CoreStrings.UpgradedConnectionLimitReached, exception.Message);

src\Servers\IIS\IIS\test\testassets\InProcessWebSite\Startup.cs (18)

275Assert.Equal("GET", ctx.Request.Method); 277Assert.Equal("test", ctx.Request.Method); 279Assert.Equal("http", ctx.Request.Scheme); 281Assert.Equal("test", ctx.Request.Scheme); 283Assert.Equal("/FeatureCollectionSetRequestFeatures", ctx.Request.PathBase); 285Assert.Equal("/base", ctx.Request.PathBase); 287Assert.Equal("/path", ctx.Request.Path); 289Assert.Equal("/path", ctx.Request.Path); 291Assert.Equal("?query", ctx.Request.QueryString.Value); 293Assert.Equal("", ctx.Request.QueryString.Value); 295Assert.Equal("HTTP/1.1", ctx.Request.Protocol); 297Assert.Equal("HTTP/1.0", ctx.Request.Protocol); 337Assert.Equal("Set Response", ctx.Features.Get<IHttpResponseFeature>().ReasonPhrase); 1147Assert.Equal("£", value); 1154Assert.Equal("�", value); 1166Assert.Equal("gzip, chunked", ctx.Request.Headers["Transfer-Encoding"]); 1184Assert.Equal("gzip, chunked", ctx.Request.Headers["Transfer-Encoding"]); 1187Assert.Equal("5", ctx.Request.Headers["X-Content-Length"]);

src\Servers\IIS\IIS\test\testassets\InProcessWebSite\Startup.WebSockets.cs (1)

97Assert.Equal("Upgrade requires HTTP/1.1.", ex.Message);

InteractiveHostCoreInitTests.cs (2)

91Assert.Equal("", error); 92Assert.Equal("[Metadata.ICSProp]\r\n", output);

InteractiveHostCoreTests.cs (2)

34Assert.Equal("", output); 43Assert.Equal("2\r\n", output.ToString());

InteractiveHostDesktopInitTests.cs (2)

64Assert.Equal("", error); 65Assert.Equal("[Metadata.ICSProp]\r\n", output);

InteractiveHostDesktopTests.cs (50)

Http2\Http2RequestTests.cs (16)

78Assert.Equal("http", (string)tags.Single(t => t.Key == "network.protocol.name").Value); 79Assert.Equal("2", (string)tags.Single(t => t.Key == "network.protocol.version").Value); 80Assert.Equal("tcp", (string)tags.Single(t => t.Key == "network.transport").Value); 81Assert.Equal("ipv4", (string)tags.Single(t => t.Key == "network.type").Value); 82Assert.Equal("127.0.0.1", (string)tags.Single(t => t.Key == "server.address").Value); 84Assert.Equal("invalid_handshake", (string)tags.Single(t => t.Key == "error.type").Value); 145Assert.Equal("http", (string)m.Tags["network.protocol.name"]); 146Assert.Equal("2", (string)m.Tags["network.protocol.version"]); 147Assert.Equal("tcp", (string)m.Tags["network.transport"]); 148Assert.Equal("ipv6", (string)m.Tags["network.type"]); 149Assert.Equal("::1", (string)m.Tags["server.address"]); 151Assert.Equal("1.2", (string)m.Tags["tls.protocol.version"]); 191Assert.Equal("abc", response.Headers.GetValues("test").Single()); 192Assert.Equal(longValue, response.Headers.GetValues(longKey).Single()); 218Assert.Equal("An HTTP/1.x request was sent to an HTTP/2 only endpoint.", await responseMessage.Content.ReadAsStringAsync()); 287Assert.Equal("value!", trailers.GetValues("test-trailer").Single());

Http2WebSocketInteropTests.cs (3)

61Assert.Equal(expectedVersion, context.Request.Protocol); 68Assert.Equal("Hello", Encoding.UTF8.GetString(bytes, 0, result.Count)); 92Assert.Equal("Hi there", Encoding.UTF8.GetString(bytes, 0, result.Count));

Http3\Http3RequestTests.cs (18)

105Assert.Equal("ipv4", (string)m.Tags["network.type"]); 106Assert.Equal("http", (string)m.Tags["network.protocol.name"]); 107Assert.Equal("3", (string)m.Tags["network.protocol.version"]); 108Assert.Equal("udp", (string)m.Tags["network.transport"]); 109Assert.Equal("127.0.0.1", (string)m.Tags["server.address"]); 111Assert.Equal("1.3", (string)m.Tags["tls.protocol.version"]); 155Assert.Equal("hello, world", await responseMessage.Content.ReadAsStringAsync()); 439Assert.Equal("Hello world", responseText); 521Assert.Equal("The client reset the request stream.", serverEx.Message); 587Assert.Equal("The connection was aborted by the application.", serverEx.Message); 740Assert.Equal("Hello world", responseText); 1046Assert.Equal("The client reset the request stream.", serverEx.Message); 1256Assert.Equal(new string('!', i), value); 1312Assert.Equal(connectionId1, connectionId2); // ConnectionId unchanged 1314Assert.Equal($"{connectionId1}:00000000", traceId1); 1315Assert.Equal($"{connectionId2}:00000004", traceId2); 1376Assert.Equal("TestUserAgent", request1HeaderValue); 1942Assert.Equal("The connection was aborted because the server is shutting down and request processing didn't complete within the time specified by HostOptions.ShutdownTimeout.", ex.Message);

Http3\Http3TlsTests.cs (10)

44Assert.Equal("testhost", host); 65Assert.Equal("Hello World", result); 111Assert.Equal("True", result); 153Assert.Equal("False", result); 211Assert.Equal("True", await response.Content.ReadAsStringAsync().DefaultTimeout()); 250Assert.Equal("False", await response.Content.ReadAsStringAsync()); 283Assert.Equal("The OnAuthenticate callback is not supported with HTTP/3.", exception.Message); 331Assert.Equal("Hello World", result); 485Assert.Equal(expectedCertificate.GetSerialNumberString(), actualCertificate.GetSerialNumberString()); 496Assert.Equal("Hello World", result);

HttpClientHttp2InteropTests.cs (33)

CallAnalysis\LegacyLoggingTests.cs (19)

CallAnalysis\LegacyLoggingTests.Extra.cs (16)

MakeExeTypesInternalTests.cs (2)

75Assert.Equal(ExpectedFixedSource.Replace("\r\n", "\n", StringComparison.Ordinal), actualFixedSources[0]); 173Assert.Equal(DiagDescriptors.MakeExeTypesInternal.Id, f.FixableDiagnosticIds[0]);

Json\JsonReaderTest.cs (11)

Json\JsonValueTest.cs (10)

36Assert.Equal("text", new JsonValue("text").AsString); 55Assert.Equal("interface Microsoft.Extensions.Metrics.IHistogram2<in T> where T : struct", 122Assert.Equal("false", new JsonValue(false).AsString); 123Assert.Equal("true", new JsonValue(true).AsString); 124Assert.Equal("0.5", new JsonValue(0.5).AsString); 125Assert.Equal("1", new JsonValue(1.0).AsString); 126Assert.Equal("text", new JsonValue("text").AsString); 135Assert.Equal("0.5", new JsonValue(0.5).AsString); 211Assert.Equal(time.ToString("o", CultureInfo.InvariantCulture), ((JsonValue)time).AsString); 280Assert.Equal("text", (string?)new JsonValue("text"));

AssertEx.cs (2)

352Assert.Equal(parameterName, e.ParamName); 364Assert.Equal(parameterName, e.ParamName);

StartupAnalyzerTest.cs (5)

61Assert.Collection(ConfigureServicesMethods, m => Assert.Equal("ConfigureServices", m.Name)); 62Assert.Collection(ConfigureMethods, m => Assert.Equal("Configure", m.Name)); 112m => Assert.Equal("ConfigureServices", m.Name)); 116m => Assert.Equal("Configure", m.Name), 117m => Assert.Equal("ConfigureProduction", m.Name));

AntiforgeryApplicationBuilderExtensionsTest.cs (1)

44Assert.Equal(

AntiforgeryOptionsSetupTest.cs (2)

34Assert.Equal(expectedCookieName, cookieName); 59Assert.Equal("antiforgery", cookieName);

AntiforgeryTokenTest.cs (6)

15Assert.Equal("", token.AdditionalData); 19Assert.Equal("additional data", token.AdditionalData); 23Assert.Equal("", token.AdditionalData); 70Assert.Equal("", token.Username); 74Assert.Equal("my username", token.Username); 78Assert.Equal("", token.Username);

BinaryBlobTest.cs (2)

28Assert.Equal("bitLength", ex.ParamName); 63Assert.Equal("data", ex.ParamName);

DefaultAntiforgeryTest.cs (44)

DefaultAntiforgeryTokenGeneratorTest.cs (11)

97Assert.Equal( 137Assert.Equal("additional-data", fieldToken.AdditionalData); 170Assert.Equal("", fieldToken.Username); 172Assert.Equal("", fieldToken.AdditionalData); 203Assert.Equal("my-username", fieldToken.Username); 330Assert.Equal(expectedMessage, message); 357Assert.Equal(expectedMessage, message); 382Assert.Equal(expectedMessage, message); 422Assert.Equal(expectedMessage, message); 460Assert.Equal(expectedMessage, message); 497Assert.Equal(expectedMessage, message);

DefaultAntiforgeryTokenSerializerTest.cs (3)

51Assert.Equal(@"The antiforgery token could not be decrypted.", ex.Message); 178Assert.Equal(expected.AdditionalData, actual.AdditionalData); 182Assert.Equal(expected.Username, actual.Username);

DefaultAntiforgeryTokenStoreTest.cs (13)

70Assert.Equal(expectedToken, token); 387Assert.Equal(_cookieName, cookies.Key); 388Assert.Equal("serialized-value", cookies.Value); 426Assert.Equal(_cookieName, cookies.Key); 427Assert.Equal("serialized-value", cookies.Value); 429Assert.Equal(expectedCookiePath, cookies.Options.Path); 466Assert.Equal(_cookieName, cookies.Key); 467Assert.Equal("serialized-value", cookies.Value); 469Assert.Equal(expectedCookiePath, cookies.Options.Path); 505Assert.Equal(_cookieName, cookies.Key); 506Assert.Equal("serialized-value", cookies.Value); 508Assert.Equal("/vdir1", cookies.Options.Path); 509Assert.Equal(expectedCookieDomain, cookies.Options.Domain);

DefaultClaimUidExtractorTest.cs (4)

48Assert.Equal("yhXE+2v4zSXHtRHmzm4cmrhZca2J0g7yTUwtUerdeF4=", claimUid); 73Assert.Equal(identiferParameters[index++], claim.Type); 74Assert.Equal(identiferParameters[index++], claim.Value); 75Assert.Equal(identiferParameters[index++], claim.Issuer);

Dependencies\AddPackageTests.cs (1)

79Assert.Equal("Microsoft.AspNetCore.OpenApi", packageInstallData.PackageName);

Infrastructure\WellKnownTypesTests.cs (2)

36Assert.Collection(diagnostics, d => Assert.Equal("TEST001", d.Id)); 69Assert.Collection(diagnostics, d => Assert.Equal("TEST001", d.Id));

RouteEmbeddedLanguage\FrameworkParametersCompletionProviderTests.cs (35)

RouteEmbeddedLanguage\RoutePatternAnalyzerTests.cs (11)

RouteEmbeddedLanguage\RoutePatternCompletionProviderTests.cs (25)

RouteEmbeddedLanguage\RoutePatternParserTests_ConformanceTests.cs (25)

RouteHandlers\DetectMisplacedLambdaAttributeTest.cs (7)

50Assert.Equal("'AuthorizeAttribute' should be placed directly on the route handler lambda to be effective", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 72Assert.Equal("'AuthorizeAttribute' should be placed directly on the route handler lambda to be effective", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 98Assert.Equal("'AuthorizeAttribute' should be placed directly on the route handler lambda to be effective", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 104Assert.Equal("'ProducesAttribute' should be placed directly on the route handler lambda to be effective", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 131Assert.Equal("'ProducesAttribute' should be placed directly on the route handler lambda to be effective", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 170Assert.Equal("CS0103", diagnostic.Descriptor.Id); 220Assert.Equal("'AuthorizeAttribute' should be placed directly on the route handler lambda to be effective", diagnostic.GetMessage(CultureInfo.InvariantCulture));

RouteHandlers\DisallowMvcBindArgumentsOnParametersTest.cs (2)

63Assert.Equal("BindAttribute should not be specified for a MapGet Delegate parameter", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 85Assert.Equal("ModelBinderAttribute should not be specified for a MapPost Delegate parameter", diagnostic.GetMessage(CultureInfo.InvariantCulture));

RouteHandlers\DisallowReturningActionResultsFromMapMethodsTest.cs (6)

132Assert.Equal("IActionResult instances should not be returned from a MapGet Delegate parameter. Consider returning an equivalent result from Microsoft.AspNetCore.Http.Results.", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 155Assert.Equal("IActionResult instances should not be returned from a MapGet Delegate parameter. Consider returning an equivalent result from Microsoft.AspNetCore.Http.Results.", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 183Assert.Equal("IActionResult instances should not be returned from a MapPost Delegate parameter. Consider returning an equivalent result from Microsoft.AspNetCore.Http.Results.", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 215Assert.Equal("IActionResult instances should not be returned from a MapPost Delegate parameter. Consider returning an equivalent result from Microsoft.AspNetCore.Http.Results.", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 253Assert.Equal("IActionResult instances should not be returned from a MapPost Delegate parameter. Consider returning an equivalent result from Microsoft.AspNetCore.Http.Results.", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 291Assert.Equal("IActionResult instances should not be returned from a MapPost Delegate parameter. Consider returning an equivalent result from Microsoft.AspNetCore.Http.Results.", diagnostic.GetMessage(CultureInfo.InvariantCulture));

WebApplicationBuilder\DisallowConfigureHostBuilderConfigureWebHostTest.cs (7)

47Assert.Equal("ConfigureWebHost cannot be used with WebApplicationBuilder.Host", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 68Assert.Equal("ConfigureWebHost cannot be used with WebApplicationBuilder.Host", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 90Assert.Equal("ConfigureWebHost cannot be used with WebApplicationBuilder.Host", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 130Assert.Equal("ConfigureWebHost cannot be used with WebApplicationBuilder.Host", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 158Assert.Equal("ConfigureWebHost cannot be used with WebApplicationBuilder.Host", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 187Assert.Equal("ConfigureWebHost cannot be used with WebApplicationBuilder.Host", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 221Assert.Equal("ConfigureWebHost cannot be used with WebApplicationBuilder.Host", diagnostic.GetMessage(CultureInfo.InvariantCulture));

WebApplicationBuilder\DisallowConfigureHostLoggingTest.cs (1)

275Assert.Equal("Suggest using builder.Logging instead of ConfigureLogging", diagnostic.GetMessage(CultureInfo.InvariantCulture));

WebApplicationBuilder\DisallowConfigureServicesTest.cs (1)

286Assert.Equal("Suggest using builder.Services instead of ConfigureServices", diagnostic.GetMessage(CultureInfo.InvariantCulture));

WebApplicationBuilder\DisallowConfigureWebHostBuilderConfigureTest.cs (4)

49Assert.Equal("Configure cannot be used with WebApplicationBuilder.WebHost", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 70Assert.Equal("Configure cannot be used with WebApplicationBuilder.WebHost", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 97Assert.Equal("Configure cannot be used with WebApplicationBuilder.WebHost", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 125Assert.Equal("Configure cannot be used with WebApplicationBuilder.WebHost", diagnostic.GetMessage(CultureInfo.InvariantCulture));

WebApplicationBuilder\DisallowConfigureWebHostBuilderUseStartupTest.cs (6)

48Assert.Equal("UseStartup cannot be used with WebApplicationBuilder.WebHost", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 69Assert.Equal("UseStartup cannot be used with WebApplicationBuilder.WebHost", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 89Assert.Equal("UseStartup cannot be used with WebApplicationBuilder.WebHost", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 110Assert.Equal("UseStartup cannot be used with WebApplicationBuilder.WebHost", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 137Assert.Equal("UseStartup cannot be used with WebApplicationBuilder.WebHost", diagnostic.GetMessage(CultureInfo.InvariantCulture)); 165Assert.Equal("UseStartup cannot be used with WebApplicationBuilder.WebHost", diagnostic.GetMessage(CultureInfo.InvariantCulture));

WebApplicationBuilder\UseTopLevelRouteRegistrationInsteadOfUseEndpointsTest.cs (9)

SharedFxTests.cs (8)

95Assert.Equal("Microsoft.NETCore.App", (string)runtimeConfig["runtimeOptions"]["framework"]["name"]); 96Assert.Equal(_expectedTfm, (string)runtimeConfig["runtimeOptions"]["tfm"]); 97Assert.Equal("LatestPatch", (string)runtimeConfig["runtimeOptions"]["rollForward"]); 99Assert.Equal(TestData.GetMicrosoftNETCoreAppPackageVersion(), (string)runtimeConfig["runtimeOptions"]["framework"]["version"]); 115Assert.Equal(target, (string)depsFile["runtimeTarget"]["name"]); 122Assert.Equal("package", lib["type"].Value<string>()); 254Assert.Equal(TestData.GetRepositoryCommit(), lines[0]); 255Assert.Equal(TestData.GetSharedFxVersion(), lines[1]);

TargetingPackTests.cs (4)

178Assert.Equal(netCoreAppPackageVersion, packageVersion); 182Assert.Equal(aspNetCoreAppPackageVersion, packageVersion); 279Assert.Equal("Microsoft.AspNetCore.App.Ref", parts[1]); 421Assert.Equal(expectedLanguage, actualLanguage);

AuthenticationPropertiesTests.cs (23)

83Assert.Equal("foo bar", props.GetString("foo")); 84Assert.Equal("foo bar", props.Items["foo"]); 88Assert.Equal("foo baz", props.GetString("foo")); 89Assert.Equal("foo baz", props.Items["foo"]); 93Assert.Equal("xy", props.GetString("bar")); 94Assert.Equal("xy", props.Items["bar"]); 98Assert.Equal(string.Empty, props.GetString("bar")); 99Assert.Equal(string.Empty, props.Items["bar"]); 118Assert.Equal("foo bar", props.GetParameter<string>("foo")); 173Assert.Equal(string.Empty, props.Items.First().Value); 186Assert.Equal("http://example.com", props.RedirectUri); 187Assert.Equal("http://example.com", props.Items.First().Value); 201Assert.Equal("Wed, 21 Mar 2018 00:00:00 GMT", props.Items.First().Value); 215Assert.Equal("Mon, 19 Mar 2018 12:34:56 GMT", props.Items.First().Value); 229Assert.Equal("True", props.Items.First().Value); 233Assert.Equal("False", props.Items.First().Value); 245Assert.Equal("Mon, 19 Mar 2018 12:34:56 GMT", props.Items["foo"]); 268Assert.Equal("BAR", props.Items["foo"]); 277Assert.Equal(true.ToString(), props.Items["foo"]); 280Assert.Equal(false.ToString(), props.Items["foo"]); 302Assert.Equal("BAR", props.Items["foo"]); 336Assert.Equal(props.RedirectUri, deserialized.RedirectUri); 340Assert.Equal(props.Items["foo"], deserialized.Items["foo"]);

AuthenticationSchemeProviderTests.cs (17)

TokenExtensionTests.cs (16)

UserJwtsTests.cs (14)

EventTests.cs (21)

42Assert.Equal("Negotiate", result.Response.Headers.WWWAuthenticate); 66Assert.Equal("Teapot", result.Response.Headers.WWWAuthenticate); 81Assert.Equal("InvalidBlob", context.Exception.Message); 90Assert.Equal("InvalidBlob", ex.Message); 114Assert.Equal("Teapot", result.Response.Headers.WWWAuthenticate); 129Assert.Equal("A test other error occurred", context.Exception.Message); 138Assert.Equal("A test other error occurred", ex.Message); 164Assert.Equal("Teapot", result.Response.Headers.WWWAuthenticate); 180Assert.Equal("A test credential error occurred", context.Exception.Message); 214Assert.Equal("Teapot", result.Response.Headers.WWWAuthenticate); 230Assert.Equal("A test client error occurred", context.Exception.Message); 264Assert.Equal("Teapot", result.Response.Headers.WWWAuthenticate); 281Assert.Equal("name", identity.Name); 282Assert.Equal("Kerberos", identity.AuthenticationType); 340Assert.Equal("Negotiate", result.Response.Headers.WWWAuthenticate); 364Assert.Equal("Negotiate", result.Response.Headers.WWWAuthenticate); 399Assert.Equal("Negotiate ServerKerberosBlob1", result.Response.Headers.WWWAuthenticate); 406Assert.Equal("Negotiate ServerKerberosBlob2", result.Response.Headers.WWWAuthenticate); 444Assert.Equal("HTTP/1.1", context.Request.Protocol); // Not HTTP/2 552Assert.Equal("NTLM", _protocol); 569Assert.Equal("Kerberos", _protocol);

NegotiateHandlerTests.cs (22)

ServerDeferralTests.cs (2)

29Assert.Equal("The Negotiate Authentication handler cannot be used on a server that directly supports Windows Authentication." 39Assert.Equal("DeferralScheme", options.ForwardDefault);

AuthenticationMiddlewareTests.cs (1)

180Assert.Equal("SomeIssuer", options.TokenValidationParameters.ValidIssuer);

CertificateTests.cs (21)

ClaimActionTests.cs (16)

CookieTests.cs (67)

DynamicSchemeTests.cs (13)

FacebookTests.cs (8)

367Assert.Equal("/me", transaction.Response.Headers.GetValues("Location").First()); 396Assert.Equal("Test App Id", entries["client_id"]); 397Assert.Equal("https://example.com/signin-facebook", entries["redirect_uri"]); 398Assert.Equal("Test App Secret", entries["client_secret"]); 399Assert.Equal("TestCode", entries["code"]); 400Assert.Equal("authorization_code", entries["grant_type"]); 440Assert.Equal("S256", queryParams["code_challenge_method"]); 449Assert.Equal("/challenge", transaction.Response.Headers.GetValues("Location").First());

GoogleTests.cs (82)

JsonDocumentAuthExtensionsTests.cs (1)

21Assert.Equal(expected, value);

JwtBearerTests.cs (32)

JwtBearerTests_Handler.cs (38)

MicrosoftAccountTests.cs (14)

244Assert.Equal("/me", transaction.Response.Headers.GetValues("Location").First()); 252Assert.Equal("Test Refresh Token", transaction.FindClaimValue("RefreshToken")); 271Assert.Equal("https://graph.microsoft.com/user.read", query["scope"]); 272Assert.Equal("consumers", query["domain_hint"]); 273Assert.Equal("username", query["login_hint"]); 274Assert.Equal("select_account", query["prompt"]); 275Assert.Equal("query", query["response_mode"]); 302Assert.Equal("Test Client Id", entries["client_id"]); 303Assert.Equal("https://example.com/signin-microsoft", entries["redirect_uri"]); 304Assert.Equal("Test Client Secret", entries["client_secret"]); 305Assert.Equal("TestCode", entries["code"]); 306Assert.Equal("authorization_code", entries["grant_type"]); 340Assert.Equal("S256", queryParams["code_challenge_method"]); 349Assert.Equal("/me", transaction.Response.Headers.GetValues("Location").First());

OAuthChallengePropertiesTest.cs (10)

71Assert.Equal("login", properties.Prompt); 80Assert.Equal("consent", properties.Prompt); 96Assert.Equal("offline", properties.AccessType); 98Assert.Equal("force", properties.ApprovalPrompt); 100Assert.Equal("test@example.com", properties.LoginHint); 102Assert.Equal("login", properties.Prompt); 114Assert.Equal("offline", properties.AccessType); 115Assert.Equal("force", properties.ApprovalPrompt); 116Assert.Equal("test@example.com", properties.LoginHint); 117Assert.Equal("login", properties.Prompt);

OAuthTests.cs (6)

314Assert.Equal("https://www.example.com/access-denied?ReturnUrl=http%3A%2F%2Ftesthost%2Fredirect", transaction.Response.Headers.Location.ToString()); 336Assert.Equal("testvalue", context.Properties.Items["testkey"]); 371Assert.Equal("Access was denied by the resource owner or by the remote server.", context.Failure.Message); 372Assert.Equal("testvalue", context.Properties.Items["testkey"]); 408Assert.Equal("testvalue", context.Properties.Items["testkey"]); 557Assert.Equal("protected_state", protectedText);

OpenIdConnect\OpenIdConnectAuthenticateTests.cs (3)

36Assert.Equal("Hi from the callback path", transaction.ResponseText); 64Assert.Equal("Hi from the callback path", transaction.ResponseText); 119Assert.Equal("protected_state", protectedText);

OpenIdConnect\OpenIdConnectChallengeTests.cs (10)

165Assert.Equal("text/html", transaction.Response.Content.Headers.ContentType.MediaType); 204Assert.Equal(userState ?? string.Empty, actualProperties.Items[OpenIdConnectDefaults.UserstatePropertiesKey]); 241Assert.Equal(userState, actualProperties.Items[OpenIdConnectDefaults.UserstatePropertiesKey]); 323Assert.Equal($"{OpenIdConnectParameterNames.ClientId}={newClientId}", actual); 361Assert.Equal(newMessage.TestAuthorizeEndpoint, res.Headers.Location.AbsoluteUri); 391Assert.Equal("Oolong", res.Headers.GetValues("tea").Single()); 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); 923Assert.Equal("login", mockBackchannel.PushedParameters["prompt"]);

OpenIdConnect\OpenIdConnectConfigurationTests.cs (5)

444Assert.Equal($"{TestServerBuilder.DefaultAuthority}/.well-known/openid-configuration", handler.Options.MetadataAddress); 492ex => Assert.Equal("ClientId", ex.ParamName)); 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 (47)

OpenIdConnect\OpenIdConnectEventTests_Handler.cs (47)

OpenIdConnect\OpenIdConnectTests.cs (9)

298Assert.Equal("Cannot redirect to the end session endpoint, the configuration may be missing or invalid.", exception.Message); 444Assert.Equal("https://authority.com", options.Authority); 449Assert.Equal("https://localhost:5000", options.CorrelationCookie.Domain); // Can set nested properties on cookie 450Assert.Equal("CookieName", options.CorrelationCookie.Name); 477Assert.Equal("https://localhost:5000", options.CorrelationCookie.Domain); 481Assert.Equal(".AspNetCore.Correlation.", options.CorrelationCookie.Name); 484Assert.Equal(OpenIdConnectDefaults.CookieNoncePrefix, options.NonceCookie.Name); 562Assert.Equal("client-id", options.ClientId); 563Assert.Equal("overwritten-client-secret", options.ClientSecret);

OpenIdConnect\UniqueJsonKeyClaimActionTests.cs (4)

24Assert.Equal("claimType", claim.Type); 25Assert.Equal("value", claim.Value); 41Assert.Equal("claimType", claims.First().Type); 42Assert.Equal("value", claims.First().Value);

PolicyTests.cs (8)

SecureDataFormatTests.cs (2)

31Assert.Equal(input, result); 45Assert.Equal(input, result);

SharedAuthenticationTests.cs (1)

546Assert.Equal(DisplayName, scheme.DisplayName);

TicketSerializerTests.cs (13)

27Assert.Equal("bye", readTicket.Properties.RedirectUri); 28Assert.Equal("Hello", readTicket.AuthenticationScheme); 49Assert.Equal("misc", readTicket.Principal.Identity.AuthenticationType); 72Assert.Equal("misc", readTicket.Principal.Identity.AuthenticationType); 76Assert.Equal("actor", identity.Actor.AuthenticationType); 107Assert.Equal("misc", readTicket.Principal.Identity.AuthenticationType); 111Assert.Equal("type", claim.Type); 112Assert.Equal("value", claim.Value); 113Assert.Equal("valueType", claim.ValueType); 114Assert.Equal("issuer", claim.Issuer); 115Assert.Equal("original-issuer", claim.OriginalIssuer); 118Assert.Equal("property-value", property1); 121Assert.Equal(string.Empty, property2);

TokenExtensionTests.cs (10)

TwitterTests.cs (19)

WsFederation\WsFederationTest.cs (21)

36Assert.Equal("WsFederationHandler", scheme.HandlerType.Name); 37Assert.Equal(WsFederationDefaults.AuthenticationScheme, scheme.DisplayName); 66Assert.Equal("Provide MetadataAddress, Configuration, or ConfigurationManager to WsFederationOptions", exception.Message); 76Assert.Equal("https://login.windows.net/4afbc689-805b-48cf-a24c-d4aa3248a248/wsfed", response.Headers.Location.GetLeftPart(System.UriPartial.Path)); 79Assert.Equal("http://Automation1", queryItems["wtrealm"]); 81Assert.Equal(httpClient.BaseAddress + "signin-wsfed", queryItems["wreply"]); 82Assert.Equal("wsignin1.0", queryItems["wa"]); 92Assert.Equal("https://login.windows.net/4afbc689-805b-48cf-a24c-d4aa3248a248/wsfed", response.Headers.Location.GetLeftPart(System.UriPartial.Path)); 95Assert.Equal("http://Automation1", queryItems["wtrealm"]); 97Assert.Equal(httpClient.BaseAddress + "signin-wsfed", queryItems["wreply"]); 98Assert.Equal("wsignin1.0", queryItems["wa"]); 108Assert.Equal("https://login.windows.net/4afbc689-805b-48cf-a24c-d4aa3248a248/wsfed", response.Headers.Location.GetLeftPart(System.UriPartial.Path)); 111Assert.Equal("http://Automation1", queryItems["wtrealm"]); 113Assert.Equal(httpClient.BaseAddress + "premapped-challenge/signin-wsfed", queryItems["wreply"]); 114Assert.Equal("wsignin1.0", queryItems["wa"]); 138Assert.Equal(WsFederationDefaults.AuthenticationScheme, await response.Content.ReadAsStringAsync()); 165Assert.Equal(WsFederationDefaults.AuthenticationScheme, await response.Content.ReadAsStringAsync()); 183Assert.Equal("AuthenticationFailed", await response.Content.ReadAsStringAsync()); 195Assert.Equal(".AspNetCore.Cookies=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; samesite=lax; httponly", cookie); 196Assert.Equal("OnRemoteSignOut", response.Headers.GetValues("EventHeader").Single()); 197Assert.Equal("", await response.Content.ReadAsStringAsync());

WsFederation\WsFederationTest_Handler.cs (21)

34Assert.Equal("WsFederationHandler", scheme.HandlerType.Name); 35Assert.Equal(WsFederationDefaults.AuthenticationScheme, scheme.DisplayName); 64Assert.Equal("Provide MetadataAddress, Configuration, or ConfigurationManager to WsFederationOptions", exception.Message); 74Assert.Equal("https://login.windows.net/4afbc689-805b-48cf-a24c-d4aa3248a248/wsfed", response.Headers.Location.GetLeftPart(System.UriPartial.Path)); 77Assert.Equal("http://Automation1", queryItems["wtrealm"]); 79Assert.Equal(httpClient.BaseAddress + "signin-wsfed", queryItems["wreply"]); 80Assert.Equal("wsignin1.0", queryItems["wa"]); 90Assert.Equal("https://login.windows.net/4afbc689-805b-48cf-a24c-d4aa3248a248/wsfed", response.Headers.Location.GetLeftPart(System.UriPartial.Path)); 93Assert.Equal("http://Automation1", queryItems["wtrealm"]); 95Assert.Equal(httpClient.BaseAddress + "signin-wsfed", queryItems["wreply"]); 96Assert.Equal("wsignin1.0", queryItems["wa"]); 106Assert.Equal("https://login.windows.net/4afbc689-805b-48cf-a24c-d4aa3248a248/wsfed", response.Headers.Location.GetLeftPart(System.UriPartial.Path)); 109Assert.Equal("http://Automation1", queryItems["wtrealm"]); 111Assert.Equal(httpClient.BaseAddress + "premapped-challenge/signin-wsfed", queryItems["wreply"]); 112Assert.Equal("wsignin1.0", queryItems["wa"]); 136Assert.Equal(WsFederationDefaults.AuthenticationScheme, await response.Content.ReadAsStringAsync()); 163Assert.Equal(WsFederationDefaults.AuthenticationScheme, await response.Content.ReadAsStringAsync()); 181Assert.Equal("AuthenticationFailed", await response.Content.ReadAsStringAsync()); 193Assert.Equal(".AspNetCore.Cookies=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; samesite=lax; httponly", cookie); 194Assert.Equal("OnRemoteSignOut", response.Headers.GetValues("EventHeader").Single()); 195Assert.Equal("", await response.Content.ReadAsStringAsync());

AssertionRequirementsTests.cs (1)

20Assert.Equal("Handler assertion should evaluate to true.", formattedValue);

AuthorizationAppBuilderExtensionsTests.cs (1)

58Assert.Equal(

AuthorizationEndpointConventionBuilderExtensionsTests.cs (1)

66Assert.Equal("policy", authMetadata.Policy);

ClaimsAuthorizationRequirementTests.cs (3)

25Assert.Equal("ClaimsAuthorizationRequirement:Claim.Type=Custom and Claim.Value is one of the following values: (CustomValue1|CustomValue2)", formattedValue); 38Assert.Equal("ClaimsAuthorizationRequirement:Claim.Type=Custom", formattedValue); 51Assert.Equal("ClaimsAuthorizationRequirement:Claim.Type=Custom", formattedValue);

DefaultAuthorizationServiceTests.cs (7)

192Assert.Equal("1", first.Message); 195Assert.Equal("3", second.Message); 341Assert.Equal("No policy found: BogusPolicy.", exception.Message); 1192Assert.Equal("UserAuthorizationFailed", eventId.Name); 1195Assert.Equal("Authorization failed. These requirements were not met:" + Environment.NewLine + "LogRequirement" + Environment.NewLine + "LogRequirement", message); 1225Assert.Equal("UserAuthorizationFailed", eventId.Name); 1228Assert.Equal("Authorization failed. Fail() was explicitly called.", message);

DenyAnonymousAuthorizationRequirementTests.cs (1)

25Assert.Equal("DenyAnonymousAuthorizationRequirement: Requires an authenticated user.", formattedValue);

MetadataTest.cs (2)

20Assert.Equal("Authorize", value); 35Assert.Equal("Authorize Policy: Name, Roles: Role1, AuthenticationSchemes: Scheme1", value);

NameAuthorizationRequirementTests.cs (1)

25Assert.Equal("NameAuthorizationRequirement:Requires a user identity with Name equal to Custom", formattedValue);

OperationAuthorizationRequirementTests.cs (1)

28Assert.Equal("OperationAuthorizationRequirement:Name=Custom", formattedValue);

RolesAuthorizationRequirementTests.cs (2)

25Assert.Equal("RolesAuthorizationRequirement:User.IsInRole must be true for one of the following roles: (Custom1|Custom2)", formattedValue); 38Assert.Equal("RolesAuthorizationRequirement:User.IsInRole must be true for one of the following roles: (Custom1)", formattedValue);

TransformTest.cs (18)

32Assert.Equal("add", depsElement.Name); 33Assert.Equal("DOTNET_ADDITIONAL_DEPS", depsElement.Attributes["name"].Value); 34Assert.Equal($@"{XdtExtensionPath}\additionalDeps\;{XdtExtensionPath}\additionalDeps\Microsoft.AspNetCore.AzureAppServices.HostingStartup\;" + 39Assert.Equal("add", sharedStoreElement.Name); 40Assert.Equal("DOTNET_SHARED_STORE", sharedStoreElement.Attributes["name"].Value); 41Assert.Equal($@"{XdtExtensionPath}\store", sharedStoreElement.Attributes["value"].Value); 44Assert.Equal("add", startupAssembliesElement.Name); 45Assert.Equal("ASPNETCORE_HOSTINGSTARTUPASSEMBLIES", startupAssembliesElement.Attributes["name"].Value); 46Assert.Equal("Microsoft.AspNetCore.AzureAppServices.HostingStartup", startupAssembliesElement.Attributes["value"].Value); 62Assert.Equal("add", depsElement.Name); 63Assert.Equal("DOTNET_ADDITIONAL_DEPS", depsElement.Attributes["name"].Value); 64Assert.Equal(@"ExistingValue1;" + 70Assert.Equal("add", sharedStoreElement.Name); 71Assert.Equal("DOTNET_SHARED_STORE", sharedStoreElement.Attributes["name"].Value); 72Assert.Equal($@"ExistingValue3;{XdtExtensionPath}\store", sharedStoreElement.Attributes["value"].Value); 75Assert.Equal("add", startupAssembliesElement.Name); 76Assert.Equal("ASPNETCORE_HOSTINGSTARTUPASSEMBLIES", startupAssembliesElement.Attributes["name"].Value); 77Assert.Equal("ExistingValue2;Microsoft.AspNetCore.AzureAppServices.HostingStartup", startupAssembliesElement.Attributes["value"].Value);

Verifiers\CodeFixVerifier.cs (1)

129Assert.Equal(newSource, actual);

AuthorizeRouteViewTest.cs (1)

117Assert.Equal(resource, call.resource.ToString());

AuthorizeViewTest.cs (13)

src\Components\Shared\test\AssertFrame.cs (7)

21Assert.Equal(textContent, frame.TextContent); 29Assert.Equal(markupContent, frame.MarkupContent); 37Assert.Equal(elementName, frame.ElementName); 45Assert.Equal(attributeName, frame.AttributeName); 87Assert.Equal(typeName, frame.ComponentType.FullName); 154Assert.Equal(eventType, frame.NamedEventType); 155Assert.Equal(assignedName, frame.NamedEventAssignedName);

Assets\ImportMapDefinitionTest.cs (5)

37Assert.Equal(expectedJson, importMapDefinition.ToJson().Replace("\r\n", "\n")); 66Assert.Equal(expectedJson, importMapDefinition.ToJson().Replace("\r\n", "\n")); 96Assert.Equal(expectedJson, importMapDefinition.ToJson().Replace("\r\n", "\n")); 128Assert.Equal(expectedJson, importMapDefinition.ToJson().Replace("\r\n", "\n")); 199Assert.Equal(expectedImportMap, combinedImportMap.ToJson().Replace("\r\n", "\n"));

Binding\FormDataMapperTests.cs (9)

1950element => Assert.Equal("file-1.txt", element.FileName), 1951element => Assert.Equal("file-2.txt", element.FileName), 1952element => Assert.Equal("file-3.txt", element.FileName) 2027Assert.Equal("file", browserFile.Name); 2031Assert.Equal(expectedString, Encoding.UTF8.GetString(buffer, 0, buffer.Length)); 2062Assert.Equal("file", browserFile1.Name); 2066Assert.Equal(expectedString1, Encoding.UTF8.GetString(buffer1, 0, buffer1.Length)); 2069Assert.Equal("file", browserFile2.Name); 2073Assert.Equal(expectedString1, Encoding.UTF8.GetString(buffer2, 0, buffer2.Length));

Buffering\BufferedTextWriterTest.cs (3)

28Assert.Equal("xMy stringbcd", underlying.ToString()); 62Assert.Equal("a", underlying.FlushedOutput); 69Assert.Equal("abc", underlying.FlushedOutput);

Buffering\TextChunkListBuilderTest.cs (3)

26Assert.Equal("Item1Item2Item3", writer1.ToString()); 32Assert.Equal("", writer2.ToString()); 39Assert.Equal("Item4", writer3.ToString());

Buffering\TextChunkPageTest.cs (1)

36Assert.Equal("Item1Item2Item3", writer.ToString());

Buffering\TextChunkTest.cs (4)

18Assert.Equal("string value", _writer.ToString()); 26Assert.Equal("x", _writer.ToString()); 40Assert.Equal("bcd", _writer.ToString()); 48Assert.Equal("123456", _writer.ToString());

Builder\RazorComponentsEndpointConventionBuilderExtensionsTest.cs (7)

78Assert.Equal("named.css", list[0].Url); 99Assert.Equal("default.css", list[0].Url); 121Assert.Equal("default.css", list[0].Url); 143Assert.Equal("default.css", list[0].Url); 166Assert.Equal("named.css", list[0].Url); 192Assert.Equal("named.css", list[0].Url); 243Assert.Equal(frameworkEndpoint, ((RouteEndpoint)webJSEndpoint).RoutePattern.RawText);

EndpointHtmlRendererTest.cs (81)

HotReloadServiceTests.cs (9)

ImportMapTest.cs (13)

69Assert.Equal("script", frames.Array[0].ElementName); 71Assert.Equal("type", frames.Array[1].AttributeName); 73Assert.Equal("nonce", frames.Array[2].AttributeName); 76Assert.Equal(importMapDefinition.ToJson(), frames.Array[3].TextContent); 116Assert.Equal("script", frames.Array[0].ElementName); 118Assert.Equal("type", frames.Array[1].AttributeName); 121Assert.Equal(importMapDefinition.ToJson(), frames.Array[2].TextContent); 181Assert.Equal("script", frames.Array[0].ElementName); 183Assert.Equal("type", frames.Array[1].AttributeName); 186Assert.Equal(otherImportMapDefinition.ToJson(), frames.Array[2].TextContent); 240Assert.Equal("script", frames.Array[0].ElementName); 242Assert.Equal("type", frames.Array[1].AttributeName); 245Assert.Equal(importMapDefinition.ToJson(), frames.Array[2].TextContent);

RazorComponentEndpointFactoryTest.cs (4)

35Assert.Equal("/ (App)", endpoint.DisplayName); 38Assert.Equal("/", routeEndpoint.RoutePattern.RawText); 49method => Assert.Equal("GET", method), 50method => Assert.Equal("POST", method)

RazorComponentResultTest.cs (13)

64Assert.Equal("<h1>Hello from SimpleComponent</h1>", GetStringContent(responseBody)); 65Assert.Equal("text/html; charset=utf-8", httpContext.Response.ContentType); 86Assert.Equal("<h1>Hello from SimpleComponent</h1>", GetStringContent(responseBody)); 87Assert.Equal("application/test-content-type", httpContext.Response.ContentType); 105Assert.Equal( 117Assert.Equal( 136Assert.Equal( 144Assert.Equal( 168Assert.Equal( 176Assert.Equal( 203Assert.Equal( 220Assert.Equal($"[TestParentLayout with content: [TestLayout with content: Page\n]\n]\n", GetStringContent(responseBody)); 233Assert.Equal("https://test/somewhere/else", httpContext.Response.Headers.Location);

TypeNameHashTest.cs (1)

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

EditContextDataAnnotationsExtensionsTest.cs (1)

18Assert.Equal("editContext", ex.ParamName);

EditContextTest.cs (2)

12Assert.Equal("model", ex.ParamName); 33Assert.Equal("testFieldName", fieldIdentifier.FieldName);

ExpressionFormatterTest.cs (22)

FieldIdentifierTest.cs (19)

ReverseStringBuilderTest.cs (7)

19Assert.Equal(string.Empty, result); 33Assert.Equal(string.Empty, result); 52Assert.Equal("Hello, world!", result); 72Assert.Equal("Hello, 123 worlds!", result); 91Assert.Equal("Hello, world!", result); 112Assert.Equal(expected, result); 142Assert.Equal(expected, actual);

src\Components\Shared\test\AssertFrame.cs (7)

21Assert.Equal(textContent, frame.TextContent); 29Assert.Equal(markupContent, frame.MarkupContent); 37Assert.Equal(elementName, frame.ElementName); 45Assert.Equal(attributeName, frame.AttributeName); 87Assert.Equal(typeName, frame.ComponentType.FullName); 154Assert.Equal(eventType, frame.NamedEventType); 155Assert.Equal(assignedName, frame.NamedEventAssignedName);

ValidationMessageStoreTest.cs (1)

12Assert.Equal("editContext", ex.ParamName);

Verifiers\CodeFixVerifier.cs (1)

129Assert.Equal(newSource, actual);

Circuits\CircuitHostTest.cs (7)

433Assert.Equal(expectedMessage, component.Message); 459Assert.Equal(expectedMessage, component.Message); 486Assert.Equal(expectedMessage, component.Message); 520Assert.Equal(expectedMessage, component.Message); 524Assert.Equal("Cannot update components with mismatching types.", exception.Message); 557Assert.Equal(expectedMessage, component.Message); 561Assert.Equal("Cannot update components with mismatching keys.", exception.Message);

Circuits\CircuitIdFactoryTest.cs (2)

52Assert.Equal(id.Secret, parsed.Secret); 53Assert.Equal(id.Id, parsed.Id);

Circuits\RemoteJSDataStreamTest.cs (1)

308Assert.Equal("Blazor._internal.sendJSDataStream", identifier);

Circuits\RemoteJSRuntimeTest.cs (3)

34Assert.Equal("Exceeded the maximum byte array transfer limit for a call. (Parameter 'data')", ex.Message); 74Assert.Equal("Exceeded the maximum byte array transfer limit for a call. (Parameter 'data')", ex.Message); 86Assert.Equal("Exceeded the maximum byte array transfer limit for a call. (Parameter 'data')", ex.Message);

Circuits\RemoteRendererTest.cs (1)

615Assert.Equal($"No root component exists with SSR component ID 1.", ex.Message);

Circuits\RenderBatchWriterTest.cs (1)

344Assert.Equal(expectedString, stringTableEntries[indexIntoStringTable]);

Circuits\RevalidatingServerAuthenticationStateProviderTest.cs (5)

51Assert.Equal("test user", (await provider.GetAuthenticationStateAsync()).User.Identity.Name); 112call => Assert.Equal("test user", call.AuthenticationState.User.Identity.Name)); 124call => Assert.Equal("different user", call.AuthenticationState.User.Identity.Name)); 173Assert.Equal("different user", (await provider.GetAuthenticationStateAsync()).User.Identity.Name); 178call => Assert.Equal("different user", call.AuthenticationState.User.Identity.Name));

DependencyInjection\ComponentServiceCollectionExtensionsTest.cs (3)

25Assert.Equal(BlazorPackHubProtocol.ProtocolName, protocol); 46Assert.Equal(BlazorPackHubProtocol.ProtocolName, protocol); 73Assert.Equal(BlazorPackHubProtocol.ProtocolName, protocol);

ElementReferenceJsonConverterTest.cs (5)

36Assert.Equal(expected, json); 53Assert.Equal(id, elementReference.Id); 73Assert.Equal(id, elementReference.Id); 92Assert.Equal("Unexpected JSON property 'id'.", ex.Message); 111Assert.Equal("__internalId is required.", ex.Message);

ProtectedBrowserStorageTest.cs (11)

35Assert.Equal("testStore.setItem", invocation.Identifier); 38arg => Assert.Equal( 61Assert.Equal("testStore.setItem", invocation.Identifier); 64arg => Assert.Equal( 85Assert.Equal("testStore.setItem", invocation.Identifier); 88arg => Assert.Equal( 112Assert.Equal("Hello", result.Value.StringProperty); 116Assert.Equal("testStore.getItem", invocation.Identifier); 139Assert.Equal("Hello", result.Value.StringProperty); 143Assert.Equal("testStore.getItem", invocation.Identifier); 252Assert.Equal("testStore.removeItem", invocation.Identifier);

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

BindConverterTest.cs (8)

112Assert.Equal(expected, actual); 140Assert.Equal(expected, actual); 168Assert.Equal(expected, actual); 182Assert.Equal(expected, actual); 196Assert.Equal(expected, actual); 210Assert.Equal(expected, actual); 224Assert.Equal(expected, actual); 238Assert.Equal(expected, actual);

CascadingParameterTest.cs (3)

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

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)

49Assert.Equal($"Cannot provide a value for property '{nameof(HasInjectableProperty.MyService)}' " + 62Assert.Equal($"Cannot provide a value for property '{nameof(HasInjectableProperty.MyService)}' " + 78Assert.Equal($"Cannot provide a value for property '{nameof(HasKeyedInjectableProperty.MyService)}' " +

EventCallbackFactoryBinderExtensionsTest.cs (3)

113Assert.Equal(expectedValue, value); 594Assert.Equal(expectedValue.Message, value.Message); 607Assert.Equal(

NavigationManagerTest.cs (12)

27Assert.Equal(expectedResult, actualResult); 45Assert.Equal(expectedResult, actualResult); 61Assert.Equal( 79Assert.Equal( 97Assert.Equal(expectedUri, actualUri); 111Assert.Equal(expectedUri, actualUri); 129Assert.Equal(expectedUri, actualUri); 163Assert.Equal(expectedUri, actualUri); 180Assert.Equal(expectedUri, actualUri); 702Assert.Equal(exceptionMessage, ex.Message); 733Assert.Equal(exceptionMessage, ex.Message); 759Assert.Equal(exceptionMessage, ex.Message);

ParameterViewTest.Assignment.cs (28)

31Assert.Equal("Hello", target.StringProp); 108Assert.Equal("Existing value", target.StringProp); 126Assert.Equal("hi", target.Cascading); 145Assert.Equal("bye", target.Cascading); 162Assert.Equal( 184Assert.Equal( 206Assert.Equal( 224Assert.Equal("Test", target.GetCascadingValue()); 241Assert.Equal( 260Assert.Equal( 279Assert.Equal( 299Assert.Equal("Hello", target.Parameter); 316Assert.Equal("Non-cascading", target.Parameter); 353Assert.Equal("hi", target.StringProp); 358Assert.Equal("test1", kvp.Key); 363Assert.Equal("test2", kvp.Key); 384Assert.Equal( 408Assert.Equal( 427Assert.Equal( 448Assert.Equal( 475Assert.Equal(nameof(HasCaptureUnmatchedValuesPropertyAndCascadingParameter.Cascading), kvp.Key); 478Assert.Equal("bye", target.Cascading); 494Assert.Equal( 516Assert.Equal( 537Assert.Equal( 555Assert.Equal( 578Assert.Equal( 625Assert.Equal("Hello", target.StringProp);

ParameterViewTest.cs (5)

142Assert.Equal("hello", value); 287Assert.Equal("entry 1", entry.Key); 292Assert.Equal("entry 2", entry.Key); 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); 575Assert.Equal(expectedName, parameter.Name);

RendererTest.cs (16)

720Assert.Equal("Error", exception.Message); 2095Assert.Equal("String that will change", childComponentInstance.StringProperty); 2104Assert.Equal("String that did change", childComponentInstance.StringProperty); 2925Assert.Equal("The render handle is not yet assigned.", ex.Message); 3141Assert.Equal("hello", value); 3180Assert.Equal("hello", value); 3220Assert.Equal("hello", value); 3260Assert.Equal("hello", value); 4352Assert.Equal("new property value", component.BoundString); 4404Assert.Equal(newPropertyValue, component.BoundString); 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); 4830Assert.Equal($"The renderer does not have a component with ID {rootComponentId}.", ex.Message); 4856Assert.Equal($"The renderer does not have a component with ID {rootComponentId}.", ex.Message); 4885Assert.Equal("The specified component is not a root component", ex.Message); 5086Assert.Equal("Some message", resolvedComponent.Message); 5111Assert.Equal("Some message", resolvedComponent.Message);

Rendering\RendererSynchronizationContextTest.cs (1)

790Assert.Equal(expected, actual);

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); 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); 2230Assert.Equal("eventType", ex.ParamName); 2245Assert.Equal("assignedName", ex.ParamName); 2260Assert.Equal("assignedName", ex.ParamName); 2276Assert.Equal($"Attributes may only be added immediately after frames of type {RenderTreeFrameType.Element} or {RenderTreeFrameType.Component}", ex.Message);

RenderTreeDiffBuilderTest.cs (25)

ResourceAssetCollectionTest.cs (1)

21Assert.Equal("image1.jpg", collectionAsReadOnlyList[0].Url);

RouteViewTest.cs (1)

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

Routing\QueryParameterValueSupplierTest.cs (4)

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

Routing\RouterTest.cs (4)

145Assert.Equal(expected, cancelled); 199Assert.Equal($"Rendering route matching {typeof(MultiSegmentRouteComponent)}", renderedFrame.TextContent); 245Assert.Equal("Custom content", renderedFrame.TextContent); 265Assert.Equal("Not found", renderedFrame.TextContent);

Routing\RouteTableFactoryTests.cs (1)

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

src\Components\Shared\test\AssertFrame.cs (7)

21Assert.Equal(textContent, frame.TextContent); 29Assert.Equal(markupContent, frame.MarkupContent); 37Assert.Equal(elementName, frame.ElementName); 45Assert.Equal(attributeName, frame.AttributeName); 87Assert.Equal(typeName, frame.ComponentType.FullName); 154Assert.Equal(eventType, frame.NamedEventType); 155Assert.Equal(assignedName, frame.NamedEventAssignedName);

StackObjectPoolTest.cs (2)

100Assert.Equal("There are no outstanding instances to return.", ex.Message); 116Assert.Equal("Attempting to return wrong pooled instance. Get/Return calls must form a stack.", ex.Message);

Forms\BrowserFileTest.cs (1)

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

Forms\HtmlFieldPrefixTest.cs (5)

22Assert.Equal("person.Children[0].BillingAddress.City", prefix.GetFieldName(valueExpression)); 40Assert.Equal("person.Children[0].Children[1].BillingAddress.City", prefix.GetFieldName(valueExpression)); 56Assert.Equal("person.BillingAddress.City", prefix.GetFieldName(valueExpression)); 72Assert.Equal("person.Nicknames[0]", prefix.GetFieldName(valueExpression)); 90Assert.Equal("person.Children[0].Nicknames[1]", prefix.GetFieldName(valueExpression));

Forms\InputBaseTest.cs (17)

Forms\InputFileChangeEventArgsTest.cs (1)

63Assert.Equal($"The maximum number of files accepted is 1, but 2 were supplied.", ex.Message);

Forms\InputRadioTest.cs (1)

58Assert.All(inputRadioComponents, inputRadio => Assert.Equal(groupName, inputRadio.GroupName));

Forms\Mapping\FormMappingContextTest.cs (2)

14Assert.Equal("", context.MappingScopeName); 21Assert.Equal("name", context.MappingScopeName);

Forms\Mapping\FormMappingScopeTest.cs (5)

44Assert.Equal("named-context", capturedContext.MappingScopeName); 74Assert.Equal("child-context", capturedContext.MappingScopeName); 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 (19)

src\Components\Shared\test\AssertFrame.cs (7)

21Assert.Equal(textContent, frame.TextContent); 29Assert.Equal(markupContent, frame.MarkupContent); 37Assert.Equal(elementName, frame.ElementName); 45Assert.Equal(attributeName, frame.AttributeName); 87Assert.Equal(typeName, frame.ComponentType.FullName); 154Assert.Equal(eventType, frame.NamedEventType); 155Assert.Equal(assignedName, frame.NamedEventAssignedName);

Virtualization\VirtualizeTest.cs (1)

99Assert.Equal("Thrown from items provider.", ex.Message);

WebEventData\ClipboardEventArgsReaderTest.cs (1)

24Assert.Equal(args.Type, result.Type);

WebEventData\DragEventArgsReaderTest.cs (4)

64Assert.Equal(expected.DropEffect, actual.DropEffect); 65Assert.Equal(expected.EffectAllowed, actual.EffectAllowed); 76Assert.Equal(expected[i].Kind, actual[i].Kind); 77Assert.Equal(expected[i].Type, actual[i].Type);

WebEventData\ErrorEventArgsReaderTest.cs (3)

30Assert.Equal(args.Filename, result.Filename); 32Assert.Equal(args.Message, result.Message); 33Assert.Equal(args.Type, result.Type);

WebEventData\FocusEventArgsReaderTest.cs (1)

25Assert.Equal(args.Type, result.Type);

WebEventData\KeyboardEventArgsReaderTest.cs (3)

35Assert.Equal(args.Code, result.Code); 37Assert.Equal(args.Key, result.Key); 42Assert.Equal(args.Type, result.Type);

WebEventData\MouseEventArgsReaderTest.cs (1)

63Assert.Equal(expected.Type, actual.Type);

WebEventData\PointerEventArgsReaderTest.cs (1)

49Assert.Equal(args.PointerType, result.PointerType);

WebEventData\ProgressEventArgsReaderTest.cs (1)

30Assert.Equal(args.Type, result.Type);

WebEventData\TouchEventArgsReaderTest.cs (1)

83Assert.Equal(args.Type, result.Type);

WebEventData\WebEventDescriptorReaderTest.cs (2)

32Assert.Equal(args.EventName, result.EventName); 60Assert.Equal(args.EventName, result.EventName);

ContentEncodingNegotiatorTests.cs (16)

28Assert.Equal(expectedPath, httpContext.Request.Path); 30Assert.Equal(expectedEncoding, selectedEncoding); 50Assert.Equal(expectedPath, httpContext.Request.Path); 71Assert.Equal(expectedPath, httpContext.Request.Path); 73Assert.Equal(expectedEncoding, selectedEncoding); 94Assert.Equal(expectedPath, httpContext.Request.Path); 96Assert.Equal(expectedEncoding, selectedEncoding); 117Assert.Equal(expectedPath, httpContext.Request.Path); 119Assert.Equal(expectedEncoding, selectedEncoding); 140Assert.Equal(expectedPath, httpContext.Request.Path); 142Assert.Equal(expectedEncoding, selectedEncoding); 163Assert.Equal(expectedPath, httpContext.Request.Path); 165Assert.Equal(expectedEncoding, selectedEncoding); 185Assert.Equal(expectedPath, httpContext.Request.Path); 206Assert.Equal(expectedPath, httpContext.Request.Path); 208Assert.Equal(expectedEncoding, selectedEncoding);

Hosting\WebAssemblyCultureProviderTest.cs (1)

41Assert.Equal("Blazor detected a change in the application's culture that is not supported with the current project configuration. " +

Hosting\WebAssemblyHostBuilderTest.cs (4)

32Assert.Equal("value", host.Configuration["key"]); 149Assert.Equal("https://www.example.com/", navigationManager.BaseUri); 150Assert.Equal("https://www.example.com/awesome-part-that-will-be-truncated-in-tests/cool", navigationManager.Uri); 203Assert.Equal("value", configuration["key"]);

Hosting\WebAssemblyHostConfigurationTest.cs (22)

PullFromJSDataStreamTest.cs (4)

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); 123Assert.Equal("Blazor._internal.getJSDataStreamChunk", identifier);

Infrastructure\AssertHelpers.cs (2)

15Assert.Equal("Blazor._internal.attachWebRendererInterop", args[1].GetString()); 24Assert.Equal(selector, args[1].GetString());

StaticContentProviderTests.cs (3)

38Assert.Equal("OK", statusMessage); 39Assert.Equal("this is css", contentString); 41Assert.Equal("text/css", contentTypeValue);

WebViewManagerTests.cs (1)

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

ConcurrencyLimiterEventSourceTests.cs (1)

18Assert.Equal("Microsoft.AspNetCore.ConcurrencyLimiter", eventSource.Name);

CookieChunkingTests.cs (4)

20Assert.Equal("TestCookie=" + testString + "; path=/", values[0]); 43Assert.Equal($"TestCookie={testString}; expires={now.AddMinutes(5).ToString("R")}; max-age=300; domain=foo.com; path=/bar; secure; samesite=strict; httponly", values[0]); 163Assert.Equal(testString, result); 204Assert.Equal(testString, result);

CookieConsentTests.cs (13)

30Assert.Equal("Test=Value; path=/", httpContext.Response.Headers.SetCookie); 94Assert.Equal("Test=Value; path=/", httpContext.Response.Headers.SetCookie); 113Assert.Equal("Test=Value; path=/", httpContext.Response.Headers.SetCookie); 166Assert.Equal("Test=Value; path=/", httpContext.Response.Headers.SetCookie); 242Assert.Equal(".AspNet.Consent", context.CookieName); 243Assert.Equal("yes", context.CookieValue); 305Assert.Equal("Test=Value; path=/", httpContext.Response.Headers.SetCookie); 337Assert.Equal("Started.Granted.", await reader.ReadToEndAsync()); 421Assert.Equal(".AspNet.Consent", context.CookieName); 488Assert.Equal("Started.Withdrawn.", await reader.ReadToEndAsync()); 489Assert.Equal("Test=Value1; path=/", httpContext.Response.Headers.SetCookie); 600Assert.Equal(".AspNet.Consent", context.CookieName); 601Assert.Equal("yes", context.CookieValue);

CookiePolicyTests.cs (51)

CorsEndpointConventionBuilderExtensionsTests.cs (1)

29Assert.Equal("TestPolicyName", metadata.PolicyName);

CorsMiddlewareTests.cs (31)

CorsPolicyBuilderTests.cs (7)

345Assert.Equal(Resources.InsecureConfiguration, ex.Message); 358Assert.Equal(expected, normalizedOrigin); 371Assert.Equal(origin, normalizedOrigin); 384Assert.Equal("http://www.example.com", normalizedOrigin); 397Assert.Equal("http://www.example.com", normalizedOrigin); 409Assert.Equal(expected, normalizedOrigin); 424Assert.Equal(expected, normalizedOrigin);

CorsPolicyTests.cs (2)

54Assert.Equal( 78Assert.Equal(

CorsResultTests.cs (2)

36Assert.Equal( 60Assert.Equal(

CorsServiceTests.cs (17)

115Assert.Equal("*", result.AllowedOrigin); 131Assert.Equal("*", result.AllowedOrigin); 185Assert.Equal("*", result.AllowedOrigin); 202Assert.Equal("http://example.com", result.AllowedOrigin); 220Assert.Equal("http://example.com", result.AllowedOrigin); 237Assert.Equal("http://example.com", result.AllowedOrigin); 348Assert.Equal("http://example.com", result.AllowedOrigin); 370Assert.Equal("http://example.com", result.AllowedOrigin); 593Assert.Equal("http://example.com", httpContext.Response.Headers["Access-Control-Allow-Origin"]); 633Assert.Equal("true", httpContext.Response.Headers["Access-Control-Allow-Credentials"]); 653Assert.Equal("Origin", httpContext.Response.Headers["Vary"]); 674Assert.Equal("Cookie,Origin", httpContext.Response.Headers["Vary"]); 735Assert.Equal("PUT", httpContext.Response.Headers["Access-Control-Allow-Methods"]); 776Assert.Equal("foo", httpContext.Response.Headers["Access-Control-Allow-Headers"]); 838Assert.Equal("foo,bar", httpContext.Response.Headers[CorsConstants.AccessControlExposeHeaders]); 858Assert.Equal("foo", httpContext.Response.Headers["Access-Control-Expose-Headers"]); 899Assert.Equal("30", httpContext.Response.Headers["Access-Control-Max-Age"]);

Cng\CachedAlgorithmHandlesTests.cs (5)

116Assert.Equal("AES", algorithmHandle.GetAlgorithmName()); 138Assert.Equal(expectedAlgorithmName, algorithmHandle.GetAlgorithmName()); 152Assert.Equal(expectedDigest, Convert.ToBase64String(outputHash)); 169Assert.Equal(expectedAlgorithmName, algorithmHandle.GetAlgorithmName()); 185Assert.Equal(expectedDigest, Convert.ToBase64String(outputHash));

SafeHandles\SecureLocalAllocHandleTests.cs (1)

27Assert.Equal(expected, new string((char*)duplicateHandle.DangerousGetHandle(), 0, expected.Length)); // contents the same data

UnsafeBufferUtilTests.cs (3)

59Assert.Equal(expected, actual); 80Assert.Equal(expected, actual); 100Assert.Equal(expected, actual);

Pbkdf2Tests.cs (1)

206Assert.Equal(expectedDerivedKeyAsBase64, Convert.ToBase64String(derivedKey));

DataProtectionCommonExtensionsTests.cs (3)

117Assert.Equal(Resources.FormatDataProtectionExtensions_NoService(typeof(IDataProtectionProvider).FullName), ex.Message); 268Assert.Equal("AQIDBAU", retVal); 310Assert.Equal("Hello", retVal);

DataProtectionAdvancedExtensionsTests.cs (3)

29Assert.Equal(SampleEncodedString, protectedPayload); 52Assert.Equal(SampleEncodedString, protectedPayload); 92Assert.Equal("this is plaintext", unprotectedPayload);

DataProtectionProviderTests.cs (8)

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

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

Cng\CbcAuthenticatedEncryptorTests.cs (1)

114Assert.Equal("AAAAAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh+36j4yWJOjBgOJxmYDYwhLnYqFxw+9mNh/cudyPrWmJmw4d/dmGaLJLLut2udiAAAAAAAA", retValAsString);

Cng\GcmAuthenticatedEncryptorTests.cs (1)

103Assert.Equal("AAAAAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaG0O2kY0NZtmh2UQtXY5B2jlgnOgAAAAA", retValAsString);

DataProtectionUtilityExtensionsTests.cs (3)

43Assert.Equal(expected, actual); 74Assert.Equal(expected, actual); 102Assert.Equal(expected, actual);

Internal\KeyManagementOptionsPostSetupTest.cs (1)

165Assert.Equal(keyDir, repository.Directory.FullName);

KeyManagement\KeyRingBasedDataProtectorTests.cs (3)

154Assert.Equal(Resources.ProtectionProvider_BadMagicHeader, ex.Message); 172Assert.Equal(Resources.ProtectionProvider_BadMagicHeader, ex.Message); 190Assert.Equal(Resources.ProtectionProvider_BadVersion, ex.Message);

KeyManagement\KeyRingProviderTests.cs (1)

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

KeyManagement\XmlKeyManagerTests.cs (4)

158Assert.Equal("key-3d6d01fd-c0e7-44ae-82dd-013b996b4093", friendlyNameStoredInRepository); 286Assert.Equal("key-3d6d01fd-c0e7-44ae-82dd-013b996b4093", friendlyNameStoredInRepository); 659Assert.Equal("revocation-20150302T0313197573854Z", friendlyNameStoredInRepository); 714Assert.Equal("revocation-a11f35fc-1fed-4bd4-b727-056a63b70932", friendlyNameStoredInRepository);

Managed\ManagedAuthenticatedEncryptorTests.cs (1)

104Assert.Equal("AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh+36j4yWJOjBgOJxmYDYwhLnYqFxw+9mNh/cudyPrWmJmw4d/dmGaLJLLut2udiAAA=", retValAsString);

RegistryPolicyResolverTests.cs (13)

Repositories\FileSystemXmlRepositoryTests.cs (1)

27Assert.Equal(expectedDir, defaultDirInfo.FullName);

SecretAssert.cs (1)

16Assert.Equal(SecretToBase64String(secret1), SecretToBase64String(secret2));

ServiceCollectionTests.cs (1)

97Assert.Equal(keyDir, repository.Directory.FullName);

SP800_108\SP800_108Tests.cs (2)

155Assert.Equal(expectedDerivedSubkeyAsBase64, Convert.ToBase64String(derivedSubkey)); 168Assert.Equal(expectedDerivedSubkeyAsBase64, Convert.ToBase64String(derivedSubkeySegment.AsStandaloneArray()));

TypeForwardingActivatorTests.cs (1)

86Assert.Equal(expected, new MockTypeForwardingActivator().Parse(typeName));

XmlEncryption\CertificateXmlEncryptionTests.cs (1)

51Assert.Equal("http://www.w3.org/2001/04/xmlenc#Element", (string)encryptedXmlInfo.EncryptedElement.Attribute("Type"));

XmlEncryption\EncryptedXmlDecryptorTests.cs (4)

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); 85Assert.Equal("Lorem ipsum", decrypted.Value);

XmlEncryption\XmlEncryptionExtensionsTests.cs (1)

225Assert.Equal(typeof(MyXmlDecryptor).AssemblyQualifiedName, (string)retVal.Attribute(XmlConstants.DecryptorTypeAttributeName));

CertificateManagerTests.cs (11)

HealthCheckEndpointRouteBuilderExtensionsTest.cs (5)

40Assert.Equal( 81Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 82Assert.Equal("Healthy", await response.Content.ReadAsStringAsync()); 126Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 127Assert.Equal("Custom!", await response.Content.ReadAsStringAsync());

HealthCheckMiddlewareSampleTest.cs (7)

31Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 32Assert.Equal("Healthy", await response.Content.ReadAsStringAsync()); 53Assert.Equal("application/json", response.Content.Headers.ContentType.ToString()); 76Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 77Assert.Equal("Healthy", await response.Content.ReadAsStringAsync()); 98Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 99Assert.Equal("Unhealthy", await response.Content.ReadAsStringAsync());

HealthCheckMiddlewareTests.cs (39)

Latency\AddServerTimingHeaderMiddlewareTests.cs (1)

47Assert.Equal($"reqlatency;dur={TimeAdvanceMs}", header[0]);

Latency\ChecpointAcceptanceTests.cs (1)

132Assert.Equal("reqlatency;dur", metricFragments[0]);

Latency\RequestLatencyTelemetryMiddlewareTests.cs (2)

46Assert.Equal(serverName, header[0]); 104Assert.Equal(serverName, header[0]);

Logging\AcceptanceTests.cs (14)

Logging\AcceptanceTests.Mvc.cs (5)

74Assert.Equal(LoggingCategory, logRecord.Category); 109Assert.Equal(LoggingCategory, logRecord.Category); 155Assert.Equal(LoggingCategory, logRecord.Category); 199Assert.Equal(LoggingCategory, logRecord.Category); 240Assert.Equal(LoggingCategory, logRecord.Category);

Logging\AcceptanceTests.Routing.cs (6)

74Assert.Equal(LoggingCategory, logRecord.Category); 139Assert.Equal(expectedHttpPath, state[HttpLoggingTagNames.Path]); 177Assert.Equal(httpRoute, state[HttpLoggingTagNames.Path]); 181Assert.Equal(controller, state["controller"]); 186Assert.Equal(action, state["action"]); 195Assert.Equal(param, state["param"]);

Logging\HeaderNormalizerTests.cs (2)

23Assert.Equal(Prefix + "accept-charset", headers[0]); 24Assert.Equal(Prefix + "content-type", headers[1]);

Logging\HeaderReaderTests.cs (1)

62Assert.Equal(NormalizedHeader, redacted.Key);

Logging\HttpLoggingServiceExtensionsTests.cs (6)

81Assert.Equal("Taxonomy1", options.RouteParameterDataClasses["one"].TaxonomyName); 82Assert.Equal("Value1", options.RouteParameterDataClasses["one"].Value); 85Assert.Equal("Taxonomy2", options.RequestHeadersDataClasses["two"].TaxonomyName); 86Assert.Equal("Value2", options.RequestHeadersDataClasses["two"].Value); 89Assert.Equal("Taxonomy3", options.ResponseHeadersDataClasses["three"].TaxonomyName); 90Assert.Equal("Value3", options.ResponseHeadersDataClasses["three"].Value);

Logging\LoggingOptionsValidationTests.cs (1)

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

Logging\RequestHeadersEnricherTests.cs (5)

105Assert.Equal($"redacted:{RequestId}", enrichedState[NormalizedHeaderKey1].ToString()); 106Assert.Equal(TestValue, enrichedState[NormalizedHeaderKey4].ToString()); 135Assert.Equal($"REDACTED:{RequestId}", enrichedState[NormalizedHeaderKey1].ToString()); 161Assert.Equal(RequestId, enrichedState[NormalizedHeaderKey1].ToString()); 187Assert.Equal(RequestId, enrichedState[NormalizedHeaderKey1].ToString());

DeveloperExceptionPageMiddlewareTest.cs (17)

71Assert.Equal("Test exception", originalExceptionMessage); 127Assert.Equal("Test exception", originalExceptionMessage); 129Assert.Equal("1", routeValue); 130Assert.Equal("/test/1", path); 186Assert.Equal("Test exception", originalExceptionMessage); 188Assert.Equal("1", routeValue); 189Assert.Equal("/test/1", path); 261Assert.Equal("text/html", response.Content.Headers.ContentType.MediaType); 296Assert.Equal("text/plain", response.Content.Headers.ContentType.MediaType); 297Assert.Equal("utf-8", response.Content.Headers.ContentType.CharSet); 403Assert.Equal("Test exception", await response.Content.ReadAsStringAsync()); 439Assert.Equal("Bad format exception!", await response.Content.ReadAsStringAsync()); 477Assert.Equal("An error occurred", await response.Content.ReadAsStringAsync()); 618Assert.Equal("System.Exception", (string)m.Tags["error.type"]); 627Assert.Equal(exceptionName, (string)measurement.Tags["error.type"]); 628Assert.Equal(result, measurement.Tags["aspnetcore.diagnostics.exception.result"].ToString()); 635Assert.Equal(handler, (string)measurement.Tags["aspnetcore.diagnostics.handler.type"]);

ExceptionHandlerMiddlewareTest.cs (9)

77Assert.Equal("Test exception", originalExceptionMessage); 223Assert.Equal(DiagnosticsMetrics.MeterName, meter.Name); 350Assert.Equal("System.Exception", (string)m.Tags["error.type"]); 351Assert.Equal("/path", (string)m.Tags["http.route"]); 417Assert.Equal("System.Exception", (string)m.Tags["error.type"]); 418Assert.Equal("/new", (string)m.Tags["http.route"]); 451Assert.Equal(exceptionName, (string)measurement.Tags["error.type"]); 452Assert.Equal(result, measurement.Tags["aspnetcore.diagnostics.exception.result"].ToString()); 459Assert.Equal(handler, (string)measurement.Tags["aspnetcore.diagnostics.handler.type"]);

ExceptionHandlerTest.cs (35)

StatusCodeMiddlewareTest.cs (7)

63Assert.Equal(expectedUri, response.Headers.First(s => s.Key == "Location").Value.First()); 67Assert.Equal(expectedQueryString, content); 68Assert.Equal(expectedQueryString, response.RequestMessage.RequestUri.Query); 129Assert.Equal($"?id={expectedStatusCode}, /location, ?name=James", content); 191Assert.Equal($"?id={expectedStatusCode}, /location, ?name=James", content); 280Assert.Equal("errorPage", content); 390Assert.Equal("Status: 400", content);

WebHostFunctionalTests.cs (7)

45Assert.Equal("Kestrel", response.Headers.Server.ToString()); 47Assert.Equal(applicationName, responseText); 70Assert.Equal("Kestrel", response.Headers.Server.ToString()); 72Assert.Equal(applicationName, responseText); 171Assert.Equal("Microsoft-IIS/10.0", response.Headers.Server.ToString()); 173Assert.Equal(applicationName, responseText); 193Assert.Equal(applicationName, responseText);

ConverterTests\JsonConverterReadTests.cs (8)

36Assert.Equal("A field name", m.HidingFieldName); 47Assert.Equal("", m.FieldName); 48Assert.Equal("A field name", m.HidingFieldName); 59Assert.Equal("A field name", m.FieldName); 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); 395Assert.Equal("In any!", helloRequest.Name); 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));

ConverterTests\JsonConverterWriteTests.cs (3)

232Assert.Equal(expectedJson, json); 247Assert.Equal(expectedJson, json); 517Assert.Equal(@"{""b"":10,""a"":20,""d"":30}", json);

HttpRoutePatternParserTests.cs (57)

JsonTranscodingRouteAdapterTests.cs (20)

JsonTranscodingServerCallContextTests.cs (3)

52Assert.Equal("testname", headers[0].Key); 53Assert.Equal("TestValue", headers[0].Value); 54Assert.Equal("hello-bin", headers[1].Key);

JsonTranscodingServiceMethodProviderTests.cs (38)

ServerStreamingServerCallHandlerTests.cs (16)

64Assert.Equal("application/json; charset=utf-8", httpContext.Response.ContentType); 68Assert.Equal("Hello TestName! 1", responseJson1.RootElement.GetProperty("message").GetString()); 75Assert.Equal("Hello TestName! 2", responseJson2.RootElement.GetProperty("message").GetString()); 112Assert.Equal("Hello TestName! 1", responseJson1.RootElement.GetProperty("message").GetString()); 116Assert.Equal("Exception was thrown by handler.", responseJson2.RootElement.GetProperty("message").GetString()); 120Assert.Equal("Error when executing service method 'TestMethodName'.", exceptionWrite.Message); 121Assert.Equal("Exception!", exceptionWrite.Exception.Message); 154Assert.Equal("Hello TestName! 1", responseJson1.RootElement.GetProperty("message").GetString()); 158Assert.Equal("Detail!", responseJson2.RootElement.GetProperty("message").GetString()); 162Assert.Equal("Error status code 'Aborted' with detail 'Detail!' raised.", exceptionWrite.Message); 195Assert.Equal("Exception was thrown by handler. Exception: Exception!", responseJson.RootElement.GetProperty("message").GetString()); 199Assert.Equal("Error when executing service method 'TestMethodName'.", exceptionWrite.Message); 200Assert.Equal("Exception!", exceptionWrite.Exception.Message); 245Assert.Equal("application/xml", httpContext.Response.ContentType); 249Assert.Equal("Hello TestName! 1", (string)responseXml1.Element("message")!); 256Assert.Equal("Hello TestName! 2", (string)responseXml2.Element("message")!);

ServiceDescriptorHelpersTests.cs (2)

21Assert.Equal("/say", httpRule.Post); 22Assert.Equal("*", httpRule.Body);

UnaryServerCallHandlerTests.cs (95)

Binding\BodyTests.cs (6)

32Assert.Equal("array", bodySchema.Type); 33Assert.Equal("RequestBody", bodySchema.Items.Reference.Id); 51Assert.Equal("object", bodySchema.Type); 52Assert.Equal("integer", bodySchema.AdditionalProperties.Type); 66Assert.Equal("RequestBody", bodySchema.Reference.Id); 80Assert.Equal("RequestOne", bodySchema.Reference.Id);

Binding\ParametersTests.cs (26)

Binding\ResponseBodyTests.cs (10)

32Assert.Equal("string", bodySchema.Type); 47Assert.Equal("array", bodySchema.Type); 48Assert.Equal("string", bodySchema.Items.Type); 64Assert.Equal("string", enumSchema.Type); 69v => Assert.Equal("ENUM_WITHOUT_MESSAGE_BAR", v), 70v => Assert.Equal("ENUM_WITHOUT_MESSAGE_BAZ", v), 71v => Assert.Equal("ENUM_WITHOUT_MESSAGE_FOO", v), 72v => Assert.Equal("ENUM_WITHOUT_MESSAGE_NEG", v), 73v => Assert.Equal("ENUM_WITHOUT_MESSAGE_UNSPECIFIED", v)); 89Assert.Equal("object", enumSchema.Type);

GrpcSwaggerServiceExtensionsTests.cs (2)

49Assert.Equal("OK", operation.Responses["200"].Description); 50Assert.Equal("Error", operation.Responses["default"].Description);

SchemaGeneratorIntegrationTests.cs (38)

XmlComments\XmlCommentsDocumentFilterTests.cs (1)

44Assert.Equal(expectedDescription, document.Tags[0].Description);

XmlComments\XmlDocumentationIntegrationTests.cs (16)

28Assert.Equal("XmlDoc", swagger.Tags[0].Name); 29Assert.Equal("XmlDocServiceWithComments XML comment!", swagger.Tags[0].Description); 39Assert.Equal("XmlDoc", swagger.Tags[0].Name); 40Assert.Equal("XmlDoc!", swagger.Tags[0].Description); 51Assert.Equal("Name field!", path.Operations[OperationType.Get].Parameters[0].Description); 62Assert.Equal("BasicGet XML summary!", path.Operations[OperationType.Get].Summary); 63Assert.Equal("BasicGet XML remarks!", path.Operations[OperationType.Get].Description); 74Assert.Equal("BasicGet!", path.Operations[OperationType.Get].Summary); 86Assert.Equal("Request XML param!", path.Operations[OperationType.Post].RequestBody.Description); 108Assert.Equal("Detail field!", path.Operations[OperationType.Post].RequestBody.Description); 123Assert.Equal("name", p.Name); 124Assert.Equal("Name field!", p.Description); 129Assert.Equal("detail.age", p.Name); 130Assert.Equal("Age field!", p.Description); 142Assert.Equal("StringReply!", helloReplyMessage.Description); 143Assert.Equal("Message field!", helloReplyMessage.Properties["message"].Description);

CommonHeadersTests.cs (17)

HeaderKeyTests.cs (2)

22Assert.Equal(TestHeaderName, sut.ToString()); 30Assert.Equal(TestHeaderName, sut.Name);

HeaderParsingExtensionsTests.cs (2)

113Assert.Equal(date, parsedDate.ToString("R", CultureInfo.InvariantCulture)); 117Assert.Equal(date, parsedDate.ToString("R", CultureInfo.InvariantCulture));

HeaderParsingFeatureTests.cs (8)

54Assert.Equal(date, value.ToString("R", CultureInfo.InvariantCulture)); 73Assert.Equal(currentDate, value.ToString("R", CultureInfo.InvariantCulture)); 79Assert.Equal(futureDate, textValue.ToString("R", CultureInfo.InvariantCulture)); 97Assert.Equal(date, value.ToString("R", CultureInfo.InvariantCulture)); 111Assert.Equal("Header 'Date' not found.", _logger.Collector.LatestRecord.Message); 127Assert.Equal(date, value.ToString("R", CultureInfo.InvariantCulture)); 130Assert.Equal("Using a default value for header 'Date'.", _logger.Collector.LatestRecord.Message); 148Assert.Equal("Can't parse header 'Date' due to 'Unable to parse date time offset value.'.", _logger.Collector.LatestRecord.Message);

HeaderRegistryTests.cs (1)

33Assert.Equal(CommonHeaders.Date.HeaderName, key.Name);

HeaderSetupTests.cs (2)

19Assert.Equal(TestHeaderName, sut.HeaderName); 29Assert.Equal(TestHeaderName, sut.HeaderName);

HostHeaderValueTests.cs (2)

75Assert.Equal("foo", hhv.ToString()); 78Assert.Equal("foo:82", hhv.ToString());

ParserTests.cs (9)

22Assert.Equal("web.vortex.data.microsoft.com", result.Host); 80Assert.Equal("csrftoken", result[0].Name.Value); 81Assert.Equal("u32t4o3tb3gg43", result[0].Value.Value); 91Assert.Equal("csrftoken", result[0].Name.Value); 92Assert.Equal("u32t4o3tb3gg43", result[0].Value.Value); 93Assert.Equal("_gat", result[1].Name.Value); 94Assert.Equal("1", result[1].Value.Value); 275Assert.Equal("foo.com", result!.Host); 428Assert.Equal("IP address cannot be empty.", error);

HeaderPropagationIntegrationTest.cs (3)

69Assert.Equal( 91Assert.Equal( 165Assert.Equal(

HeaderPropagationMessageHandlerEntryCollectionTest.cs (4)

16Assert.Equal("foo", entry.CapturedHeaderName); 17Assert.Equal("foo", entry.OutboundHeaderName); 28Assert.Equal("foo", entry.CapturedHeaderName); 29Assert.Equal("bar", entry.OutboundHeaderName);

HeaderPropagationMiddlewareTest.cs (3)

136Assert.Equal("in", receivedName); 153Assert.Equal("test", CapturedHeaders["in"]); 196Assert.Equal("Test", CapturedHeaders["in"]);

LinkedApplicationTests.cs (1)

49Assert.Equal("Hello World", body);

ShutdownTests.cs (1)

115Assert.Equal(CompletionMessage, output);

WebHostBuilderTests.cs (1)

64Assert.Equal($"IStartupInjectionAssemblyName", output);

ConfigureBuilderTests.cs (2)

29Assert.Equal($"Could not resolve a service of type '{typeof(CrasherService).FullName}' for the parameter" 34Assert.Equal("Service instantiation failed", ex.InnerException.Message);

GenericWebHostBuilderTests.cs (4)

26Assert.Equal("true", config[randomEnvKey]); 64Assert.Equal("TEST_URL", server.Addresses.Single()); 88Assert.Equal("TEST_URL", server.Addresses.Single()); 128Assert.Equal(expected, string.Join(';', server.Addresses));

HostingApplicationDiagnosticsTests.cs (24)

HostingEnvironmentExtensionsTests.cs (6)

26Assert.Equal(Path.GetFullPath("."), env.ContentRootPath); 27Assert.Equal(Path.GetFullPath("testroot"), env.WebRootPath); 39Assert.Equal(Path.GetFullPath("testroot"), env.ContentRootPath); 40Assert.Equal(Path.GetFullPath(Path.Combine("testroot", "wwwroot")), env.WebRootPath); 52Assert.Equal(Path.GetFullPath(Path.Combine("testroot", "wwwroot")), env.ContentRootPath); 73Assert.Equal("NewName", env.EnvironmentName);

HostingMetricsTests.cs (5)

32Assert.Equal(HostingMetrics.MeterName, meter.Name); 95Assert.Equal(httpVersion, (string)measurement.Tags["network.protocol.version"]); 103Assert.Equal(exceptionName, (string)measurement.Tags["error.type"]); 130Assert.Equal(HostingMetrics.MeterName, meter.Name); 166Assert.Equal(HostingMetrics.MeterName, meter.Name);

Internal\HostingEventSourceTests.cs (6)

22Assert.Equal("Microsoft.AspNetCore.Hosting", eventSource.Name); 42Assert.Equal("HostStart", eventData.EventName); 65Assert.Equal("HostStop", eventData.EventName); 121Assert.Equal("RequestStart", eventData.EventName); 149Assert.Equal("RequestStop", eventData.EventName); 171Assert.Equal("UnhandledException", eventData.EventName);

Internal\HostingRequestStartLogTests.cs (1)

31Assert.Equal(expected, logger.ToString());

StartupManagerTests.cs (20)

34Assert.Equal("StartupServicesFilter Before 1", before.Message); 35Assert.Equal("StartupServicesFilter After 1", after.Message); 56Assert.Equal("StartupServicesFilter Before 1", before.Message); 57Assert.Equal("StartupServicesFilter After 2", after.Message); 81Assert.Equal(expectedMessage, exception.Message); 102Assert.Equal("ConfigureContainerFilter Before 1", before.Message); 103Assert.Equal("ConfigureContainerFilter After 1", after.Message); 124Assert.Equal("ConfigureContainerFilter Before 1", before.Message); 125Assert.Equal("ConfigureContainerFilter After 2", after.Message); 146Assert.Equal("StartupServicesFilter Before 1", before.Message); 147Assert.Equal("ConfigureContainerFilter After 2", after.Message); 356Assert.Equal(environment, options.Environment); 368Assert.Equal("A public method named 'ConfigureBoom' or 'Configure' could not be found in the 'Microsoft.AspNetCore.Hosting.Fakes.StartupBoom' type.", ex.Message); 380Assert.Equal("StartupCaseInsensitive", type.Name); 403Assert.Equal("ConfigureCaseInsensitiveServices", options.Environment); 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); 499Assert.Equal("Configure", foo.Message); 591Assert.Equal(((MyContainer)app.ApplicationServices).Environment, Environments.Production);

StaticWebAssets\ManifestStaticWebAssetsFileProviderTests.cs (5)

289Assert.Equal("file.version.js", file.Name); 306Assert.Equal("", file.Name); 323Assert.Equal("other.html", file.Name); 342Assert.Equal("other.html", file.Name); 358Assert.Equal("project-transitive-dep.js", file.Name);

WebHostBuilderTests.cs (58)

34Assert.Equal("MyStartupAssembly", options.ApplicationName); 35Assert.Equal("MyStartupAssembly", options.StartupAssembly); 78Assert.Equal("The specified factory returned null startup instance.", ex.Message); 331Assert.Equal("value1", context.Configuration["key1"]); 351Assert.Equal("value1", context.Configuration["key1"]); 382Assert.Equal("value1", config["key1"]); 412Assert.Equal("value1", config["key1"]); 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); 499Assert.Equal("EnvB", options.Environment); 525Assert.Equal("EnvB", options.Environment); 551Assert.Equal("EnvB", options.Environment); 586Assert.Equal("EnvB", options.Environment); 611Assert.Equal(expected, host.Services.GetService<IHostEnvironment>().EnvironmentName); 612Assert.Equal(expected, host.Services.GetService<IWebHostEnvironment>().EnvironmentName); 614Assert.Equal(expected, host.Services.GetService<AspNetCore.Hosting.IHostingEnvironment>().EnvironmentName); 615Assert.Equal(expected, host.Services.GetService<Extensions.Hosting.IHostingEnvironment>().EnvironmentName); 659Assert.Equal("/", host.Services.GetService<IHostEnvironment>().ContentRootPath); 660Assert.Equal("/", host.Services.GetService<IWebHostEnvironment>().ContentRootPath); 662Assert.Equal("/", host.Services.GetService<AspNetCore.Hosting.IHostingEnvironment>().ContentRootPath); 663Assert.Equal("/", host.Services.GetService<Extensions.Hosting.IHostingEnvironment>().ContentRootPath); 701Assert.Equal(appBase, host.Services.GetService<IHostEnvironment>().ContentRootPath); 703Assert.Equal(appBase, host.Services.GetService<AspNetCore.Hosting.IHostingEnvironment>().ContentRootPath); 736Assert.Equal(typeof(Startup).Assembly.GetName().Name, hostingEnv.ApplicationName); 737Assert.Equal(typeof(Startup).Assembly.GetName().Name, hostingEnv2.ApplicationName); 754Assert.Equal(typeof(StartupNoServicesNoInterface).Assembly.GetName().Name, hostingEnv.ApplicationName); 755Assert.Equal(typeof(StartupNoServicesNoInterface).Assembly.GetName().Name, hostingEnv2.ApplicationName); 769Assert.Equal(typeof(StartupNoServicesNoInterface).Assembly.GetName().Name, hostingEnv.ApplicationName); 784Assert.Equal(typeof(WebHostBuilderTests).Assembly.GetName().Name, hostingEnv.ApplicationName); 800Assert.Equal(typeof(WebHostBuilderTests).Assembly.GetName().Name, hostingEnv.ApplicationName); 814Assert.Equal("Microsoft.AspNetCore.Hosting.Tests", hostingEnv.ApplicationName); 828Assert.Equal("Microsoft.AspNetCore.Hosting.Tests", hostingEnv.ApplicationName); 842Assert.Equal("WebHostBuilder allows creation only of a single instance of WebHost", ex.Message); 896Assert.Equal("1", builder.GetSetting("testhostingstartup1")); 897Assert.Equal("1", builder.GetSetting("testhostingstartup1_calls")); 916Assert.Equal("1", builder.GetSetting("testhostingstartup1")); 917Assert.Equal("1", builder.GetSetting("testhostingstartup1_calls")); 933Assert.Equal("0", builder.GetSetting("testhostingstartup")); 934Assert.Equal("1", builder.GetSetting("testhostingstartup1")); 935Assert.Equal("01", builder.GetSetting("testhostingstartup_chain")); 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); 1055Assert.Equal("0", builder.GetSetting("testhostingstartup_chain")); 1093Assert.Equal("value", configuration["testhostingstartup:config"]); 1113Assert.Equal("appvalue", context.Configuration["appconfig"]); 1117Assert.Equal("appvalue", context.Configuration["appconfig"]); 1121Assert.Equal("appvalue", context.Configuration["appconfig"]); 1129Assert.Equal("appvalue", configuration["appconfig"]); 1137Assert.Equal("value", config["testhostingstartup:config"]); 1156Assert.Equal("0", builder.GetSetting("testhostingstartup")); 1187Assert.Equal("0", builder.GetSetting("testhostingstartup")); 1334Assert.Equal("nestedvalue", builder.GetSetting("key")); 1338Assert.Equal("nestedvalue", appConfig["key"]); 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);

WebHostConfigurationsTests.cs (5)

27Assert.Equal("wwwroot", config.WebRoot); 28Assert.Equal("MyProjectReference", config.ApplicationName); 29Assert.Equal("MyProjectReference", config.StartupAssembly); 30Assert.Equal(Environments.Development, config.Environment); 42Assert.Equal(Environments.Development, config.Environment);

WebHostTests.cs (12)

28Assert.Equal("No service for type 'Microsoft.AspNetCore.Hosting.Server.IServer' has been registered.", ex.Message); 63Assert.Equal("http://localhost:5002", serverAddressFeature.Addresses.First()); 82Assert.Equal("http://localhost:5003", serverAddressFeature.Addresses.First()); 102Assert.Equal("http://localhost:5009", serverAddressFeature.Addresses.First()); 718Assert.Equal("Changed", env.EnvironmentName); 719Assert.Equal("Changed", env2.EnvironmentName); 805Assert.Equal(Environments.Production, env.EnvironmentName); 806Assert.Equal(Environments.Production, env2.EnvironmentName); 828Assert.Equal(Environments.Staging, env.EnvironmentName); 829Assert.Equal(Environments.Staging, env.EnvironmentName); 848Assert.Equal(Path.GetFullPath("testroot"), env.WebRootPath); 854Assert.Equal(Path.GetFullPath("testroot"), env1.WebRootPath);

HtmlContentBuilderExtensionsTest.cs (22)

25entry => Assert.Equal(Environment.NewLine, HtmlContentToString(entry))); 40entry => Assert.Equal("Hi", Assert.IsType<UnencodedString>(entry).Value), 41entry => Assert.Equal(Environment.NewLine, HtmlContentToString(entry))); 58entry => Assert.Equal(Environment.NewLine, HtmlContentToString(entry))); 73entry => Assert.Equal("Hi", Assert.IsType<EncodedString>(entry).Value), 74entry => Assert.Equal(Environment.NewLine, HtmlContentToString(entry))); 90entry => Assert.Equal("Hi", Assert.IsType<UnencodedString>(entry).Value)); 124entry => Assert.Equal("Hi", Assert.IsType<EncodedString>(entry).Value)); 137Assert.Equal( 152Assert.Equal( 167Assert.Equal("First!", HtmlContentToString(builder)); 180Assert.Equal( 195Assert.Equal( 210Assert.Equal( 225Assert.Equal( 240Assert.Equal("0xHtmlEncode[[32]]", HtmlContentToString(builder)); 259Assert.Equal( 278Assert.Equal( 297Assert.Equal( 317Assert.Equal( 333Assert.Equal( 349Assert.Equal(

HtmlContentBuilderTest.cs (13)

HtmlFormattableStringTest.cs (13)

22Assert.Equal("Hello, World!", result); 35Assert.Equal("Hello, World!", result); 48Assert.Equal( 63Assert.Equal("First!", result); 79Assert.Equal("HtmlEncode[[First]]!", result); 96Assert.Equal("Happy Birthday, HtmlEncode[[Billy]]!", result); 109Assert.Equal(" First!", result); 122Assert.Equal( 137Assert.Equal( 151Assert.Equal("0xHtmlEncode[[32]]", result); 170Assert.Equal( 188Assert.Equal("HtmlEncode[[1,21]] in french!", result); 202Assert.Equal("HtmlEncode[[Sonntag, 1. Februar 2015]]", result);

CookieBuilderTests.cs (2)

51Assert.Equal(new CookieOptions().Path, new CookieBuilder().Build(new DefaultHttpContext()).Path); 73Assert.Equal("name=value; path=/; simple; key=value", cookie.ToString());

EndpointFilterInvocationContextOfTTests.cs (2)

36Assert.Equal("Foo", context.GetArgument<string>(0)); 96Assert.Equal(currentContent, generatedContent);

EndpointMetadataCollectionTests.cs (1)

80Assert.Equal("2", requiredMetadata);

HostStringTest.cs (2)

39Assert.Equal(expectedDomain, result); 93Assert.Equal(expectedHost, host);

HttpProtocolTests.cs (6)

11Assert.Equal("HTTP/3", HttpProtocol.Http3); 30Assert.Equal("HTTP/2", HttpProtocol.Http2); 49Assert.Equal("HTTP/1.1", HttpProtocol.Http11); 68Assert.Equal("HTTP/1.0", HttpProtocol.Http10); 87Assert.Equal("HTTP/0.9", HttpProtocol.Http09); 118Assert.Equal(expected, actual);

HttpValidationProblemDetailsJsonConverterTest.cs (28)

35Assert.Equal(problemDetails.Type, document.RootElement.GetProperty("type").GetString()); 36Assert.Equal(problemDetails.Title, document.RootElement.GetProperty("title").GetString()); 38Assert.Equal(problemDetails.Detail, document.RootElement.GetProperty("detail").GetString()); 39Assert.Equal(problemDetails.Instance, document.RootElement.GetProperty("instance").GetString()); 40Assert.Equal((string)problemDetails.Extensions["traceId"]!, document.RootElement.GetProperty("traceId").GetString()); 42Assert.Equal("error0", errorsElement.GetProperty("key0")[0].GetString()); 43Assert.Equal("error1", errorsElement.GetProperty("key1")[0].GetString()); 44Assert.Equal("error2", errorsElement.GetProperty("key1")[1].GetString()); 66Assert.Equal(type, problemDetails.Type); 67Assert.Equal(title, problemDetails.Title); 69Assert.Equal(instance, problemDetails.Instance); 70Assert.Equal(detail, problemDetails.Detail); 75Assert.Equal("traceId", kvp.Key); 76Assert.Equal(traceId, kvp.Value?.ToString()); 82Assert.Equal("key0", kvp.Key); 87Assert.Equal("key1", kvp.Key); 109Assert.Equal(type, problemDetails.Type); 110Assert.Equal(title, problemDetails.Title); 116Assert.Equal("traceId", kvp.Key); 117Assert.Equal(traceId, kvp.Value?.ToString()); 123Assert.Equal("key0", kvp.Key); 128Assert.Equal("key1", kvp.Key); 148Assert.Equal(type, problemDetails!.Type); 149Assert.Equal(title, problemDetails.Title); 155Assert.Equal("traceId", kvp.Key); 156Assert.Equal(traceId, kvp.Value?.ToString()); 162Assert.Equal("key0", kvp.Key); 167Assert.Equal("key1", kvp.Key);

MapPathMiddlewareTests.cs (17)

MetadataTests.cs (9)

14Assert.Equal("Produces StatusCode: 100", new ProducesResponseTypeMetadata(100).ToString()); 15Assert.Equal("Produces StatusCode: 200, ContentTypes: application/json", new ProducesResponseTypeMetadata(200, contentTypes: new[] { "application/json" }).ToString()); 16Assert.Equal("Produces StatusCode: 300, ContentTypes: application/json,text/plain", new ProducesResponseTypeMetadata(300, contentTypes: new[] { "application/json", "text/plain" }).ToString()); 17Assert.Equal("Produces StatusCode: 400, Type: System.Version", new ProducesResponseTypeMetadata(400, type: typeof(Version)).ToString()); 18Assert.Equal("Produces StatusCode: 500, Type: System.Void", new ProducesResponseTypeMetadata(500, type: typeof(void)).ToString()); 25Assert.Equal("Accepts ContentTypes: application/json, IsOptional: False", new AcceptsMetadata(new[] { "application/json" }).ToString()); 26Assert.Equal("Accepts ContentTypes: application/json,text/plain, IsOptional: False", new AcceptsMetadata(new[] { "application/json", "text/plain" }).ToString()); 27Assert.Equal("Accepts ContentTypes: application/json, RequestType: System.Version, IsOptional: False", new AcceptsMetadata(new[] { "application/json" }, type: typeof(Version)).ToString()); 28Assert.Equal("Accepts ContentTypes: application/json, IsOptional: True", new AcceptsMetadata(new[] { "application/json" }, isOptional: true).ToString());

PathStringTests.cs (12)

90Assert.Equal(expected, result.Value); 104Assert.Equal("http://localhost:80/base/path?query#frag", result); 107Assert.Equal("/base/path?query#frag", result); 110Assert.Equal("/pathtext", result); 286Assert.Equal(expected, path.ToUriComponent()); 294Assert.Equal("/foo", result.ToString()); 321Assert.Equal(input, sut.Value); 333Assert.Equal(input, sut.Value); 343Assert.Equal(expected, sut.Value); 354Assert.Equal(expected, sut.Value); 369Assert.Equal(input, sut.ToUriComponent()); 378Assert.Equal(expected, sut.Value);

ProblemDetailsJsonConverterTest.cs (25)

50Assert.Equal(type, problemDetails.Type); 51Assert.Equal(title, problemDetails.Title); 53Assert.Equal(instance, problemDetails.Instance); 54Assert.Equal(detail, problemDetails.Detail); 59Assert.Equal("traceId", kvp.Key); 60Assert.Equal(traceId, kvp.Value?.ToString()); 81Assert.Equal(type, problemDetails!.Type); 82Assert.Equal(title, problemDetails.Title); 84Assert.Equal(instance, problemDetails.Instance); 85Assert.Equal(detail, problemDetails.Detail); 90Assert.Equal("traceId", kvp.Key); 91Assert.Equal(traceId, kvp.Value?.ToString()); 113Assert.Equal(type, problemDetails!.Type); 114Assert.Equal(title, problemDetails.Title); 116Assert.Equal(instance, problemDetails.Instance); 117Assert.Equal(detail, problemDetails.Detail); 122Assert.Equal("traceId", kvp.Key); 124Assert.Equal(traceId, kvp.Value?.ToString()); 145Assert.Equal(type, problemDetails.Type); 146Assert.Equal(title, problemDetails.Title); 152Assert.Equal("traceId", kvp.Key); 153Assert.Equal(traceId, kvp.Value?.ToString()); 186Assert.Equal(expected, actual); 210Assert.Equal(expected, actual); 241Assert.Equal(expected, actual);

QueryStringTests.cs (9)

31Assert.Equal(string.Empty, query.Value); 39Assert.Equal("?", query.Value); 46Assert.Equal("?Hello=Wor%23ld", query.ToString()); 60Assert.Equal(expected, query.Value); 74Assert.Equal("?key1=value1&key2=value2&key3=value3&key4=&key5=", query.Value); 88Assert.Equal("?key1=value1&key2=value2&key3=value3&key4=&key5=", query.Value); 105Assert.Equal(expected, q1.Add(q2).Value); 106Assert.Equal(expected, (q1 + q2).Value); 127Assert.Equal(expected, q2.Value);

RouteValueDictionaryTests.cs (46)

UseExtensionsTests.cs (1)

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

UseMiddlewareTest.cs (15)

18Assert.Equal( 32Assert.Equal( 46Assert.Equal( 60Assert.Equal( 74Assert.Equal( 87Assert.Equal( 100Assert.Equal( 113Assert.Equal( 127Assert.Equal( 141Assert.Equal( 154Assert.Equal( 166Assert.Equal( 217Assert.Equal(Resources.FormatException_UseMiddlewareExplicitArgumentsNotSupported(typeof(IMiddleware)), exception.Message); 234Assert.Equal(Resources.FormatException_UseMiddlewareNoMiddlewareFactory(typeof(IMiddlewareFactory)), exception.Message); 253Assert.Equal(

UsePathBaseExtensionsTests.cs (7)

163Assert.Equal("Response", response); 185Assert.Equal("Response", response); 205Assert.Equal("Response", response); 222Assert.Equal(expectedPath, ((PathString?)requestContext.Items["test.Path"])!.Value.Value); 223Assert.Equal(expectedPathBase, ((PathString?)requestContext.Items["test.PathBase"])!.Value.Value); 226Assert.Equal(pathBase, requestContext.Request.PathBase.Value); 227Assert.Equal(requestPath, requestContext.Request.Path.Value);

HttpConnectionDispatcherTests.cs (37)

HttpConnectionManagerTests.cs (5)

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

Internal\HttpConnectionsEventSourceTests.cs (7)

23Assert.Equal("Microsoft.AspNetCore.Http.Connections", eventSource.Name); 43Assert.Equal("ConnectionStart", eventData.EventName); 46Assert.Equal("Started connection '{0}'.", eventData.Message); 70Assert.Equal("ConnectionStop", eventData.EventName); 73Assert.Equal("Stopped connection '{0}'.", eventData.Message); 97Assert.Equal("ConnectionTimedOut", eventData.EventName); 100Assert.Equal("Connection '{0}' timed out.", eventData.Message);

LongPollingTests.cs (2)

81Assert.Equal("Hello World", Encoding.UTF8.GetString(ms.ToArray())); 109Assert.Equal("Hello World", Encoding.UTF8.GetString(payload));

MapConnectionHandlerTests.cs (27)

NegotiateProtocolTests.cs (8)

34Assert.Equal(connectionId, response.ConnectionId); 36Assert.Equal(url, response.Url); 37Assert.Equal(accessToken, response.AccessToken); 39Assert.Equal(connectionToken, response.ConnectionToken); 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); 96Assert.Equal("{\"negotiateVersion\":0,\"availableTransports\":[]}", json); 115Assert.Equal("{\"negotiateVersion\":0,\"availableTransports\":[{\"transport\":null,\"transferFormats\":[]}]}", json);

ServerSentEventsMessageFormatterTests.cs (2)

25Assert.Equal(encoded, Encoding.UTF8.GetString(output.ToArray())); 37Assert.Equal(encoded, Encoding.UTF8.GetString(output.ToArray()));

ServerSentEventsTests.cs (6)

34Assert.Equal("text/event-stream", context.Response.ContentType); 35Assert.Equal("no-cache,no-store", context.Response.Headers["Cache-Control"]); 36Assert.Equal("no-cache", context.Response.Headers["Pragma"]); 79Assert.Equal(":\r\ndata: Hello\r\n\r\n", Encoding.ASCII.GetString(ms.ToArray())); 104Assert.Equal(":\r\ndata: " + hText + wText + "\r\n\r\n", Encoding.ASCII.GetString(ms.ToArray())); 130Assert.Equal(expected, Encoding.UTF8.GetString(ms.ToArray()));

WebSocketsTests.cs (3)

56Assert.Equal("Hello", Encoding.UTF8.GetString(buffer.ToArray())); 106Assert.Equal("Hello", Encoding.UTF8.GetString(clientSummary.Received[0].Buffer)); 381Assert.Equal(ExpectedSubProtocol, feature.SubProtocol);

HttpRequestJsonExtensionsTests.cs (6)

46Assert.Equal(expectedMessage, ex.Message); 61Assert.Equal(expectedMessage, ex.Message); 130Assert.Equal("激光這兩個字是甚麼意思", result!["name"]); 164Assert.Equal("Unable to read the request as JSON because the request content type charset 'invalid' is not a known encoding.", ex.Message); 194Assert.Equal("激光這兩個字是甚麼意思", result!["name"]); 208Assert.Equal("Unable to read the request as JSON because the request content type charset 'invalid' is not a known encoding.", ex.Message);

HttpResponseJsonExtensionsTests.cs (12)

54Assert.Equal("null", data); 74Assert.Equal("[false,true,false]", data); 119Assert.Equal("application/custom-type", context.Response.ContentType); 158Assert.Equal(@"{""stringProperty"":""激光這兩個字是甚麼意思""}", data); 195Assert.Equal("null", data); 239Assert.Equal(@"{""stringProperty"":""激光這兩個字是甚麼意思""}", data); 274Assert.Equal("[1,2]", Encoding.UTF8.GetString(body.ToArray())); 299Assert.Equal("[1,2]", Encoding.UTF8.GetString(body.ToArray())); 463Assert.Equal("[1,2,3]", data); 484Assert.Equal("null", data); 515Assert.Equal("t", headerValue); 547Assert.Equal("t", headerValue);

MetadataTest.cs (3)

20Assert.Equal("Description: A description", value); 33Assert.Equal("Summary: A summary", value); 46Assert.Equal("Tags: Tag1,Tag2", value);

ParameterBindingMethodCacheTests.cs (8)

575Assert.Equal("TryParseFromMultipleInterfaces implements multiple interfaces defining a static Boolean TryParse(System.String, TryParseFromMultipleInterfaces ByRef) method causing ambiguity.", ex.Message); 643Assert.Equal("BindAsyncFromMultipleInterfaces implements multiple interfaces defining a static System.Threading.Tasks.ValueTask`1[Microsoft.AspNetCore.Http.Extensions.Tests.ParameterBindingMethodCacheTests+BindAsyncFromMultipleInterfaces] BindAsync(Microsoft.AspNetCore.Http.HttpContext) method causing ambiguity.", ex.Message); 684Assert.Equal($"No public parameterless constructor found for type '{TypeNameHelper.GetTypeDisplayName(type, fullName: false)}'.", ex.Message); 694Assert.Equal($"The abstract type '{TypeNameHelper.GetTypeDisplayName(type, fullName: false)}' is not supported.", ex.Message); 704Assert.Equal($"Only a single public parameterized constructor is allowed for type '{TypeNameHelper.GetTypeDisplayName(type, fullName: false)}'.", ex.Message); 716Assert.Equal( 1080Assert.Equal("bindAsyncRecord", parameter.Name); 1096Assert.Equal("bindAsyncStruct", parameter.Name);

ProblemDetailsDefaultWriterTest.cs (66)

ProblemDetailsServiceCollectionExtensionsTest.cs (1)

236Assert.Equal("Microsoft.AspNetCore.Http.ProblemDetailsJsonContext", jsonOptions.Value.SerializerOptions.TypeInfoResolverChain[1].GetType().FullName);

ProblemDetailsServiceTest.cs (3)

33Assert.Equal("\"SecondWriter\"", Encoding.UTF8.GetString(stream.ToArray())); 60Assert.Equal("\"SecondWriter\"", Encoding.UTF8.GetString(stream.ToArray())); 110Assert.Equal(string.Empty, Encoding.UTF8.GetString(stream.ToArray()));

PropertyAsParameterInfoTests.cs (2)

18Assert.Equal(propertyInfo.Name, parameterInfo.Name); 31Assert.Equal(propertyInfo.Name, parameterInfo.Name);

QueryBuilderTests.cs (10)

RequestDelegateFactoryTests.cs (44)

RequestDelegateFactoryTests.FormMapping.cs (7)

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); 174Assert.Equal("Specified argument was out of the range of valid values.", anotherException.Message); 203Assert.Equal("Write tests", capturedTodo.Name); 282Assert.Equal("The maximum recursion depth of '3' was exceeded for 'Manager.Manager.Manager.Name'.", exception.Message); 303Assert.Equal("A test file", capturedArgument.Description);

RequestDelegateGenerator\CompileTimeCreationTests.AsParameters.cs (4)

33Assert.Equal(DiagnosticDescriptors.InvalidAsParametersNullable.Id, diagnostic.Id); 84Assert.Equal(diagnosticId, diagnostic.Id); 85Assert.Equal(message, diagnostic.GetMessage(CultureInfo.InvariantCulture)); 103Assert.Equal(DiagnosticDescriptors.InvalidAsParametersNested.Id, diagnostic.Id);

RequestDelegateGenerator\CompileTimeCreationTests.cs (13)

47Assert.Equal("'invalidName' is not a route parameter.", exception.Message); 201Assert.Equal(DiagnosticDescriptors.UnableToResolveAnonymousReturnType.Id, diagnostic.Id); 251Assert.Equal(DiagnosticDescriptors.TypeParametersNotSupported.Id, diagnostic.Id); 305Assert.Equal(DiagnosticDescriptors.InaccessibleTypesNotSupported.Id, diagnostic.Id); 351Assert.Equal(DiagnosticDescriptors.InaccessibleTypesNotSupported.Id, diagnostic.Id); 389Assert.All(TestSink.Writes, context => Assert.Equal("RequiredParameterNotProvided", context.EventId.Name)); 429Assert.Equal("JsonSerializerOptions instance must specify a TypeInfoResolver setting before being marked as read-only.", exception.Message); 460Assert.Equal(message, exception.Message); 566Assert.Equal(@"Implicit body inferred for parameter ""todo"" but no body was provided. Did you mean to use a Service instead?", log1.Message); 574Assert.Equal(@"Implicit body inferred for parameter ""todo1"" but no body was provided. Did you mean to use a Service instead?", log2.Message); 589Assert.Equal("MapGet", endpointModel.HttpMethod); 608Assert.Equal("MapGet", endpointModel.HttpMethod); 758Assert.Equal(DiagnosticDescriptors.UnableToResolveParameterDescriptor.Id, diagnostic.Id);

RequestDelegateGenerator\CompileTimeCreationTests.Routes.cs (3)

22Assert.Equal("MapGet", endpointModel.HttpMethod); 45Assert.Equal("MapGet", endpointModel.HttpMethod); 71Assert.Equal("MapGet", endpointModel.HttpMethod);

RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (3)

185Assert.Equal(typeof(RequestDelegateGeneratorSources).Assembly.FullName, generatedCode.Tool); 257Assert.Equal(expectedContentType, httpContext.Response.ContentType); 266Assert.Equal(expectedBody, body);

RequestDelegateGenerator\RequestDelegateCreationTests.Arrays.cs (30)

RequestDelegateGenerator\RequestDelegateCreationTests.AsParameters.cs (5)

347Assert.Equal(uriValue, value.Uri?.ToString()); 348Assert.Equal(uriValue, anotherValue.Uri?.ToString()); 395Assert.Equal(@"Required parameter ""string RequiredRouteParam"" was not provided from route.", logs[0].Message); 399Assert.Equal(@"Required parameter ""string RequiredQueryParam"" was not provided from query string.", logs[1].Message); 403Assert.Equal(@"Required parameter ""string RequiredHeaderParam"" was not provided from header.", logs[2].Message);

RequestDelegateGenerator\RequestDelegateCreationTests.BindAsync.cs (8)

104Assert.Equal("The request is missing the required Referer header.", ex.Message); 133Assert.Equal("The request is missing the required Referer header.", ex.Message); 148Assert.Equal($@"Required parameter ""{bindAsyncType} myBindAsyncParam"" was not provided from {bindAsyncType}.BindAsync{parameters}.", log.Message); 198Assert.Equal("BindAsync failed", ex.Message); 251Assert.Equal("https://example.org/", arg!.Uri.ToString()); 254Assert.Equal("Write more tests!", todo!.Name); 307Assert.Equal("Write more tests!", todo0!.Name); 310Assert.Equal("Write more tests!", todo1!.Name);

RequestDelegateGenerator\RequestDelegateCreationTests.cs (10)

36Assert.Equal("MapGet", endpointModel.HttpMethod); 57Assert.Equal("MapGet", endpointModel.HttpMethod); 63Assert.Equal("req", reqParam.SymbolName); 68Assert.Equal("res", reqParam.SymbolName); 92Assert.Equal("MapGet", endpointModel.HttpMethod); 129Assert.Equal("MapGet", endpointModel.HttpMethod); 136Assert.Equal("MapGet", endpointModel.HttpMethod); 143Assert.Equal("MapGet", endpointModel.HttpMethod); 148Assert.Equal("req", reqParam.SymbolName); 153Assert.Equal("res", reqParam.SymbolName);

RequestDelegateGenerator\RequestDelegateCreationTests.Filters.cs (2)

105Assert.Equal("New response", problemDetails.Detail); 623Assert.Equal("Test todo", todo.Name);

RequestDelegateGenerator\RequestDelegateCreationTests.Forms.cs (38)

RequestDelegateGenerator\RequestDelegateCreationTests.JsonBody.cs (1)

477Assert.Equal(@"Required parameter ""Todo todo"" was not provided from body.", log.Message);

RequestDelegateGenerator\RequestDelegateCreationTests.JsonBodyOrService.cs (1)

134Assert.Equal(@"Implicit body inferred for parameter ""todo"" but no body was provided. Did you mean to use a Service instead?", log.Message);

RequestDelegateGenerator\RequestDelegateCreationTests.KeyServices.cs (4)

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

RequestDelegateGenerator\RequestDelegateCreationTests.Logging.cs (23)

RequestDelegateGenerator\RequestDelegateCreationTests.Metadata.cs (9)

35Assert.Equal("text/plain", metadata.ContentTypes.Single()); 51Assert.Equal("application/json", metadata.ContentTypes.Single()); 81Assert.Equal("text/plain", metadata.ContentTypes.Single()); 95Assert.Equal("text/plain", metadata.ContentTypes.Single()); 109Assert.Equal("text/plain", metadata.ContentTypes.Single()); 123Assert.Equal("text/plain", metadata.ContentTypes.Single()); 138Assert.Equal("application/problem+json", metadata.ContentTypes.Single()); 181Assert.Equal("application/json", Assert.Single(responseMetadata.ContentTypes)); 195Assert.Equal("text/plain", Assert.Single(responseMetadata.ContentTypes));

RequestDelegateGenerator\RequestDelegateCreationTests.QueryParameters.cs (5)

72Assert.Equal($@"Required parameter ""{expectedType}"" was not provided from {parameterSource}.", log.Message); 79Assert.Equal(expectedResponse, decodedResponseBody); 93Assert.Equal("MapGet", endpointModel.HttpMethod); 117Assert.Equal("MapGet", endpointModel.HttpMethod); 171Assert.Equal("MapGet", endpointModel.HttpMethod);

RequestDelegateGenerator\RequestDelegateCreationTests.Responses.cs (22)

RequestDelegateGenerator\RequestDelegateCreationTests.TryParse.cs (3)

166Assert.Equal("MapGet", endpointModel.HttpMethod); 189Assert.Equal("MapGet", endpointModel.HttpMethod); 230Assert.Equal("MapGet", endpointModel.HttpMethod);

RequestDelegateGenerator\RuntimeCreationTests.ComplexFormBinding.cs (3)

41Assert.Equal("Write tests", todo.Name); 77Assert.Equal("Write tests", todo.Name); 185Assert.Equal(@"Failed to bind parameter ""Dictionary<string, bool> elements"" from the request body as form.", log.Message);

RequestDelegateGenerator\SharedTypes.cs (1)

205Assert.Equal("customTodo", parameter.Name);

ResponseExtensionTests.cs (2)

21Assert.Equal(string.Empty, context.Response.Headers["custom"].ToString()); 47Assert.Equal(location, context.Response.Headers.Location.First());

SendFileResponseExtensionsTests.cs (1)

28Assert.Equal("bob", fakeFeature.Name);

UriHelperTests.cs (9)

13Assert.Equal("/", result); 22Assert.Equal("/un%3Fescaped/base/un%3Fescaped?name=val%23ue#my%20value", result); 30Assert.Equal("http:///", result); 39Assert.Equal("http://my.xn--host-cpd:80/un%3Fescaped/base/un%3Fescaped?name=val%23ue#my%20value", result); 80Assert.Equal(expectedUri, uri); 93Assert.Equal("http://my.xn--host-cpd:80/un%3Fescaped/base/un%3Fescaped?name=val%23ue", request.GetEncodedUrl()); 108Assert.Equal("http://my.hoψst:80" + pathBase + "/un?escaped?name=val%23ue", request.GetDisplayUrl()); 142Assert.Equal(scheme, expectedScheme); 166Assert.Equal(scheme, resScheme);

src\Http\Http.Extensions\test\RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (3)

185Assert.Equal(typeof(RequestDelegateGeneratorSources).Assembly.FullName, generatedCode.Tool); 257Assert.Equal(expectedContentType, httpContext.Response.ContentType); 266Assert.Equal(expectedBody, body);

src\Http\Http.Extensions\test\RequestDelegateGenerator\SharedTypes.cs (1)

205Assert.Equal("customTodo", parameter.Name);

AcceptedAtRouteOfTResultTests.cs (3)

60Assert.Equal("\"Hello world\"", response); 99Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]); 204Assert.Equal(value, result.Value);

AcceptedAtRouteResultTests.cs (1)

53Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]);

AcceptedOfTResultTests.cs (3)

29Assert.Equal("\"Hello world\"", response); 45Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]); 128Assert.Equal(value, result.Value);

AcceptedResultTests.cs (1)

29Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]);

BadRequestOfTResultTests.cs (2)

81Assert.Equal("\"Hello\"", Encoding.UTF8.GetString(stream.ToArray())); 171Assert.Equal(value, result.Value);

ConflictOfTResultTests.cs (2)

80Assert.Equal("\"Hello\"", Encoding.UTF8.GetString(stream.ToArray())); 149Assert.Equal(value, result.Value);

ContentResultTests.cs (3)

30Assert.Equal("text/plain; charset=utf-16", httpContext.Response.ContentType); 121Assert.Equal(expectedContentType, finalResponseContentType); 145Assert.Equal(contentType, result.ContentType);

CreatedAtRouteOfTResultTests.cs (2)

69Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]); 171Assert.Equal(value, result.Value);

CreatedAtRouteResultTests.cs (1)

52Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]);

CreatedOfTResultTests.cs (4)

58Assert.Equal(location, httpContext.Response.Headers["Location"]); 75Assert.Equal(location, httpContext.Response.Headers["Location"]); 94Assert.Equal("\"testInput\"", response); 168Assert.Equal(value, result.Value);

CreatedResultTests.cs (2)

43Assert.Equal(location, httpContext.Response.Headers["Location"]); 60Assert.Equal(location, httpContext.Response.Headers["Location"]);

FileContentResultTests.cs (3)

46Assert.Equal(contentType, result.ContentType); 47Assert.Equal(downloadName, result.FileDownloadName); 59Assert.Equal(contentType, result.ContentType);

HttpFileStreamResultTests.cs (5)

55Assert.Equal(expectedMediaType, result.ContentType); 78Assert.Equal(expectedMediaType, result.ContentType); 101Assert.Equal(contentType, result.ContentType); 102Assert.Equal(downloadName, result.FileDownloadName); 114Assert.Equal(contentType, result.ContentType);

HttpResultsHelperTests.cs (12)

42Assert.Equal("Write even more tests!", body!.Name); 74Assert.Equal("Write even more tests!", body!.Name); 107Assert.Equal("Write even more tests!", body!.Name); 109Assert.Equal("With type hierarchies!", body!.Child); 141Assert.Equal("Write even more tests!", body!.Name); 143Assert.Equal("With type hierarchies!", body!.Child); 175Assert.Equal("Write even more tests!", body!.Name); 177Assert.Equal("With type hierarchies!", body!.Child); 207Assert.Equal("One", one.Name); 212Assert.Equal("Two", two.Name); 217Assert.Equal("Three", three.Name); 218Assert.Equal("ThreeChild", three.Child);

InternalServerErrorOfTResultTests.cs (2)

81Assert.Equal("\"Hello\"", Encoding.UTF8.GetString(stream.ToArray())); 171Assert.Equal(value, result.Value);

JsonResultTests.cs (11)

74Assert.Equal("\"Hello\"", Encoding.UTF8.GetString(stream.ToArray())); 107Assert.Equal(value.Title, responseDetails.Title); 108Assert.Equal(value.Description, responseDetails.Description); 111Assert.Equal(JsonSerializer.Serialize(value, options: jsonOptions), Encoding.UTF8.GetString(stream.ToArray())); 138Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.6.1", responseDetails.Type); 139Assert.Equal("An error occurred while processing your request.", responseDetails.Title); 167Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.1", responseDetails.Type); 168Assert.Equal("One or more validation errors occurred.", responseDetails.Title); 200Assert.Equal("I'm a teapot", responseDetails.Title); 264Assert.Equal(contentType, result.ContentType); 312Assert.Equal(value, result.Value);

LocalRedirectResultTests.cs (3)

72Assert.Equal(expectedPath, httpContext.Response.Headers.Location.ToString()); 93Assert.Equal( 114Assert.Equal(

NotFoundOfTResultTests.cs (2)

48Assert.Equal("Test Content", notFound.Value); 131Assert.Equal(value, result.Value);

OkOfTResultTests.cs (3)

27Assert.Equal(value, result.Value); 62Assert.Equal("\"Hello\"", Encoding.UTF8.GetString(stream.ToArray())); 148Assert.Equal(value, result.Value);

PhysicalFileResultTest.cs (3)

48Assert.Equal(contentType, result.ContentType); 49Assert.Equal(downloadName, result.FileDownloadName); 61Assert.Equal(contentType, result.ContentType);

ProblemResultTests.cs (8)

41Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.6.1", responseDetails.Type); 42Assert.Equal("An error occurred while processing your request.", responseDetails.Title); 74Assert.Equal("An error occurred while processing your request.", responseDetails.Title); 102Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.1", responseDetails.Type); 103Assert.Equal("One or more validation errors occurred.", responseDetails.Title); 135Assert.Equal("I'm a teapot", responseDetails.Title); 168Assert.Equal("testError", error.Key); 249Assert.Equal("application/problem+json", result.ContentType);

PushStreamResultTests.cs (7)

26Assert.Equal("Hello World", Encoding.UTF8.GetString(ms.ToArray())); 27Assert.Equal("application/octet-stream", result.ContentType); 43Assert.Equal(expectedMediaType, result.ContentType); 67Assert.Equal(expectedMediaType, result.ContentType); 90Assert.Equal(contentType, result.ContentType); 91Assert.Equal(downloadName, result.FileDownloadName); 103Assert.Equal(contentType, result.ContentType);

RedirectToRouteResultTests.cs (3)

48Assert.Equal(locationUrl, httpContext.Response.Headers["Location"]); 66Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]); 84Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]);

ResultsCacheTests.cs (1)

22Assert.Equal(currentContent, generatedContent);

ResultsTests.cs (92)

src\Shared\ResultsTests\FileContentResultTestBase.cs (24)

src\Shared\ResultsTests\FileStreamResultTestBase.cs (28)

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

src\Shared\ResultsTests\RedirectResultTestBase.cs (2)

34Assert.Equal(expectedPath, httpContext.Response.Headers.Location.ToString()); 57Assert.Equal(expectedPath, httpContext.Response.Headers.Location.ToString());

src\Shared\ResultsTests\VirtualFileResultTestBase.cs (25)

TypedResultsTests.cs (81)

UnprocessableEntityOfTResultTests.cs (2)

79Assert.Equal("\"Hello\"", Encoding.UTF8.GetString(stream.ToArray())); 148Assert.Equal(value, result.Value);

Utf8ContentResultTests.cs (4)

26Assert.Equal("application/json charst=utf-8", result.ContentType); 45Assert.Equal("text/plain; charset=utf-8", context.Response.ContentType); 63Assert.Equal("text/plain; charset=utf-8", context.Response.ContentType); 74Assert.Equal(contentType, result.ContentType);

ValidationProblemResultTests.cs (4)

43Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.1", responseDetails.Type); 44Assert.Equal("One or more validation errors occurred.", responseDetails.Title); 76Assert.Equal("One or more validation errors occurred.", responseDetails.Title); 170Assert.Equal(contentType, result.ContentType);

VirtualFileResultTests.cs (3)

32Assert.Equal(contentType, result.ContentType); 33Assert.Equal(downloadName, result.FileDownloadName); 45Assert.Equal(contentType, result.ContentType);

ApplicationBuilderTests.cs (1)

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

BindingAddressTests.cs (12)

65Assert.Equal(scheme, serverAddress.Scheme); 66Assert.Equal(host, serverAddress.Host); 68Assert.Equal(pathBase, serverAddress.PathBase); 70Assert.Equal(toString ?? url, serverAddress.ToString()); 84Assert.Equal(scheme, serverAddress.Scheme); 85Assert.Equal(host, serverAddress.Host); 87Assert.Equal(pathBase, serverAddress.PathBase); 89Assert.Equal(toString ?? url, serverAddress.ToString()); 102Assert.Equal(scheme, serverAddress.Scheme); 103Assert.Equal(host, serverAddress.Host); 105Assert.Equal(pathBase, serverAddress.PathBase); 107Assert.Equal(toString ?? url, serverAddress.ToString());

DefaultHttpContextTests.cs (2)

24Assert.Equal("Session has not been configured for this application or request.", exception.Message); 103Assert.Equal("SomeAuthType", context.User.Identity.AuthenticationType);

Features\FormFeatureTests.cs (29)

43Assert.Equal("Form value count limit 1 exceeded.", exception.Message); 63Assert.Equal("bar", formCollection["foo"]); 64Assert.Equal("2", formCollection["baz"]); 105Assert.Equal("bar", formCollection["foo"]); 106Assert.Equal("2", formCollection["baz"]); 259Assert.Equal("Foo", formCollection["description"]); 301Assert.Equal("myfile1", file.Name); 302Assert.Equal("temp.html", file.FileName); 303Assert.Equal("text/html", file.ContentType); 304Assert.Equal(@"form-data; name=""myfile1""; filename=""temp.html""", file.ContentDisposition); 310Assert.Equal("<html><body>Hello World</body></html>", content); 344Assert.Equal("Foo", formCollection["description"]); 386Assert.Equal("myfile1", file.Name); 387Assert.Equal("t\u00e9mp.html", file.FileName); 388Assert.Equal("text/html", file.ContentType); 389Assert.Equal(@"form-data; name=""myfile1""; filename=""temp.html""; filename*=utf-8''t%c3%a9mp.html", file.ContentDisposition); 395Assert.Equal("<html><body>Hello World</body></html>", content); 429Assert.Equal("Foo", formCollection["description"]); 435Assert.Equal("text/html", file.ContentType); 436Assert.Equal(@"form-data; name=""myfile1""; filename=""temp.html""", file.ContentDisposition); 442Assert.Equal("<html><body>Hello World</body></html>", content); 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); 578Assert.Equal("Foo", formCollection["description"]); 584Assert.Equal("text/html", file.ContentType); 585Assert.Equal(@"form-data; name=""myfile1""; filename=""temp.html""", file.ContentDisposition); 610Assert.Equal("Form section has invalid Content-Disposition value: " + InvalidContentDispositionValue, exception.Message);

Features\HttpRequestIdentifierFeatureTests.cs (1)

26Assert.Equal(id1, id2);

Features\QueryFeatureTests.cs (12)

Features\RequestBodyPipeFeatureTests.cs (1)

38Assert.Equal(expectedString, GetStringFromReadResult(data));

HeaderDictionaryTests.cs (2)

33Assert.Equal("Value1", headers["header1"]); 83Assert.Equal("Value1", headers["header1"]);

Internal\DefaultHttpRequestTests.cs (13)

78Assert.Equal(expected, host.Value); 98Assert.Equal(expected, host.Value); 115Assert.Equal(expected, headers["Host"][0]); 122Assert.Equal(string.Empty, request.Scheme); 125Assert.Equal("https", request.Scheme); 127Assert.Equal("http", request.Scheme); 139Assert.Equal(string.Empty, requestFeature.QueryString); 149Assert.Equal("value0", query1["name0"]); 150Assert.Equal("value1", query1["name1"]); 159Assert.Equal("?name2=value2", requestFeature.QueryString); 181Assert.Equal("value0,", cookies1["name0"]); 182Assert.Equal("value1", cookies1["name1"]); 191Assert.Equal("value2", request.Cookies["name2"]);

RequestCookiesCollectionTests.cs (2)

55Assert.Equal(value, cookies.ElementAt(i).Value); 71Assert.Equal(c.ToString(), cookies.Single().Value);

ResponseCookiesTest.cs (1)

54Assert.Equal("The cookie 'TestCookie' has set 'SameSite=None' and must also set 'Secure'.", writeContext.Message);

FileLoggerProcessorTests.cs (14)

HttpLoggingAttributeTests.cs (2)

12Assert.Equal(nameof(HttpLoggingAttribute.RequestBodyLogLimit), ex.ParamName); 15Assert.Equal(nameof(HttpLoggingAttribute.ResponseBodyLogLimit), ex.ParamName);

HttpLoggingEndpointConventionBuilderTests.cs (2)

46Assert.Equal("requestBodyLogLimit", ex.ParamName); 50Assert.Equal("responseBodyLogLimit", ex.ParamName);

HttpLoggingMiddlewareTests.cs (40)

352Assert.Equal(expected, body); 380Assert.Equal(expected, body); 1277Assert.Equal("No Content-Type header for request body.", contentTypeLog.Message); 1282Assert.Equal("Request and Response:", lines[i++]); 1283Assert.Equal("Protocol: HTTP/1.1", lines[i++]); 1284Assert.Equal("Method: GET", lines[i++]); 1285Assert.Equal("Scheme: http", lines[i++]); 1286Assert.Equal("PathBase: ", lines[i++]); 1287Assert.Equal("Path: /", lines[i++]); 1288Assert.Equal("Connection: Upgrade", lines[i++]); 1289Assert.Equal("Upgrade: websocket", lines[i++]); 1290Assert.Equal("StatusCode: 101", lines[i++]); 1291Assert.Equal("Connection: Upgrade", lines[i++]); 1530Assert.Equal("Request and Response:", lines[i++]); 1533Assert.Equal("Protocol: HTTP/1.0", lines[i++]); 1534Assert.Equal("Method: GET", lines[i++]); 1535Assert.Equal("Scheme: http", lines[i++]); 1536Assert.Equal("PathBase: /foo", lines[i++]); 1537Assert.Equal("Path: /foo", lines[i++]); 1538Assert.Equal("Connection: keep-alive", lines[i++]); 1541Assert.Equal("Content-Type: text/plain", lines[i++]); 1546Assert.Equal("StatusCode: 200", lines[i++]); 1547Assert.Equal("Transfer-Encoding: test", lines[i++]); 1550Assert.Equal("Content-Type: text/plain2", lines[i++]); 1555Assert.Equal("RequestBody: test", lines[i++]); 1556Assert.Equal("RequestBodyStatus: [Completed]", lines[i++]); 1560Assert.Equal("ResponseBody: test response", lines[i++]); 1592Assert.Equal("Request and Response:", lines[i++]); 1593Assert.Equal("Protocol: HTTP/1.0", lines[i++]); 1594Assert.Equal("Method: GET", lines[i++]); 1595Assert.Equal("Scheme: http", lines[i++]); 1596Assert.Equal("PathBase: /foo", lines[i++]); 1597Assert.Equal("Path: /foo", lines[i++]); 1598Assert.Equal("Connection: keep-alive", lines[i++]); 1599Assert.Equal("Content-Type: text/plain", lines[i++]); 1600Assert.Equal("StatusCode: 200", lines[i++]); 1601Assert.Equal("Transfer-Encoding: test", lines[i++]); 1602Assert.Equal("Content-Type: text/plain2", lines[i++]); 1603Assert.Equal("RequestBody: test", lines[i++]); 1604Assert.Equal("RequestBodyStatus: [Completed]", lines[i++]);

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

W3CLoggerTests.cs (5)

36Assert.Equal("#Version: 1.0", lines[0]); 45Assert.Equal("#Fields: date time", lines[2]); 80Assert.Equal("#Version: 1.0", lines[0]); 89Assert.Equal("#Fields: cs-uri-query sc-status cs-host", lines[2]); 90Assert.Equal("- - -", lines[3]);

W3CLoggingMiddlewareTests.cs (12)

91Assert.Equal("#Version: 1.0", lines[0]); 100Assert.Equal("#Fields: date time c-ip s-computername s-ip s-port cs-method cs-uri-stem cs-uri-query sc-status time-taken cs-version cs-host cs(User-Agent) cs(Referer)", lines[2]); 136Assert.Equal("#Version: 1.0", lines[0]); 145Assert.Equal("#Fields: date time c-ip s-computername s-ip s-port cs-method cs-uri-stem cs-uri-query sc-status time-taken cs-version cs-host cs(User-Agent) cs(Referer) cs(:invalid) cs(x-client-ssl-protocol) cs(x-forwarded-for)", lines[2]); 177Assert.Equal("Snickerdoodle", lines[3]); 209Assert.Equal("#Version: 1.0", lines[0]); 212Assert.Equal("#Fields: cs(x-forwarded-for)", lines[2]); 213Assert.Equal("1.3.3.7,+2001:db8:85a3:8d3:1319:8a2e:370:7348", lines[3]); 256Assert.Equal("#Version: 1.0", lines[0]); 265Assert.Equal("#Fields: date time c-ip s-computername s-ip s-port cs-method cs-uri-stem cs-uri-query sc-status time-taken cs-version cs-host cs(User-Agent) cs(Cookie) cs(Referer) cs(:invalid) cs(x-client-ssl-protocol) cs(x-forwarded-for)", lines[2]); 294Assert.Equal("#Version: 1.0", lines[0]); 303Assert.Equal("#Fields: time-taken", lines[2]);

ForwardedHeadersMiddlewareTest.cs (37)

HttpMethodOverrideMiddlewareTest.cs (6)

29Assert.Equal("DELETE", context.Request.Method); 59Assert.Equal("POST", context.Request.Method); 89Assert.Equal("GET", context.Request.Method); 122Assert.Equal("DELETE", context.Request.Method); 160Assert.Equal("POST", context.Request.Method); 197Assert.Equal("POST", context.Request.Method);

IPNetworkTest.cs (4)

57Assert.Equal(prefixText, network.Prefix.ToString()); 86Assert.Equal(expectedPrefix, network.Prefix.ToString()); 97Assert.Equal("An invalid IP address or prefix length was specified.", ex.Message); 119Assert.Equal(expectedPrefix, network.Prefix.ToString());

HstsMiddlewareTests.cs (6)

71Assert.Equal("max-age=2592000", response.Headers.GetValues(HeaderNames.StrictTransportSecurity).FirstOrDefault()); 117Assert.Equal(expected, response.Headers.GetValues(HeaderNames.StrictTransportSecurity).FirstOrDefault()); 163Assert.Equal(expected, response.Headers.GetValues(HeaderNames.StrictTransportSecurity).FirstOrDefault()); 270Assert.Equal("Adding HSTS header to response.", message.State.ToString()); 372Assert.Equal("The request is insecure. Skipping HSTS header.", message.State.ToString()); 418Assert.Equal("Adding HSTS header to response.", message.State.ToString());

HttpsPolicyTests.cs (2)

70Assert.Equal(expectedUrl, response.Headers.Location.ToString()); 77Assert.Equal(expectedHstsHeader, response.Headers.GetValues(HeaderNames.StrictTransportSecurity).FirstOrDefault());

HttpsRedirectionMiddlewareTests.cs (15)

SqlStoreOnlyUsersTestBase.cs (1)

112Assert.Equal("value", await userMgr.GetAuthenticationTokenAsync(user, "provider", "test"));

SqlStoreTestBase.cs (1)

211Assert.Equal("value", await userMgr.GetAuthenticationTokenAsync(user, "provider", "test"));

UserStoreEncryptPersonalDataTest.cs (2)

95Assert.Equal("123-456-7890", await manager.GetPhoneNumberAsync(user)); 291Assert.Equal("[ProtectedPersonalData] only works strings by default.", e.Message);

UserStoreWithGenericsTest.cs (3)

168Assert.Equal(claim.Type, newClaim.Type); 169Assert.Equal(claim.Value, newClaim.Value); 170Assert.Equal(claim.Issuer, newClaim.Issuer);

Extensions\ResponseAssert.cs (1)

24Assert.Equal("text/html", response.Content.Headers.ContentType.MediaType);

ManagementTests.cs (5)

303Assert.Equal(userName, (string)jsonData["UserName"]); 305Assert.Equal(userName, (string)jsonData["Email"]); 309Assert.Equal("null", (string)jsonData["PhoneNumber"]); 325Assert.Equal(userName, (string)jsonData["Contoso external login provider key"]); 369Assert.Equal(expectedPrincipalClaim, actualPrincipalClaim);

MapIdentityApiTests.cs (65)

Pages\Account\Login.cs (2)

67Assert.Equal(Index.Path, loggedInLocation.ToString()); 90Assert.Equal("/Identity/Account/Lockout", lockedOut.ToString());

Pages\Account\LoginWith2fa.cs (1)

34Assert.Equal(Index.Path, goToIndex.ToString());

Pages\Account\Manage\DeleteUser.cs (1)

24Assert.Equal(Index.Path, deleteLocation.ToString());

Pages\Account\Register.cs (2)

47Assert.Equal(Index.Path, registeredLocation.ToString()); 64Assert.Equal(RegisterConfirmation.Path + "?email=" + userName + "&returnUrl=%2F", registeredLocation.ToString());

RegistrationTests.cs (1)

244Assert.Equal("Contoso", authenticationMethod);

ControllerTest.cs (2)

104Assert.Equal("refresh", await userManager.GetAuthenticationTokenAsync(user, authScheme, "refresh_token")); 105Assert.Equal("access", await userManager.GetAuthenticationTokenAsync(user, authScheme, "access_token"));

FunctionalTest.cs (13)

IdentityResultAssert.cs (3)

41Assert.Equal(error, result.Errors.First().Description); 53Assert.Equal(error.Description, result.Errors.FirstOrDefault()?.Description); 54Assert.Equal(error.Code, result.Errors.FirstOrDefault()?.Code);

IdentitySpecificationTestBase.cs (1)

557Assert.Equal(roleName, await roleMgr.GetRoleNameAsync(await roleMgr.FindByNameAsync(roleName)));

UserManagerSpecificationTests.cs (41)

513Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); 584Assert.Equal(provider, logins[0].LoginProvider); 585Assert.Equal(providerKey, logins[0].ProviderKey); 586Assert.Equal(display, logins[0].ProviderDisplayName); 647Assert.Equal(login.LoginProvider, logins[^1].LoginProvider); 648Assert.Equal(login.ProviderKey, logins[^1].ProviderKey); 649Assert.Equal(login.ProviderDisplayName, logins[^1].ProviderDisplayName); 780Assert.Equal(claim.Type, newClaim.Type); 781Assert.Equal(claim.Value, newClaim.Value); 808Assert.Equal(claim.Type, newClaim.Type); 809Assert.Equal(claim.Value, newClaim.Value); 813Assert.Equal("c", oldClaim2.Type); 814Assert.Equal("a", oldClaim2.Value); 1030Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); 1052Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); 1354Assert.Equal("123-456-7890", await manager.GetPhoneNumberAsync(user)); 1356Assert.Equal("111-111-1111", await manager.GetPhoneNumberAsync(user)); 1375Assert.Equal("111-111-1111", await manager.GetPhoneNumberAsync(user)); 1409Assert.Equal("123-456-7890", await manager.GetPhoneNumberAsync(user)); 1410Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); 1441Assert.Equal("111-111-1111", await manager.GetPhoneNumberAsync(user)); 1461Assert.Equal("123-456-7890", await manager.GetPhoneNumberAsync(user)); 1462Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); 1508Assert.Equal(await manager.GetEmailAsync(user), newEmail); 1531Assert.Equal(await manager.GetEmailAsync(user), newEmail); 1557Assert.Equal(await manager.GetEmailAsync(user), newEmail); 1581Assert.Equal("another@email.com", await manager.GetEmailAsync(user)); 1603Assert.Equal(await manager.GetEmailAsync(user), oldEmail); 1604Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); 1627Assert.Equal(await manager.GetEmailAsync(user), oldEmail); 1628Assert.Equal(stamp, await manager.GetSecurityStampAsync(user)); 1691Assert.Equal(error, ex.Message); 1694Assert.Equal(error, ex.Message); 1697Assert.Equal(error, ex.Message); 1700Assert.Equal(error, ex.Message); 1730Assert.Equal("value", await manager.GetAuthenticationTokenAsync(user, "provider", "name")); 1733Assert.Equal("value2", await manager.GetAuthenticationTokenAsync(user, "provider", "name")); 1736Assert.Equal("value2", await manager.GetAuthenticationTokenAsync(user, "provider", "name")); 1819Assert.Equal("Phone", factors[0]); 1830Assert.Equal("Phone", factors[0]); 1835Assert.Equal("Authenticator", factors[1]);

IdentityOptionsTest.cs (9)

28Assert.Equal("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+", options.User.AllowedUserNameCharacters); 31Assert.Equal(ClaimTypes.Role, options.ClaimsIdentity.RoleClaimType); 32Assert.Equal(ClaimTypes.Name, options.ClaimsIdentity.UserNameClaimType); 33Assert.Equal(ClaimTypes.NameIdentifier, options.ClaimsIdentity.UserIdClaimType); 34Assert.Equal("AspNet.Identity.SecurityStamp", options.ClaimsIdentity.SecurityStampClaimType); 87Assert.Equal("a", options.Get(IdentityConstants.ApplicationScheme).Cookie.Name); 88Assert.Equal("b", options.Get(IdentityConstants.ExternalScheme).Cookie.Name); 89Assert.Equal("c", options.Get(IdentityConstants.TwoFactorRememberMeScheme).Cookie.Name); 90Assert.Equal("d", options.Get(IdentityConstants.TwoFactorUserIdScheme).Cookie.Name);

IdentityUIScriptsTest.cs (2)

41Assert.Equal(scriptTag.Integrity, integrity); 89Assert.Equal(RemoveLineEndings(cdnContent), RemoveLineEndings(fallbackSrcContent));

PasswordHasherTest.cs (5)

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

SignInManagerTest.cs (3)

1057Assert.Equal("Blah blah", externalLoginInfo.ProviderDisplayName); 1088Assert.Equal("bar", externalLoginInfo.ProviderKey); 1123Assert.Equal("fizzbuzz", customValue);

UserClaimsPrincipalFactoryTest.cs (1)

93Assert.Equal(IdentityConstants.ApplicationScheme, identity.AuthenticationType);

UserManagerTest.cs (1)

971Assert.Equal(expectedMessage, error.Message);

ExceptionAssertions.cs (5)

96Assert.Equal(paramName, ex.ParamName); 123Assert.Equal(paramName, ex.ParamName); 140Assert.Equal(paramName, ex.ParamName); 207Assert.Equal(paramName, ex.ParamName); 260Assert.Equal(expectedMessage, exception.Message);

Tracing\EventAssert.cs (2)

51Assert.Equal(_expectedName, evt.EventName); 56return actualValue => Assert.Equal(val.name, actualValue);

AssemblyTestLogTests.cs (2)

304Assert.Equal( 309Assert.Equal(

EnvironmentVariableSkipConditionTest.cs (2)

50Assert.Equal( 69Assert.Equal(

HttpClientSlimTest.cs (4)

22Assert.Equal("test", await HttpClientSlim.GetStringAsync(address)); 40Assert.Equal("test post", await HttpClientSlim.PostAsync(address, new StringContent("test post"))); 58Assert.Equal("[fe80::5d2a:d070:6fd6:1bac]:5003", HttpClientSlim.GetHost(requestUri)); 65Assert.Equal("[fe80::5d2a:d070:6fd6:1bac]", HttpClientSlim.GetHost(requestUri));

LoggedTestXunitTests.cs (5)

75Assert.Equal("Information", message.Formatter(message.State, null)); 86Assert.Equal("Debug", message.Formatter(message.State, null)); 99Assert.Equal("Information", message.Formatter(message.State, null)); 123Assert.Equal($"{nameof(LoggedTheoryNullArgumentsAreEscaped)}_null", ResolvedTestMethodName); 162Assert.Equal("Trace", message.Formatter(message.State, null));

TaskExtensionsTest.cs (2)

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

TestContextTest.cs (3)

18Assert.Equal(GetType().FullName, Context.FileOutput.TestClassName); 43Assert.Equal(GetType().Name, Context.FileOutput.TestClassName); 69Assert.Equal(GetType().Name, Context.FileOutput.TestClassName);

TestPathUtilitiesTest.cs (1)

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

XunitLoggerProviderTest.cs (3)

30Assert.Equal(expectedOutput, MakeConsistent(testTestOutputHelper.Output)); 44Assert.Equal("| [TIMESTAMP] TestCategory Error: This is a bad error" + Environment.NewLine, MakeConsistent(testTestOutputHelper.Output)); 63Assert.Equal(expectedOutput, MakeConsistent(testTestOutputHelper.Output));

IntegrationTests\AnonymousObjectIntegrationTest.cs (7)

27Assert.Equal("The target location specified by path segment 'NewProperty' was not found.", 51Assert.Equal("The target location specified by path segment 'NewInt' was not found.", 74Assert.Equal("The property at path 'StringProperty' could not be updated.", 97Assert.Equal("The property at path 'Test' could not be updated.", 121Assert.Equal("The property at path 'StringProperty' could not be updated.", 145Assert.Equal("The property at path 'StringProperty' could not be updated.", 186Assert.Equal("The current value 'A' at path 'StringProperty' is not equal to the test value 'B'.",

IntegrationTests\DictionaryIntegrationTest.cs (5)

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

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)

153Assert.Equal("The current value '' at path 'Test' is not equal to the test value 'TestValue'.", 174Assert.Equal("The current value 'Value' at path 'Test' is not equal to the test value 'TestValue'.", 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\HeterogenousCollectionTests.cs (2)

44Assert.Equal("Shape property", circle.ShapeProperty); 45Assert.Equal("Circle property", circle.CircleProperty);

IntegrationTests\ListIntegrationTest.cs (4)

49Assert.Equal("The index value provided by path segment '-1' is out of bounds of the array size.", 101Assert.Equal("ChangedString1", targetObject.SimpleObjectList[0].StringProperty); 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\NestedObjectIntegrationTest.cs (12)

33Assert.Equal("B", targetObject.SimpleObjectWithNullCheck.StringProperty); 56Assert.Equal("B", targetObject.NestedObject.StringProperty); 75Assert.Equal("A", targetObject.NestedObject.StringProperty); 95Assert.Equal("B", targetObject.NestedObject.StringProperty); 117Assert.Equal("B", targetObject.SimpleObject.StringProperty); 178Assert.Equal("A", targetObject.SimpleObject.AnotherStringProperty); 229Assert.Equal("C", targetObject.SimpleObject.StringProperty); 230Assert.Equal("D", targetObject.SimpleObject.AnotherStringProperty); 231Assert.Equal("C", targetObject.InheritedObject.StringProperty); 232Assert.Equal("D", targetObject.InheritedObject.AnotherStringProperty); 327Assert.Equal("C", targetObject.SimpleObject.StringProperty); 328Assert.Equal("D", targetObject.SimpleObject.AnotherStringProperty);

IntegrationTests\SimpleObjectIntegrationTest.cs (2)

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

Internal\DictionaryAdapterTest.cs (8)

81Assert.Equal($"The provided path segment '{guidKey.ToString()}' cannot be converted to the target type.", message); 108Assert.Equal("The target location specified by path segment 'NAME' was not found.", message); 136Assert.Equal("James", outValue?.ToString()); 194Assert.Equal("The value 'test' is invalid for target location.", message); 212Assert.Equal("The target location specified by path segment 'Name' was not found.", message); 230Assert.Equal("The target location specified by path segment 'Name' was not found.", message); 254Assert.Equal("James", dictionary[nameKey].RectangleProperty); 335Assert.Equal(expectedErrorMessage, errorMessage);

Internal\DynamicObjectAdapterTest.cs (7)

91Assert.Equal($"The target location specified by path segment '{segment}' was not found.", getErrorMessage); 129Assert.Equal($"The target location specified by path segment '{segment}' was not found.", errorMessage); 165Assert.Equal($"The target location specified by path segment '{segment}' was not found.", errorMessage); 183Assert.Equal($"The value 'test' is invalid for target location.", errorMessage); 204Assert.Equal("new", rect.RectangleProperty); 249Assert.Equal($"The target location specified by path segment '{segment}' was not found.", removeErrorMessage); 292Assert.Equal(expectedErrorMessage, errorMessage);

Internal\ListAdapterTest.cs (10)

27Assert.Equal($"The type '{targetObject.GetType().FullName}' which is an array is not supported for json patch operations as it has a fixed size.", message); 45Assert.Equal($"The type '{targetObject.GetType().FullName}' which is a non generic list is not supported for json patch operations. Only generic list types are supported.", message); 83Assert.Equal($"The index value provided by path segment '{position}' is out of bounds of the array size.", message); 101Assert.Equal($"The path segment '{position}' is invalid for an array index.", message); 191Assert.Equal("The value 'James' is invalid for target location.", message); 317Assert.Equal($"The index value provided by path segment '{position}' is out of bounds of the array size.", message); 356Assert.Equal($"The index value provided by path segment '{position}' is out of bounds of the array size.", message); 391Assert.Equal("The value 'James' is invalid for target location.", message); 477Assert.Equal(expectedErrorMessage, errorMessage); 494Assert.Equal(expectedErrorMessage, errorMessage);

Internal\ObjectVisitorTest.cs (2)

170Assert.Equal($"The index value provided by path segment '{position}' is out of bounds of the array size.", message); 188Assert.Equal($"The path segment '{position}' is invalid for an array index.", message);

Internal\PocoAdapterTest.cs (11)

33Assert.Equal("John", model.Name); 55Assert.Equal(expectedErrorMessage, errorMessage); 96Assert.Equal(expectedErrorMessage, errorMessage); 136Assert.Equal(expectedErrorMessage, errorMessage); 154Assert.Equal("John", model.Name); 178Assert.Equal(expectedErrorMessage, errorMessage); 197Assert.Equal("Joana", model.Name); 199Assert.Equal(expectedErrorMessage, errorMessage); 220Assert.Equal("Oval", model.Rectangle.RectangleProperty); 238Assert.Equal("Joana", model.Name); 260Assert.Equal(expectedErrorMessage, errorMessage);

JsonPatchDocumentGetPathTest.cs (7)

22Assert.Equal("/SimpleObject/IntegerList/-", path); 35Assert.Equal("/3", path); 48Assert.Equal("/key/3", path); 61Assert.Equal("/", path); 74Assert.Equal("/-", path); 87Assert.Equal("/DerivedObject", path); 103Assert.Equal("The expression '(p.IntegerValue >= 4)' is not supported. Supported expressions include member access and indexer expressions.", exception.Message);

JsonPatchDocumentJObjectTest.cs (6)

29Assert.Equal("foo@baz.com", model.CustomData["Emails"][1].Value<string>()); 60Assert.Equal("Bar Baz", model.CustomData["Name"].Value<string>()); 76Assert.Equal("foo@bar.com", model.CustomData["UserName"].Value<string>()); 109Assert.Equal("Bar", model.CustomData["LastName"].Value<string>()); 125Assert.Equal("Foo", model.CustomData["Name"].Value<string>()); 157Assert.Equal("foo@baz.com", model.CustomData["Email"].Value<string>());

JsonPatchDocumentJsonPropertyAttributeTest.cs (5)

24Assert.Equal("/AnotherName", pathToCheck); 40Assert.Equal("John", obj.FirstName); 41Assert.Equal("Doe", obj.LastName); 55Assert.Equal("/StringProperty", fromPath); 57Assert.Equal("/StringProperty2", toPath);

JsonPatchDocumentTest.cs (6)

25Assert.Equal( 43Assert.Equal( 68Assert.Equal("A", targetObject.AnotherStringProperty); 95Assert.Equal("A", targetObject.AnotherStringProperty); 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);

LocalizationTest.cs (1)

118Assert.Equal(expected, await response.Content.ReadAsStringAsync());

RouteDataRequestCultureProviderTest.cs (3)

88Assert.Equal($"{expectedCulture},{expectedUICulture}", data); 134Assert.Equal("en-US,en-US", data); 210Assert.Equal($"{expectedCulture},{expectedUICulture}", data);

AcceptLanguageHeaderRequestCultureProviderTest.cs (5)

38Assert.Equal("ar-SA", requestCulture.Culture.Name); 79Assert.Equal("ar-SA", requestCulture.Culture.Name); 119Assert.Equal("fr-FR", requestCulture.Culture.Name); 164Assert.Equal("ar-YE", requestCulture.Culture.Name); 165Assert.Equal("ar-YE", requestCulture.UICulture.Name);

CookieRequestCultureProviderTest.cs (6)

52Assert.Equal("ar-SA", requestCulture.Culture.Name); 68Assert.Equal("c=ar-SA|uic=ar-SA", value); 104Assert.Equal("en-US", requestCulture.Culture.Name); 153Assert.Equal("en-US", requestCulture.Culture.Name); 225Assert.Equal(expectedMessage, write.State.ToString()); 284Assert.Equal(expectedMessage, write.State.ToString());

CustomRequestCultureProviderTest.cs (1)

49Assert.Equal("ar", requestCulture.Culture.Name);

QueryStringRequestCultureProviderTest.cs (14)

41Assert.Equal("ar-SA", requestCulture.Culture.Name); 42Assert.Equal("ar-YE", requestCulture.UICulture.Name); 75Assert.Equal("en-US", requestCulture.Culture.Name); 76Assert.Equal("en-US", requestCulture.UICulture.Name); 117Assert.Equal("en-US", requestCulture.Culture.Name); 158Assert.Equal("en-US", requestCulture.UICulture.Name); 199Assert.Equal("ar-SA", requestCulture.Culture.Name); 200Assert.Equal("ar-SA", requestCulture.UICulture.Name); 241Assert.Equal("ar-SA", requestCulture.Culture.Name); 242Assert.Equal("ar-SA", requestCulture.UICulture.Name); 288Assert.Equal("ar-SA", requestCulture.Culture.Name); 289Assert.Equal("ar-YE", requestCulture.UICulture.Name); 336Assert.Equal("fr", requestCulture.Culture.ToString()); 337Assert.Equal("fr", requestCulture.UICulture.ToString());

RequestLocalizationMiddlewareTest.cs (2)

53Assert.Equal(parentCulture, requestCulture.RequestCulture.Culture.Name); 54Assert.Equal(parentCulture, requestCulture.RequestCulture.UICulture.Name);

RequestLocalizationOptionsTest.cs (1)

124Assert.Equal(defaultCulture, options.DefaultRequestCulture.Culture.Name);

MiddlewareAnalysisTests.cs (3)

50Assert.Equal("Microsoft.AspNetCore.MiddlewareAnalysis.MiddlewareAnalysisTests+<>c", listener.MiddlewareStarting[1]); 53Assert.Equal("Microsoft.AspNetCore.MiddlewareAnalysis.MiddlewareAnalysisTests+<>c", listener.MiddlewareException[0]); 56Assert.Equal("Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddleware", listener.MiddlewareFinished[0]);

ModelBinding\ModelMetadataTest.cs (8)

301Assert.Equal("item", metadata.Name); 302Assert.Equal("item", metadata.ParameterName); 314Assert.Equal(nameof(string.Length), metadata.Name); 316Assert.Equal(nameof(string.Length), metadata.PropertyName); 333Assert.Equal("displayName", result); 348Assert.Equal("item", result); 362Assert.Equal("Length", result); 375Assert.Equal("String", result);

ModelBinding\ModelStateDictionaryTest.cs (61)

ModelBinding\ValueProviderResultTest.cs (5)

64Assert.Equal("Hi There", result.Values); 65Assert.Equal("Hi There", result.FirstValue); 67Assert.Equal("Hi There", (string)result); 80Assert.Equal("Hi", result.FirstValue); 82Assert.Equal("Hi,There", (string)result);

ApiResponseTypeProviderTest.cs (24)

DefaultApiDescriptionProviderTest.cs (27)

EndpointMetadataApiDescriptionProviderTest.cs (58)

AcceptedAtActionResultTests.cs (5)

30Assert.Equal(actionName, result.ActionName); 43Assert.Equal(controllerName, result.ControllerName); 168Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]); 210Assert.Equal("Location", header.Key); 211Assert.Equal("abc", header.Value);

AcceptedAtRouteResultTests.cs (1)

119Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]);

AcceptedResultTests.cs (2)

81Assert.Equal(location, httpContext.Response.Headers["Location"]); 100Assert.Equal(location, httpContext.Response.Headers["Location"]);

ActionResultOfTTest.cs (3)

19Assert.Equal($"Invalid type parameter '{typeof(FileStreamResult)}' specified for 'ActionResult<T>'.", ex.Message); 30Assert.Equal($"Invalid type parameter '{typeof(FileStreamResult)}' specified for 'ActionResult<T>'.", ex.Message); 41Assert.Equal($"Invalid type parameter '{typeof(TestResult)}' specified for 'ActionResult<T>'.", ex.Message);

ApplicationModels\ApiBehaviorApplicationModelProviderTest.cs (1)

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

ApplicationModels\AttributeRouteModelTests.cs (10)

78Assert.Equal(expected, combined); 103Assert.Equal(expected, combined); 119Assert.Equal(expected, combined); 143Assert.Equal(expected, combined); 155Assert.Equal(expected, result); 174Assert.Equal(expected, ex.Message); 201Assert.Equal(expected, ex.Message); 231Assert.Equal(expectedResult.Template, combined.Template); 261Assert.Equal(expectedTemplate, combined.Template); 277Assert.Equal(expectedName, combined.Name);

ApplicationModels\AuthorizationApplicationModelProviderTest.cs (1)

91Assert.Equal("Authorize", action.ActionName);

ApplicationModels\ConsumesConstraintForFormFileParameterConventionTest.cs (2)

27Assert.Equal("application/json", Assert.Single(consumesAttribute.ContentTypes)); 48Assert.Equal("multipart/form-data", Assert.Single(consumesAttribute.ContentTypes));

ApplicationModels\ControllerActionDescriptorBuilderTest.cs (1)

53Assert.Equal("BoundProperty", property.Name);

ApplicationModels\ControllerActionDescriptorProviderTests.cs (44)

48Assert.Equal($"{controllerTypeInfo.FullName}.{nameof(PersonController.GetPerson)} ({controllerTypeInfo.Assembly.GetName().Name})", descriptor.DisplayName); 92Assert.Equal("OnlyPost", descriptor.ActionName); 109Assert.Equal("Items", descriptor.AttributeRouteInfo.Template); 129Assert.Equal("id", id.Name); 148Assert.Equal("id", id.Name); 154Assert.Equal("entity", entity.Name); 173Assert.Equal("id", id.Name); 179Assert.Equal("ID", upperCaseId.Name); 185Assert.Equal("Id", pascalCaseId.Name); 206Assert.Equal("entity", entity.Name); 227Assert.Equal("entity", entity.Name); 245Assert.Equal("ConventionallyRouted", controller.Value); 248Assert.Equal(nameof(ConventionallyRoutedController.ConventionalAction), actionConstraint.Value); 274metadata => Assert.Equal("ControllerPolicy", Assert.IsType<AuthorizeAttribute>(metadata).Policy), 275metadata => Assert.Equal("ActionPolicy", Assert.IsType<AuthorizeAttribute>(metadata).Policy)); 298Assert.Equal("GET", Assert.Single(httpMethodMetadata.HttpMethods)); 346Assert.Equal("AttributeRouted", controller.Value); 349Assert.Equal(nameof(AttributeRoutedController.AttributeRoutedAction), actionConstraint.Value); 412Assert.Equal("api/Token/value/TokenReplacement/stub/ThisIsAnAction", action.AttributeRouteInfo.Template); 458Assert.Equal("MultipleHttpGet", action.ActionName); 459Assert.Equal("MultiRouteAttributes", action.ControllerName); 483Assert.Equal("MultiRouteAttributes", action.ControllerName); 508Assert.Equal("MultiRouteAttributes", action.ControllerName); 517Assert.Equal("Override", action.AttributeRouteInfo.Template); 535Assert.Equal("MultiRouteAttributes", action.ControllerName); 574Assert.Equal("MultiRouteAttributes", action.ControllerName); 652Assert.Equal("Products/list", action.AttributeRouteInfo.Template); 743Assert.Equal("Action", action.ActionName); 744Assert.Equal("OnlyRoute", action.ControllerName); 747Assert.Equal("Products/Index", action.AttributeRouteInfo.Template); 883Assert.Equal(expectedMessage, ex.Message); 906Assert.Equal("ConventionalAndAttributeRoutedActionsWithArea", controllerDefault.Value); 909Assert.Equal("Index", actionDefault.Value); 912Assert.Equal("Home", areaDefault.Value); 926Assert.Equal("stub/ThisIsAnAction", action.AttributeRouteInfo.Template); 941Assert.Equal("stub/{controller}/{action}", action.AttributeRouteInfo.Template); 1021Assert.Equal("Store", action.GetProperty<ApiDescriptionActionData>().GroupName); 1035Assert.Equal("Blog", action.GetProperty<ApiDescriptionActionData>().GroupName); 1051Assert.Equal("Blog", action.GetProperty<ApiDescriptionActionData>().GroupName); 1054Assert.Equal("Store", action.GetProperty<ApiDescriptionActionData>().GroupName); 1103Assert.Equal(expected, ex.Message); 1411Assert.Equal(expectedLines[i], actualLines[i]); 1428Assert.Equal(orderedExpectedLines[i], orderedActualLines[i]); 1433Assert.Equal(expectedLines[i], actualLines[i]);

ApplicationModels\DefaultApplicationModelProviderTest.cs (25)

ApplicationModels\InferParameterBindingInfoConventionTest.cs (15)

68Assert.Equal(expected, ex.Message); 87Assert.Equal(expected, ex.Message); 106Assert.Equal(expected, ex.Message); 126Assert.Equal("model", parameter.Name); 135Assert.Equal("cancellationToken", parameter.Name); 160Assert.Equal("model", parameter.Name); 186Assert.Equal("model", parameter.Name); 212Assert.Equal("model", parameter.Name); 239Assert.Equal("top", bindingInfo.BinderModelName); 281Assert.Equal("foo", bindingInfo.BinderModelName); 684Assert.Equal("top", bindingInfo.BinderModelName); 725Assert.Equal("gps", bindingInfo.BinderModelName); 788Assert.Equal("ids", bindingInfo.BinderModelName); 830Assert.Equal("top", bindingInfo.BinderModelName); 871Assert.Equal("gps", bindingInfo.BinderModelName);

ApplicationParts\AssemblyPartTest.cs (1)

18Assert.Equal("Microsoft.AspNetCore.Mvc.Core.Test", name);

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)

27Assert.Equal( 85Assert.Equal(expected, ex.Message);

Builder\MvcAreaRouteBuilderExtensionsTest.cs (29)

ConsumesAttributeTests.cs (5)

29Assert.Equal(expectedMessage, exception.Message); 47Assert.Equal("The header contains invalid values at index 0: '" + (invalidContentType ?? "<null>") + "'", 68Assert.Equal( 399t => Assert.Equal("application/json", t), 400t => Assert.Equal("text/json", t));

ContentResultTest.cs (2)

138Assert.Equal(expectedContentType, finalResponseContentType); 243Assert.Equal(content, actualContent);

ControllerBaseTest.cs (133)

Controllers\ControllerBinderDelegateProviderTest.cs (5)

417Assert.Equal( 513Assert.Equal( 648Assert.Equal("Hello", controller.StringProperty); 1061Assert.Equal("Hello", controller.StringProperty); 1246Assert.Equal("Some error", error.ErrorMessage);

Controllers\DefaultControllerFactoryTest.cs (1)

180Assert.Equal(

Controllers\ServiceBasedControllerActivatorTest.cs (1)

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

CreatedAtActionResultTests.cs (1)

41Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]);

CreatedAtRouteResultTests.cs (1)

55Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]);

CreatedResultTests.cs (2)

75Assert.Equal(location, httpContext.Response.Headers["Location"]); 109Assert.Equal(location, httpContext.Response.Headers["Location"]);

DependencyInjection\ApiBehaviorOptionsSetupTest.cs (5)

46Assert.Equal("One or more validation errors occurred.", problemDetails.Title); 47Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.1", problemDetails.Type); 68Assert.Equal("One or more validation errors occurred.", problemDetails.Title); 69Assert.Equal(link, problemDetails.Type); 92Assert.Equal("One or more validation errors occurred.", problemDetails.Title);

FileResultHelperTest.cs (10)

25Assert.Equal("text/plain", result.ContentType.ToString()); 48Assert.Equal("application/my-type", httpContext.Response.Headers["Content-Type"]); 49Assert.Equal(@"attachment; filename=""some\\file""; filename*=UTF-8''some%5Cfile", httpContext.Response.Headers["Content-Disposition"]); 69Assert.Equal("application/my-type", httpContext.Response.Headers["Content-Type"]); 70Assert.Equal(@"attachment; filename=""ABCXYZabcxyz012789!@#$%^&*()-=_+.:~_""; filename*=UTF-8''ABCXYZabcxyz012789!%40#$%25^&%2A%28%29-%3D_+.%3A~%CE%94", 95Assert.Equal("application/my-type", httpContext.Response.ContentType); 116Assert.Equal("application/my-type", httpContext.Response.ContentType); 117Assert.Equal("attachment; filename=filename.ext; filename*=UTF-8''filename.ext", httpContext.Response.Headers["Content-Disposition"]); 218Assert.Equal(expectedOutput, actual); 234Assert.Equal("bytes", httpContext.Response.Headers.AcceptRanges);

FileStreamResultTest.cs (2)

66Assert.Equal(expectedMediaType, result.ContentType); 89Assert.Equal(expectedMediaType, result.ContentType);

Filters\DisableRequestSizeLimitFilterTest.cs (3)

68Assert.Equal($"A request body size limit could not be applied. This server does not support the IHttpRequestBodySizeFeature.", 91Assert.Equal($"A request body size limit could not be applied. The IHttpRequestBodySizeFeature for the server is read-only.", write.State.ToString()); 112Assert.Equal($"The request body size limit has been disabled.", write.State.ToString());

Filters\FilterFactoryTest.cs (2)

240Assert.Equal("foo", request1Filter3.Data); 253Assert.Equal("bar", request2Filter3.Data);

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

127Assert.Equal(expectedHeaderValue, response.Headers[expectedHeader]); 161Assert.Equal(expectedMessage, exception.Message);

Filters\RequestFormLimitsFilterTest.cs (3)

74Assert.Equal( 99Assert.Equal( 125Assert.Equal(

Filters\RequestSizeLimitFilterTest.cs (3)

72Assert.Equal($"A request body size limit could not be applied. This server does not support the IHttpRequestBodySizeFeature.", 96Assert.Equal($"A request body size limit could not be applied. The IHttpRequestBodySizeFeature for the server is read-only.", write.State.ToString()); 118Assert.Equal($"The maximum request body size has been set to 12345.", write.State.ToString());

Filters\ResponseCacheFilterExecutorTest.cs (14)

Formatters\FormatFilterTest.cs (2)

299Assert.Equal(expected, filter.GetFormat(context)); 318Assert.Equal(expected, filter.GetFormat(context));

Formatters\InputFormatterTest.cs (4)

344Assert.Collection(results, c => Assert.Equal("text/xml", c)); 361c => Assert.Equal("application/xml", c), 362c => Assert.Equal("text/xml", c)); 377Assert.Collection(results, c => Assert.Equal("text/xml", c));

Formatters\JsonInputFormatterTestBase.cs (18)

Formatters\JsonOutputFormatterTestBase.cs (1)

137Assert.Equal(expectedContent, actualContent);

Formatters\MediaTypeTest.cs (1)

146Assert.Equal(expectedMediaType, result);

Formatters\OutputFormatterTests.cs (4)

29Assert.Equal(formatter.SupportedMediaTypes[0].ToString(), context.ContentType.ToString()); 101Assert.Equal(requestedContentType, context.ContentType.ToString()); 144Assert.Equal("application/json", contentType.ToString()); 165Assert.Equal("application/vnd.test+json;v=2", contentType.ToString());

Formatters\SystemTextJsonInputFormatterTest.cs (4)

83Assert.Equal("$[1]", kvp.Key); 107Assert.Equal("The supplied value is invalid.", error.ErrorMessage); 128Assert.Equal("The supplied value is invalid.", error.ErrorMessage); 158Assert.Equal(expectedMessage, modelError.ErrorMessage);

Formatters\SystemTextJsonOutputFormatterTest.cs (4)

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

Formatters\TextOutputFormatterTests.cs (1)

254Assert.Equal(expectedValue, Assert.Single(result).Value.Value);

Infrastructure\ActionMethodExecutorTest.cs (15)

Infrastructure\ActionSelectorTest.cs (5)

516Assert.Equal(expectedMessage, write.State?.ToString()); 844Assert.Equal(expectedMessage, ex.Message); 864Assert.Equal("Patch", result.ActionName); 885Assert.Equal("Put", result.ActionName); 970Assert.Equal(actionName, result.ActionName);

Infrastructure\AsyncEnumerableReaderTest.cs (1)

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

Infrastructure\ControllerActionInvokerTest.cs (11)

1582m => Assert.Equal($"Route matched with {{}}. Executing controller action with signature {actionSignature} on controller {controllerName}.", m), 1583m => Assert.Equal("Execution plan of authorization filters (in the following order): None", m), 1584m => Assert.Equal("Execution plan of resource filters (in the following order): None", m), 1585m => Assert.Equal("Execution plan of action filters (in the following order): None", m), 1586m => Assert.Equal("Execution plan of exception filters (in the following order): None", m), 1587m => Assert.Equal("Execution plan of result filters (in the following order): None", m), 1588m => Assert.Equal($"Executing controller factory for controller {controllerName}", m), 1589m => Assert.Equal($"Executed controller factory for controller {controllerName}", m), 1590m => Assert.Equal($"Executing action method {actionName} - Validation state: Valid", m), 1592m => Assert.Equal($"Before executing action result {actionResultName}.", m), 1593m => Assert.Equal($"After executing action result {actionResultName}.", m),

Infrastructure\DefaultApiProblemDetailsWriterTest.cs (8)

48Assert.Equal(expectedProblem.Type, problemDetails.Type); 49Assert.Equal(expectedProblem.Title, problemDetails.Title); 50Assert.Equal(expectedProblem.Detail, problemDetails.Detail); 51Assert.Equal(expectedProblem.Instance, problemDetails.Instance); 87Assert.Equal(expectedProblem.Type, problemDetails.Type); 88Assert.Equal(expectedProblem.Title, problemDetails.Title); 89Assert.Equal(expectedProblem.Detail, problemDetails.Detail); 90Assert.Equal(expectedProblem.Instance, problemDetails.Instance);

Infrastructure\JsonResultExecutorTestBase.cs (13)

Infrastructure\ObjectResultExecutorTest.cs (5)

88Assert.Equal("application/json; charset=utf-8", httpContext.Response.ContentType); 299Assert.Equal( 320Assert.Equal(expected, exception.Message); 358Assert.Equal(expectedMessage, exception.Message); 395Assert.Equal(expectedContentType, actionContext.HttpContext.Response.Headers.ContentType);

Infrastructure\ProblemDetailsFactoryTest.cs (23)

23Assert.Equal("An error occurred while processing your request.", problemDetails.Title); 24Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.6.1", problemDetails.Type); 31Assert.Equal("traceId", kvp.Key); 44Assert.Equal("Not Acceptable", problemDetails.Title); 45Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.7", problemDetails.Type); 52Assert.Equal("traceId", kvp.Key); 67Assert.Equal(title, problemDetails.Title); 68Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.7", problemDetails.Type); 70Assert.Equal(detail, problemDetails.Detail); 75Assert.Equal("traceId", kvp.Key); 90Assert.Equal("One or more validation errors occurred.", problemDetails.Title); 91Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.1", problemDetails.Type); 98Assert.Equal("traceId", kvp.Key); 105Assert.Equal("some-key", kvp.Key); 120Assert.Equal("One or more validation errors occurred.", problemDetails.Title); 121Assert.Equal("https://tools.ietf.org/html/rfc4918#section-11.2", problemDetails.Type); 128Assert.Equal("traceId", kvp.Key); 135Assert.Equal("some-key", kvp.Key); 152Assert.Equal(title, problemDetails.Title); 153Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.1", problemDetails.Type); 154Assert.Equal(instance, problemDetails.Instance); 160Assert.Equal("traceId", kvp.Key); 167Assert.Equal("some-key", kvp.Key);

Infrastructure\ProblemDetalsClientErrorFactoryTest.cs (2)

61Assert.Equal("Some link", problemDetails.Type); 62Assert.Equal("Summary", problemDetails.Title);

Infrastructure\ValidationProblemDetailsJsonConverterTest.cs (22)

32Assert.Equal(type, problemDetails.Type); 33Assert.Equal(title, problemDetails.Title); 35Assert.Equal(instance, problemDetails.Instance); 36Assert.Equal(detail, problemDetails.Detail); 41Assert.Equal("traceId", kvp.Key); 42Assert.Equal(traceId, kvp.Value.ToString()); 48Assert.Equal("key0", kvp.Key); 53Assert.Equal("key1", kvp.Key); 74Assert.Equal(type, problemDetails.Type); 75Assert.Equal(title, problemDetails.Title); 81Assert.Equal("traceId", kvp.Key); 82Assert.Equal(traceId, kvp.Value.ToString()); 88Assert.Equal("key0", kvp.Key); 93Assert.Equal("key1", kvp.Key); 112Assert.Equal(type, problemDetails.Type); 113Assert.Equal(title, problemDetails.Title); 119Assert.Equal("traceId", kvp.Key); 120Assert.Equal(traceId, kvp.Value.ToString()); 126Assert.Equal("key0", kvp.Key); 131Assert.Equal("key1", kvp.Key); 157Assert.Equal(expectedJSON, json); 190Assert.Equal(expectedJSON, json);

LocalRedirectResultTest.cs (3)

78Assert.Equal(expectedPath, httpContext.Response.Headers.Location.ToString()); 100Assert.Equal( 122Assert.Equal(

ModelBinding\Binders\ArrayModelBinderTest.cs (2)

119Assert.Equal("modelName", keyValuePair.Key); 121Assert.Equal("A value for the 'fieldName' parameter or property was not provided.", error.ErrorMessage);

ModelBinding\Binders\BinderTypeModelBinderTest.cs (1)

49Assert.Equal(model.Name, person.Name);

ModelBinding\Binders\BodyModelBinderProviderTest.cs (1)

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

ModelBinding\Binders\BodyModelBinderTests.cs (28)

71Assert.Equal(string.Empty, entry.Key); 96Assert.Equal("custom", entry.Key); 154Assert.Equal("custom", entry.Key); 155Assert.Equal("Customized error message", entry.Value.Errors.Single().ErrorMessage); 244Assert.Equal("Unsupported content type ''.", bindingContext.ModelState[bindingContext.BinderModelName].Errors[0].Exception.Message); 276Assert.Equal(string.Empty, entry.Key); 278Assert.Equal("Bad input!!", errorMessage); 319Assert.Equal(string.Empty, entry.Key); 321Assert.Equal("An error occurred while deserializing input data.", errorMessage); 350Assert.Equal(string.Empty, entry.Key); 390Assert.Equal(string.Empty, entry.Key); 392Assert.Equal("An error occurred while deserializing input data.", errorMessage); 421Assert.Equal(string.Empty, entry.Key); 459Assert.Equal("Unable to read input stream!!", exception.Message); 501Assert.Equal(string.Empty, entry.Key); 503Assert.Equal("Unable to read input stream!!", errorMessage); 528Assert.Equal("Unable to read input stream!!", exception.Message); 557Assert.Equal(string.Empty, entry.Key); 559Assert.Equal("Unsupported content type 'text/xyz'.", errorMessage); 613Assert.Equal($"Attempting to bind model of type '{typeof(Person)}' using the name 'someName' in request data ...", writeList[0].State.ToString()); 614Assert.Equal($"Rejected input formatter '{typeof(TestInputFormatter)}' for content type 'application/json'.", writeList[1].State.ToString()); 615Assert.Equal($"Selected input formatter '{typeof(TestInputFormatter)}' for content type 'application/json'.", writeList[2].State.ToString()); 643write => Assert.Equal( 645write => Assert.Equal( 647write => Assert.Equal( 649write => Assert.Equal( 651write => Assert.Equal( 653write => Assert.Equal(

ModelBinding\Binders\ByteArrayModelBinderTests.cs (2)

32Assert.Equal("foo", modelState.Key); 78Assert.Equal(expected, error.ErrorMessage);

ModelBinding\Binders\CollectionModelBinderTest.cs (3)

305Assert.Equal("modelName", keyValuePair.Key); 307Assert.Equal("A value for the 'fieldName' parameter or property was not provided.", error.ErrorMessage); 461Assert.Equal("someName", mbc.ModelName);

ModelBinding\Binders\ComplexObjectModelBinderTest.cs (15)

317Assert.Equal(string.Empty, keyValuePair.Key); 319Assert.Equal("A value for the 'fieldName' parameter or property was not provided.", error.ErrorMessage); 361Assert.Equal(string.Empty, keyValuePair.Key); 363Assert.Equal("A value for the 'fieldName' parameter or property was not provided.", error.ErrorMessage); 405Assert.Equal(string.Empty, keyValuePair.Key); 407Assert.Equal("A value for the 'fieldName' parameter or property was not provided.", error.ErrorMessage); 624Assert.Equal("A value for the 'Age' parameter or property was not provided.", modelError.ErrorMessage); 689Assert.Equal("A value for the 'Age' parameter or property was not provided.", modelError.ErrorMessage); 728Assert.Equal(string.Empty, modelError.ErrorMessage); 855Assert.Equal("John", model.FirstName); 856Assert.Equal("Doe", model.LastName); 903Assert.Equal("preinitialized", person.PropertyWithInitializedValue); 927Assert.Equal("preinitialized", person.PropertyWithInitializedValueAndDefault); 1057Assert.Equal("Date of death can't be before date of birth. (Parameter 'value')", 1080Assert.Equal("This is a different exception. (Parameter 'value')",

ModelBinding\Binders\ComplexTypeModelBinderTest.cs (18)

377Assert.Equal(string.Empty, keyValuePair.Key); 379Assert.Equal("A value for the 'fieldName' parameter or property was not provided.", error.ErrorMessage); 421Assert.Equal(string.Empty, keyValuePair.Key); 423Assert.Equal("A value for the 'fieldName' parameter or property was not provided.", error.ErrorMessage); 465Assert.Equal(string.Empty, keyValuePair.Key); 467Assert.Equal("A value for the 'fieldName' parameter or property was not provided.", error.ErrorMessage); 540Assert.Equal( 565Assert.Equal(expectedMessage, exception.Message); 582Assert.Equal( 802Assert.Equal("A value for the 'Age' parameter or property was not provided.", modelError.ErrorMessage); 836Assert.Equal("A value for the 'Age' parameter or property was not provided.", modelError.ErrorMessage); 872Assert.Equal(string.Empty, modelError.ErrorMessage); 991Assert.Equal("John", model.FirstName); 992Assert.Equal("Doe", model.LastName); 1065Assert.Equal("preinitialized", person.PropertyWithInitializedValue); 1089Assert.Equal("preinitialized", person.PropertyWithInitializedValueAndDefault); 1219Assert.Equal("Date of death can't be before date of birth. (Parameter 'value')", 1242Assert.Equal("This is a different exception. (Parameter 'value')",

ModelBinding\Binders\DateTimeModelBinderTest.cs (2)

50Assert.Equal(message, error.ErrorMessage); 151Assert.Equal("theModelName", entry.Key);

ModelBinding\Binders\DictionaryModelBinderTest.cs (6)

48Assert.Equal("forty-two", dictionary[42]); 49Assert.Equal("eighty-four", dictionary[84]); 89Assert.Equal("forty-two", dictionary[42]); 90Assert.Equal("eighty-four", dictionary[84]); 491Assert.Equal("modelName", keyValuePair.Key); 493Assert.Equal("A value for the 'fieldName' parameter or property was not provided.", error.ErrorMessage);

ModelBinding\Binders\EnumTypeModelBinderTest.cs (7)

44Assert.Equal(message, error.ErrorMessage); 88Assert.Equal(expected, boundModel.ToString()); 112Assert.Equal(expected, boundModel.ToString()); 149Assert.Equal(message, error.ErrorMessage); 174Assert.Equal(expected, boundModel.ToString()); 199Assert.Equal(expected, boundModel.ToString()); 232Assert.Equal(message, error.ErrorMessage);

ModelBinding\Binders\FloatingPointTypeModelBinderTestOfT.cs (2)

72Assert.Equal(message, error.ErrorMessage); 232Assert.Equal("theModelName", entry.Key);

ModelBinding\Binders\FormCollectionModelBinderProviderTest.cs (1)

22Assert.Equal(

ModelBinding\Binders\FormCollectionModelBinderTest.cs (2)

36Assert.Equal("value1", form["field1"]); 37Assert.Equal("value2", form["field2"]);

ModelBinding\Binders\FormFileModelBinderTest.cs (9)

33Assert.Equal("file", entry.Key); 67Assert.Equal("file", entry.Key); 107Assert.Equal($"{propertyName}", entry.Key); 149Assert.Equal($"FileList.{propertyName}", entry.Key); 183Assert.Equal("[myFile]", entry.Key); 219Assert.Equal("FileDictionary[myFile]", entry.Key); 240Assert.Equal("file", entry.Key); 288Assert.Equal("file1.txt", file.FileName); 355Assert.Equal(expected, file.Name);

ModelBinding\Binders\HeaderModelBinderTests.cs (3)

295Assert.Equal($"The value '{headerValue}' is not valid.", error.ErrorMessage); 319Assert.Equal($"The value '{headerValues[0]}' is not valid.", entry.Errors[0].ErrorMessage); 320Assert.Equal($"The value '{headerValues[1]}' is not valid.", entry.Errors[1].ErrorMessage);

ModelBinding\Binders\KeyValuePairModelBinderTest.cs (5)

31Assert.Equal("someName", bindingContext.ModelName); 33Assert.Equal("A value is required.", error.ErrorMessage); 55Assert.Equal("someName", bindingContext.ModelName); 59Assert.Equal("A value is required.", error.ErrorMessage); 125Assert.Equal("someName.Key", context.ModelName);

ModelBinding\Binders\SimpleTypeModelBinderTest.cs (4)

155Assert.Equal(message, error.ErrorMessage); 326Assert.Equal("theModelName", entry.Key); 327Assert.Equal("32,000", entry.Value.AttemptedValue); 331Assert.Equal("The value '32,000' is not valid.", error.ErrorMessage);

ModelBinding\Binders\TryParseTypeModelBinderTest.cs (4)

104Assert.Equal(message, error.ErrorMessage); 252Assert.Equal("theModelName", entry.Key); 253Assert.Equal("32,000", entry.Value.AttemptedValue); 257Assert.Equal("The value '32,000' is not valid.", error.ErrorMessage);

ModelBinding\CompositeValueProviderTest.cs (2)

85Assert.Equal("prefix-test", result.Key); 86Assert.Equal("some-value", result.Value);

ModelBinding\DefaultModelBindingContextTest.cs (2)

53Assert.Equal("fieldName", bindingContext.FieldName); 57Assert.Equal("modelprefix.fieldName", bindingContext.ModelName);

ModelBinding\ElementalValueProviderTests.cs (1)

82Assert.Equal("hi", (string)result);

ModelBinding\EnumerableValueProviderTest.cs (2)

167Assert.Equal("someOtherValue", (string)result); 183Assert.Equal("someValue1,someValue2", (string)result);

ModelBinding\JQueryFormValueProviderFactoryTest.cs (1)

114Assert.Equal("found", (string)result);

ModelBinding\JQueryFormValueProviderTest.cs (1)

47Assert.Equal("some-value", (string)result);

ModelBinding\JQueryQueryStringValueProviderFactoryTest.cs (1)

80Assert.Equal("found", (string)result);

ModelBinding\JQueryQueryStringValueProviderTest.cs (1)

50Assert.Equal("some-value", (string)result);

ModelBinding\Metadata\DefaultBindingMetadataProviderTest.cs (9)

78Assert.Equal("Product", context.BindingMetadata.BinderModelName); 102Assert.Equal("Product", context.BindingMetadata.BinderModelName); 403a => Assert.Equal("Instance1", ((CustomAttribute)a).Identifier), 404a => Assert.Equal("Instance2", ((CustomAttribute)a).Identifier)); 746p => Assert.Equal("name", p.Name)); 812p => Assert.Equal("Name", p.Name), 813p => Assert.Equal("Value", p.Name)); 843p => Assert.Equal("Name", p.Name), 844p => Assert.Equal("Age", p.Name));

ModelBinding\Metadata\DefaultModelMetadataProviderTest.cs (25)

ModelBinding\Metadata\DefaultModelMetadataTest.cs (4)

110Assert.Equal("Message", metadata.PropertyName); 147Assert.Equal(newFormat, result); 184Assert.Equal(newFormat, result); 221Assert.Equal(newDisplay, result);

ModelBinding\Metadata\DisplayMetadataTest.cs (30)

ModelBinding\Metadata\ModelAttributesTest.cs (1)

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

ModelBinding\Metadata\SystemTextJsonValidationMetadataProviderTest.cs (3)

26Assert.Equal(propertyName, context.ValidationMetadata.ValidationModelName); 44Assert.Equal(JsonNamingPolicy.CamelCase.ConvertName(propertyName), context.ValidationMetadata.ValidationModelName); 79Assert.Equal(namingPolicy.ConvertName(propertyName), context.ValidationMetadata.ValidationModelName);

ModelBinding\ModelBinderFactoryTest.cs (2)

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

ModelBinding\ModelBindingHelperTest.cs (23)

ModelBinding\ParameterBinderTest.cs (24)

ModelBinding\PrefixContainerTest.cs (18)

213Assert.Equal("0", item.Key); 214Assert.Equal("[0]", item.Value); 218Assert.Equal("foo", item.Key); 219Assert.Equal("foo", item.Value); 223Assert.Equal("item1", item.Key); 224Assert.Equal("[item1]", item.Value); 256Assert.Equal("0", item.Key); 257Assert.Equal("foo[0]", item.Value); 261Assert.Equal("1", item.Key); 262Assert.Equal("foo[1]", item.Value); 266Assert.Equal("age", item.Key); 267Assert.Equal("foo.age", item.Value); 271Assert.Equal("name", item.Key); 272Assert.Equal("foo.name", item.Value); 290Assert.Equal("0", item.Key); 291Assert.Equal("person[0].address[0]", item.Value); 295Assert.Equal("1", item.Key); 296Assert.Equal("person[0].address[1]", item.Value);

ModelBinding\RouteValueProviderTests.cs (5)

43Assert.Equal("test-value", (string)result); 61Assert.Equal("10/31/2018 07:37:38 -07:00", (string)result); 80Assert.Equal(expected, (string)result); 97Assert.Equal(string.Empty, (string)result); 175Assert.Equal(expectedValue, (string)result);

ModelBinding\Validation\DefaultCollectionValidationStrategyTest.cs (9)

27Assert.Equal("prefix[0]", e.Key); 33Assert.Equal("prefix[1]", e.Key); 39Assert.Equal("prefix[2]", e.Key); 67Assert.Equal("prefix[0]", e.Key); 73Assert.Equal("prefix[1]", e.Key); 79Assert.Equal("prefix[2]", e.Key); 102Assert.Equal("prefix[0]", e.Key); 108Assert.Equal("prefix[1]", e.Key); 114Assert.Equal("prefix[2]", e.Key);

ModelBinding\Validation\DefaultComplexObjectValidationStrategyTest.cs (12)

34Assert.Equal("prefix.Age", entry.Key); 40Assert.Equal("prefix.Id", entry.Key); 46Assert.Equal("prefix.Name", entry.Key); 74Assert.Equal("prefix.AGE", entry.Key); 80Assert.Equal("prefix.ID", entry.Key); 86Assert.Equal("prefix.NAME", entry.Key); 108Assert.Equal("prefix.Age", entry.Key); 114Assert.Equal("prefix.Id", entry.Key); 120Assert.Equal("prefix.Name", entry.Key); 143Assert.Equal("prefix.Age", entry.Key); 149Assert.Equal("prefix.Id", entry.Key); 155Assert.Equal("prefix.Name", entry.Key);

ModelBinding\Validation\DefaultModelValidatorProviderTest.cs (2)

49Assert.Equal("Class", validator.Tag); 71Assert.Equal("Property", validator.Tag);

ModelBinding\Validation\DefaultObjectValidatorTests.cs (48)

ModelBinding\Validation\ExplicitIndexCollectionValidationStrategyTest.cs (13)

27Assert.Equal("prefix[one]", e.Key); 33Assert.Equal("prefix[two]", e.Key); 39Assert.Equal("prefix[zero]", e.Key); 67Assert.Equal("prefix[one]", e.Key); 73Assert.Equal("prefix[two]", e.Key); 79Assert.Equal("prefix[zero]", e.Key); 102Assert.Equal("prefix[one]", e.Key); 108Assert.Equal("prefix[two]", e.Key); 114Assert.Equal("prefix[zero]", e.Key); 138Assert.Equal("prefix[one]", e.Key); 144Assert.Equal("prefix[zero]", e.Key); 168Assert.Equal("prefix[one]", e.Key); 174Assert.Equal("prefix[zero]", e.Key);

ModelBinding\Validation\ShortFormDictionaryValidationStrategyTest.cs (7)

38Assert.Equal("prefix[2]", e.Key); 44Assert.Equal("prefix[3]", e.Key); 50Assert.Equal("prefix[5]", e.Key); 85Assert.Equal("prefix[2]", e.Key); 91Assert.Equal("prefix[3]", e.Key); 126Assert.Equal("prefix[2]", e.Key); 132Assert.Equal("prefix[3]", e.Key);

MvcCoreLoggerExtensionsTest.cs (11)

60Assert.Equal( 90Assert.Equal( 119Assert.Equal( 206Assert.Equal( 252Assert.Equal( 298Assert.Equal( 344Assert.Equal( 390Assert.Equal( 420Assert.Equal( 449Assert.Equal( 477Assert.Equal(

MvcOptionsTest.cs (1)

16Assert.Equal("value", ex.ParamName);

ProducesAttributeTests.cs (2)

102Assert.Equal("The header contains invalid values at index 0: '" + (invalidContentType ?? "<null>") + "'", 125Assert.Equal(

ProducesResponseTypeAttributeTests.cs (1)

44Assert.Equal(

RedirectToActionResultTest.cs (2)

108Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]); 136Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]);

RedirectToPageResultTest.cs (13)

115Assert.Equal("test", value.Key); 120Assert.Equal("page", value.Key); 125Assert.Equal("handler", value.Key); 128Assert.Equal("ftp", context.Protocol); 129Assert.Equal("test-fragment", context.Fragment); 169Assert.Equal("test", value.Key); 174Assert.Equal("page", value.Key); 179Assert.Equal("handler", value.Key); 182Assert.Equal("ftp", context.Protocol); 183Assert.Equal("test-fragment", context.Fragment); 231Assert.Equal("page", value.Key); 282Assert.Equal("page", value.Key); 287Assert.Equal("handler", value.Key);

RedirectToRouteResultTest.cs (3)

112Assert.Equal(locationUrl, httpContext.Response.Headers["Location"]); 137Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]); 162Assert.Equal(expectedUrl, httpContext.Response.Headers["Location"]);

RequireHttpsAttributeTests.cs (2)

101Assert.Equal(expectedUrl, result.Url); 189Assert.Equal(expectedUrl, result.Url);

ResponseCacheAttributeTest.cs (4)

56Assert.Equal("The 'HelloWorld' cache profile is not defined.", ex.Message); 170Assert.Equal(expectedProfile.VaryByHeader, responseCacheFilter.VaryByHeader); 226Assert.Equal("Accept", data); 318Assert.Equal(

Routing\ActionEndpointDataSourceBaseTest.cs (4)

37Assert.Equal("/Template!", endpoint.RoutePattern.RawText); 61(e) => Assert.Equal("/test", Assert.IsType<RouteEndpoint>(e).RoutePattern.RawText)); 99Assert.Equal("/test", routePattern.RawText); 121Assert.Equal("/test", routePattern.RawText);

Routing\ActionEndpointFactoryTest.cs (10)

50Assert.Equal(string.Empty, routeNameMetadata.RouteName); 149Assert.Equal("{controller}/{action}/{id?}", endpoint.RoutePattern.RawText); 184Assert.Equal("{controller}/{action=TESTACTION}/{id?}", endpoint.RoutePattern.RawText); 214Assert.Equal( 232Assert.Equal("{controller}/{action}/{page}", endpoint.RoutePattern.RawText); 250Assert.Equal("{controller}/{action}/{page}", endpoint.RoutePattern.RawText); 254Assert.Equal("Test", endpoint.Metadata.GetMetadata<IRouteNameMetadata>().RouteName); 255Assert.Equal("Test", endpoint.Metadata.GetMetadata<IEndpointNameMetadata>().EndpointName); 347Assert.Equal("{controller}/{action}/{id?}", matcherEndpoint.RoutePattern.RawText); 355Assert.Equal("named/{controller}/{action}/{id?}", matcherEndpoint.RoutePattern.RawText);

Routing\AttributeRouteTest.cs (35)

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\ControllerActionEndpointDataSourceTest.cs (46)

Routing\ControllerLinkGeneratorExtensionsTest.cs (9)

27Assert.Equal("host", exception.ParamName); 31Assert.Equal("action", exception.ParamName); 35Assert.Equal("controller", exception.ParamName); 39Assert.Equal("scheme", exception.ParamName); 69Assert.Equal("/Foo/Bar%3Fencodeme%3F/Home/Index/?query=some%3Fquery#Fragment?", path); 97Assert.Equal("/Foo/Bar%3Fencodeme%3F/Home/Index/?query=some%3Fquery#Fragment?", path); 128Assert.Equal("/Foo/Bar%3Fencodeme%3F/Home/Index/?query=some%3Fquery#Fragment?", path); 158Assert.Equal("http://example.com/Foo/Bar%3Fencodeme%3F/Home/Index/?query=some%3Fquery#Fragment?", path); 189Assert.Equal("http://example.com/Foo/Bar%3Fencodeme%3F/Home/Index/?query=some%3Fquery#Fragment?", uri);

Routing\DynamicControllerEndpointMatcherPolicyTest.cs (11)

194Assert.Equal("action", kvp.Key); 199Assert.Equal("controller", kvp.Key); 272Assert.Equal("action", kvp.Key); 277Assert.Equal("controller", kvp.Key); 282Assert.Equal("slug", kvp.Key); 287Assert.Equal("state", kvp.Key); 372Assert.Equal("action", kvp.Key); 377Assert.Equal("controller", kvp.Key); 382Assert.Equal("slug", kvp.Key); 387Assert.Equal("state", kvp.Key); 390Assert.Equal("ReplacedEndpoint", candidates[0].Endpoint.DisplayName);

Routing\EndpointRoutingUrlHelperTest.cs (3)

36Assert.Equal("/" + endpoint2.RoutePattern.RawText, url); 69Assert.Equal("/api/orders/500", url); 95Assert.Equal("/api/orders/10", url);

Routing\KnownRouteValueConstraintTests.cs (1)

199Assert.Equal(

Routing\MvcRouteHandlerTests.cs (1)

46Assert.Equal(expectedMessage, write.State?.ToString());

Routing\PageLinkGeneratorExtensionsTest.cs (5)

40Assert.Equal("/Foo/Bar%3Fencodeme%3F/About/18/?query=some%3Fquery#Fragment?", path); 68Assert.Equal("/Foo/Bar%3Fencodeme%3F/Admin/ManageUsers/Delete/?user=jamesnk&query=some%3Fquery#Fragment?", path); 98Assert.Equal("/Foo/Bar%3Fencodeme%3F/About/19/?query=some%3Fquery#Fragment?", path); 128Assert.Equal("http://example.com/Foo/Bar%3Fencodeme%3F/About/19/?query=some%3Fquery#Fragment?", path); 159Assert.Equal("http://example.com/Foo/Bar%3Fencodeme%3F/Admin/ManageUsers/?query=some%3Fquery#Fragment?", uri);

Routing\RoutePatternWriterTests.cs (1)

30Assert.Equal(template, sb.ToString());

Routing\UrlHelperBaseTest.cs (3)

50Assert.Equal(expected, builder.ToString()); 71Assert.Equal(expected, builder.ToString()); 99Assert.Equal(expected, url);

Routing\UrlHelperExtensionsTest.cs (49)

Routing\UrlHelperTestBase.cs (32)

Routing\ViewEnginePathTest.cs (1)

19Assert.Equal(expected, result);

SerializableErrorTests.cs (5)

24Assert.Equal("Test Error 1", arr[0]); 25Assert.Equal("Test Error 2", arr[1]); 26Assert.Equal("Test Error 3", (serializableError["key2"] as string[])[0]); 41Assert.Equal("x", arr[0]); 56Assert.Equal("The input was not valid.", arr[0]);

src\Shared\ResultsTests\FileContentResultTestBase.cs (24)

src\Shared\ResultsTests\FileStreamResultTestBase.cs (28)

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

src\Shared\ResultsTests\RedirectResultTestBase.cs (2)

34Assert.Equal(expectedPath, httpContext.Response.Headers.Location.ToString()); 57Assert.Equal(expectedPath, httpContext.Response.Headers.Location.ToString());

src\Shared\ResultsTests\VirtualFileResultTestBase.cs (25)

ValidationProblemDetailsTest.cs (9)

17Assert.Equal("One or more validation errors occurred.", problemDescription.Title); 35Assert.Equal("One or more validation errors occurred.", problemDescription.Title); 40Assert.Equal("key1", item.Key); 45Assert.Equal("key3", item.Key); 65Assert.Equal("One or more validation errors occurred.", problemDescription.Title); 70Assert.Equal("unsafeError", item.Key); 89Assert.Equal("One or more validation errors occurred.", problemDescription.Title); 94Assert.Equal("key1", item.Key); 99Assert.Equal("key2", item.Key);

VirtualFileResultTest.cs (2)

29Assert.Equal(path, result.FileName); 44Assert.Equal(path, result.FileName);

CommonResourceInvokerTest.cs (1)

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

CorsAuthorizationFilterTest.cs (8)

CompareAttributeAdapterTest.cs (36)

DataAnnotationsClientModelValidatorProviderTest.cs (1)

112Assert.Equal("Custom Required Message", adapter.Attribute.ErrorMessage);

DataAnnotationsMetadataProviderTest.cs (26)

DataAnnotationsModelValidatorTest.cs (4)

100Assert.Equal(expectedMemberName, context.MemberName); 180Assert.Equal(attribute.Object.FormatErrorMessage("Length"), validationResult.Message); 235Assert.Equal(new RequiredAttribute().FormatErrorMessage("Length"), validationResult.Message); 392Assert.Equal("Longueur est invalide : 4", validationResult.Message);

DefaultModelClientValidatorProviderTest.cs (2)

51Assert.Equal("Class", customModelValidator.Tag); 73Assert.Equal("Property", validatorItem.Tag);

FileExtensionsAttributeAdapterTest.cs (24)

MaxLengthAttributeAdapterTest.cs (30)

MinLengthAttributeAdapterTest.cs (24)

ModelMetadataProviderTest.cs (16)

57Assert.Equal("TypePrefix", metadata.BinderModelName); 128Assert.Equal("HiddenInput", result); 143Assert.Equal("HiddenInput", result); 156Assert.Equal("PersonType", propertyMetadata.BinderModelName); 169Assert.Equal("GrandParentProperty", propertyMetadata.BinderModelName); 236Assert.Equal("value", result); 252Assert.Equal("Property", result); 421Assert.Equal("description", result); 437Assert.Equal("prompt", result); 461Assert.Equal("name from resources" + culture, result); 487Assert.Equal("description from resources" + culture, result); 522Assert.Equal(expected, result); 540Assert.Equal(expected, result); 558Assert.Equal(expected, result); 581Assert.Equal(expected, result); 599Assert.Equal(expected, result);

NumericClientModelValidatorTest.cs (20)

RangeAttributeAdapterTest.cs (24)

RequiredAttributeAdapterTest.cs (12)

45kvp => { Assert.Equal("data-val", kvp.Key); Assert.Equal("true", kvp.Value); }, 46kvp => { Assert.Equal("data-val-required", kvp.Key); Assert.Equal(expectedMessage, kvp.Value); }); 70kvp => { Assert.Equal("data-val", kvp.Key); Assert.Equal("true", kvp.Value); }, 71kvp => { Assert.Equal("data-val-required", kvp.Key); Assert.Equal(expectedMessage, kvp.Value); }); 98kvp => { Assert.Equal("data-val", kvp.Key); Assert.Equal("original", kvp.Value); }, 99kvp => { Assert.Equal("data-val-required", kvp.Key); Assert.Equal("original", kvp.Value); });

StringLengthAttributeAdapterTest.cs (32)

ValidatableObjectAdapterTest.cs (2)

134Assert.Equal(expectedDisplayName, model.DisplayName); 135Assert.Equal(expectedMemberName, model.MemberName);

ValidationAttributeAdapterProviderTest.cs (1)

88Assert.Equal(expectedRuleName, dataTypeAdapter.RuleName);

DependencyInjection\XmlDataContractSerializerMvcOptionsSetupTest.cs (2)

24Assert.Equal("application/xml", mappedContentType); 40Assert.Equal("text/xml", mappedContentType);

DependencyInjection\XmlSerializerMvcOptionsSetupTest.cs (2)

24Assert.Equal("application/xml", mappedContentType); 40Assert.Equal("text/xml", mappedContentType);

ProblemDetailsWrapperTest.cs (5)

33Assert.Equal("Some title", problemDetails.Title); 34Assert.Equal("Some instance", problemDetails.Instance); 46Assert.Equal("[key2]", kvp.Key); 51Assert.Equal("key1", kvp.Key); 93Assert.Equal(expectedContent, res);

SerializableErrorWrapperTests.cs (5)

75Assert.Equal(string.Empty, kvp.Key); 80Assert.Equal("key1", kvp.Key); 85Assert.Equal("key2", kvp.Key); 90Assert.Equal("list[3].key3", kvp.Key); 123Assert.Equal(expectedContent, res);

ValidationProblemDetailsWrapperTest.cs (13)

37Assert.Equal("Some title", problemDetails.Title); 38Assert.Equal("Some instance", problemDetails.Instance); 45Assert.Equal("[key2]", kvp.Key); 50Assert.Equal("key1", kvp.Key); 63Assert.Equal("[error2]", kvp.Key); 68Assert.Equal("error1", kvp.Key); 93Assert.Equal("Some title", problemDetails.Title); 94Assert.Equal("Some instance", problemDetails.Instance); 101Assert.Equal("key1", kvp.Key); 106Assert.Equal("[key2]", kvp.Key); 131Assert.Equal("Some title", problemDetails.Title); 182Assert.Equal(expectedContent, res); 220Assert.Equal(expectedContent, res);

XmlDataContractSerializerInputFormatterTest.cs (11)

XmlDataContractSerializerOutputFormatterTest.cs (2)

667Assert.Equal($"An error occurred while trying to create a DataContractSerializer for the type '{typeof(Customer).FullName}'.", 718Assert.Equal(expectedOutput, content);

XmlSerializerInputFormatterTest.cs (12)

XmlSerializerOutputFormatterTest.cs (3)

102Assert.Equal(expectedOutput, content); 122Assert.Equal(expectedOutput, content); 484Assert.Equal(

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

AntiforgeryTests.cs (9)

39Assert.Equal("SAMEORIGIN", header); 49Assert.Equal("no-cache", pragmaValue.Name); 83Assert.Equal("OK", await response.Content.ReadAsStringAsync()); 94Assert.Equal("SAMEORIGIN", header); 101Assert.Equal("no-cache", pragmaValue.Name); 133Assert.Equal("OK", await response.Content.ReadAsStringAsync()); 173Assert.Equal("SAMEORIGIN", header); 183Assert.Equal("no-cache", pragmaValue.Name); 210Assert.Equal("http://example.com/antiforgery-redirect", response.Headers.Location.AbsoluteUri);

ApiBehaviorTest.cs (24)

62Assert.Equal("application/problem+json", response.Content.Headers.ContentType.MediaType); 70Assert.Equal("One or more validation errors occurred.", problemDetails.Title); 71Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.1", problemDetails.Type); 77Assert.Equal("Name", kvp.Key); 79Assert.Equal("The field Name must be a string with a minimum length of 5 and a maximum length of 30.", error); 83Assert.Equal("Zip", kvp.Key); 85Assert.Equal("The field Zip must match the regular expression '\\d{5}'.", error); 93Assert.Equal("traceId", kvp.Key); 132Assert.Equal("Unsupported Media Type", problemDetails.Title); 159Assert.Equal(input.Name, result.Name); 180Assert.Equal(input.Name, result.ContactInfo.Name); 213Assert.Equal(name, result.Name); 214Assert.Equal(email, result.Email); 234Assert.Equal(name, result.Name); 235Assert.Equal(email, result.Email); 255Assert.Equal(name, result.Name); 256Assert.Equal(email, result.Email); 271Assert.Equal(expected, result); 286Assert.Equal(expected, result); 311Assert.Equal("traceId", kvp.Key); 367Assert.Equal("Error", validationProblemDetails.Title); 373Assert.Equal("tracking-id", kvp.Key); 381Assert.Equal("Error1", kvp.Key); 451Assert.Equal("application/vnd.error+json", response.Content.Headers.ContentType.MediaType);

ApiExplorerTest.cs (137)

ApplicationModelTest.cs (11)

40Assert.Equal("CoolController", body); 53Assert.Equal("ActionName", body); 66Assert.Equal("CoolMetadata", body); 79Assert.Equal("Common Application Description", body); 92Assert.Equal("Common Controller Description", body); 105Assert.Equal("Specific Action Description", body); 118Assert.Equal(@"Licensed to the .NET Foundation under one or more agreements. 136Assert.Equal("From Header - HelloWorld", body); 156Assert.Equal("Hello world", response); 165Assert.Equal("No route matches the supplied values.", ex.Message); 175Assert.Equal("/Home/CannotBeRouted", response.Headers.Location.ToString());

AsyncActionsTests.cs (21)

AsyncEnumerableTestBase.cs (4)

52Assert.Equal("Project0", projects[0].Name); 53Assert.Equal("Project9", projects[9].Name); 92Assert.Equal("Project0", GetName(projects.ElementAt(0))); 93Assert.Equal("Project9", GetName(projects.ElementAt(9)));

AuthMiddlewareAndFilterTestBase.cs (2)

268Assert.Equal("/Account/Login", response.Headers.Location.LocalPath); 274Assert.Equal("/Account/AccessDenied", response.Headers.Location.LocalPath);

AuthMiddlewareUsingRequireAuthTest.cs (1)

76Assert.Equal("/Home/Login", response.Headers.Location.LocalPath);

BasicTests.cs (27)

165Assert.Equal("Hello, World!", Assert.Single(response.Headers.GetValues("Message"))); 182Assert.Equal(expectedContent, responseContent); 195Assert.Equal("https://localhost/Home/HttpsOnlyAction", response.Headers.Location.ToString()); 246Assert.Equal("text/html", response.Content.Headers.ContentType.MediaType); 269Assert.Equal("text/html", response.Content.Headers.ContentType.MediaType); 292Assert.Equal("text/html", response.Content.Headers.ContentType.MediaType); 355Assert.Equal("This is a basic website.", responseData); 378Assert.Equal(expected, response.Trim()); 391Assert.Equal(expected, response.Trim()); 409Assert.Equal("/Home/Product", response.Headers.Location.ToString()); 412Assert.Equal("Get Product", responseBody); 462Assert.Equal("true", response); 487Assert.Equal("BasicWebSite", assemblyParts[0]); 502Assert.Equal("Message set in action", message); 505Assert.Equal("Value set in OnActionExecuting", filterMessage); 508Assert.Equal("View Data Property Sample", title); 519Assert.Equal("Message set in action", message); 522Assert.Equal("View Data Property Sample", title); 543Assert.Equal("TestName", data.Name); 568Assert.Equal("CustomBoundValue", data.CustomBound); 606Assert.Equal("TestName", content); 618Assert.Equal("OnGetTestName", content); 635Assert.Equal("ConfirmPassword", kvp.Key); 636Assert.Equal("Password and confirm password do not match.", Assert.Single(kvp.Value)); 640Assert.Equal("UserName", kvp.Key); 641Assert.Equal("User name is required.", Assert.Single(kvp.Value)); 662Assert.Equal("Failed to read the request form. Form section has invalid Content-Disposition value: ", string.Join(" ", kvp.Value));

ClientValidationOptionsTests.cs (2)

40Assert.Equal("ClientValidationDisabled", view); 41Assert.Equal("ClientValidationDisabled", page);

ComponentRenderingFunctionalTests.cs (2)

76Assert.Equal("http://localhost/navigation-redirect", response.Headers.Location.ToString()); 179Assert.Equal(

ConsumesAttributeTestsBase.cs (7)

57Assert.Equal("CreateProduct_Product_Text", body); 74Assert.Equal("ConsumesAttribute_PassThrough_Product_Json", body); 110Assert.Equal(requestContentType, product.SampleString); 132Assert.Equal(expectedString, product.SampleString); 157Assert.Equal(expectedString, product.SampleString); 176Assert.Equal("Read from JSON: some input", product.SampleString); 199Assert.Equal("Read from XML: some input", product.SampleString);

ContentNegotiationTest.cs (22)

ControllerEndpointFiltersTest.cs (3)

59Assert.Equal("Index", ((JsonElement)methodInfo).GetString()); 71Assert.Equal("Intercepted", content); 84Assert.Equal("foobar", ((JsonElement)argument).GetString());

ControllerFromServicesTests.cs (6)

43Assert.Equal(expected, responseText); 56Assert.Equal(expected, response); 69Assert.Equal(expected, response); 85Assert.Equal(expected, await response.Content.ReadAsStringAsync()); 101Assert.Equal(expected, await response.Content.ReadAsStringAsync()); 128Assert.Equal(expected, response);

CorsTestsBase.cs (10)

53Assert.Equal("[\"comment1\",\"comment2\",\"comment3\"]", content); 56Assert.Equal(CorsConstants.AccessControlAllowOrigin, header.Key); 72Assert.Equal("[\"Create\",\"Update\",\"Delete\"]", content); 90Assert.Equal("[\"Create\",\"Update\",\"Delete\"]", content); 136Assert.Equal(CorsConstants.AccessControlAllowMethods, h.Key); 141Assert.Equal(CorsConstants.AccessControlAllowOrigin, h.Key); 147Assert.Equal(string.Empty, content); 179Assert.Equal("abcd", content); 237Assert.Equal("[\"usercomment1\",\"usercomment2\",\"usercomment3\"]", content); 261Assert.Equal("exclusive", content);

CustomValueProviderTest.cs (8)

51Assert.Equal("text/plain", response.Content.Headers.ContentType.MediaType); 52Assert.Equal("BasicWebSite.Controllers.CustomValueProviderController.CustomValueProviderDisplayName (BasicWebSite)", content); 68Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType); 69Assert.Equal("[42,100,200]", content); 85Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType); 86Assert.Equal("[null,42,null,100,null,200]", content); 102Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType); 103Assert.Equal(@"[null,""foo"",null,""bar"",null,""baz""]", content);

DefaultValuesTest.cs (7)

40Assert.Equal(expected, response); 54Assert.Equal(expected, response); 68Assert.Equal(expected, response); 82Assert.Equal(expected, response); 96Assert.Equal(expected, response); 112Assert.Equal(expected, response); 126Assert.Equal(expected, response);

DirectivesTest.cs (2)

40Assert.Equal(expected, body.Trim()); 53Assert.Equal(expected, body.Trim());

DoNotRespectBrowserAcceptHeaderTests.cs (7)

53Assert.Equal("application/json; charset=utf-8", response.Content.Headers.ContentType.ToString()); 55Assert.Equal("{\"id\":10,\"name\":\"John\"}", responseData); 81Assert.Equal("application/xml; charset=utf-8", response.Content.Headers.ContentType.ToString()); 112Assert.Equal("application/json; charset=utf-8", response.Content.Headers.ContentType.ToString()); 115Assert.Equal(expectedResponseData, responseData); 141Assert.Equal("application/xml; charset=utf-8", response.Content.Headers.ContentType.ToString()); 143Assert.Equal(requestData, responseData);

FileResultTests.cs (86)

FiltersTest.cs (6)

40Assert.Equal("Hello World!", await response.Content.ReadAsStringAsync()); 51Assert.Equal("Hello World!", await response.Content.ReadAsStringAsync()); 77Assert.Equal( 97Assert.Equal("Can't process this!", await response.Content.ReadAsStringAsync()); 110Assert.Equal("This value was set by TraceResourceFilter", response); 124Assert.Equal("Service filter content", await response.Content.ReadAsStringAsync());

FormFileUploadTest.cs (3)

49Assert.Equal("John", user.Name); 51Assert.Equal("John's biography content", user.Biography); 77Assert.Equal("Phone", product.Name);

GlobalAuthorizationFilterTestBase.cs (2)

43Assert.Equal( 57Assert.Equal("Administration.AllowAnonymousAction", body);

HtmlGenerationTest.cs (46)

HtmlGenerationWithCultureTest.cs (30)

InputFormatterTests.cs (11)

52Assert.Equal(sampleInputInt.ToString(CultureInfo.InvariantCulture), await response.Content.ReadAsStringAsync()); 69Assert.Equal("Test Content", responseBody); 96Assert.Equal("Test", result.DerivedProperty); 112Assert.Equal("DerivedProperty", p.Name); 128Assert.Equal(input, result.DerivedProperty); 144Assert.Equal("DerivedProperty", p.Name); 160Assert.Equal(input, result.DerivedProperty); 176Assert.Equal("DerivedProperty", p.Name); 196Assert.Equal("A non-empty request body is required.", Assert.Single(kvp.Value)); 214Assert.Equal("A non-empty request body is required.", Assert.Single(kvp.Value)); 219Assert.Equal("The dummy field is required.", Assert.Single(kvp.Value));

InputObjectValidationTests.cs (10)

82Assert.Equal("User has been registered : " + sampleName, 105Assert.Equal( 125Assert.Equal("No model validation for developer, even though developer.Name is empty.", 150Assert.Equal(expectedModelStateErrorMessage, errorMessage); 178Assert.Equal(expectedModelStateErrorMessage, errorMessage); 196Assert.Equal("xyz", await response.Content.ReadAsStringAsync()); 217Assert.Equal(expectedErrorMessage, actual: responseContent); 237Assert.Equal(expectedErrorMessage, actual: responseContent); 258Assert.Equal(expectedError, actual: responseContent); 335Assert.Equal("isbn", error.Key);

InputValidationTests.cs (10)

96Assert.Equal( 99Assert.Equal( 102Assert.Equal( 105Assert.Equal( 108Assert.Equal( 111Assert.Equal( 114Assert.Equal( 117Assert.Equal( 120Assert.Equal( 123Assert.Equal(

JsonInputFormatterTestBase.cs (17)

JsonOutputFormatterTestBase.cs (15)

JsonResultWithNewtonsoftJsonTest.cs (11)

51Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType); 52Assert.Equal("{\"message\":\"hello\"}", content); 73Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType); 74Assert.Equal("{\"message\":\"hello\"}", content); 91Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType); 92Assert.Equal("null", content); 109Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType); 110Assert.Equal("\"hello\"", content); 126Assert.Equal("{\"message\":\"hello\"}", content); 142Assert.Equal("application/message+json", response.Content.Headers.ContentType.MediaType); 143Assert.Equal("{\"message\":\"hello\"}", content);

JsonResultWithSystemTextJsonTest.cs (11)

51Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType); 52Assert.Equal("{\"message\":\"hello\"}", content); 73Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType); 74Assert.Equal("{\"message\":\"hello\"}", content); 91Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType); 92Assert.Equal("null", content); 109Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType); 110Assert.Equal("\"hello\"", content); 126Assert.Equal("{\"Message\":\"hello\"}", content); 142Assert.Equal("application/message+json", response.Content.Headers.ContentType.MediaType); 143Assert.Equal("{\"message\":\"hello\"}", content);

KeyedServicesTests.cs (5)

43Assert.Equal("OK", await okResponse.Content.ReadAsStringAsync()); 44Assert.Equal("NOT OK", await notokResponse.Content.ReadAsStringAsync()); 58Assert.Equal("OK,NOT OK", await response.Content.ReadAsStringAsync()); 72Assert.Equal("DEFAULT", await response.Content.ReadAsStringAsync()); 86Assert.Equal(string.Empty, await response.Content.ReadAsStringAsync());

LinkGeneratorTest.cs (18)

LinkParserTest.cs (16)

NewtonsoftJsonInputFormatterTest.cs (1)

24Assert.Equal("{\"\":[\"Unexpected end when reading JSON. Path '', line 1, position 1.\"]}", responseBody);

NewtonsoftJsonOutputFormatterTest.cs (1)

36Assert.Equal(expectedBody, actualBody);

OutputFormatterTest.cs (1)

48Assert.Equal(expectedBody, body);

RazorBuildTest.cs (4)

61Assert.Equal("Hello from runtime-compiled rzc page!", responseBody.Trim()); 74Assert.Equal("Hello from fallback page!", responseBody.Trim()); 86Assert.Equal("Hello from runtime-compiled rzc view!", responseBody.Trim()); 99Assert.Equal("Hello from buildtime-compiled rzc view!", responseBody.Trim());

RazorPagesNamespaceTest.cs (3)

41Assert.Equal("AspNetCoreGeneratedDocument", content.Trim()); 51Assert.Equal("CustomNamespace.Nested.Folder", content.Trim()); 61Assert.Equal("Override", content.Trim());

RazorPagesTest.cs (55)

RazorPagesViewSearchTest.cs (4)

41Assert.Equal("Hello from sibling", content.Trim()); 51Assert.Equal("Hello from parent", content.Trim()); 61Assert.Equal("Hello from root", content.Trim()); 71Assert.Equal("Hello from shared", content.Trim());

RazorPagesWithBasePathTest.cs (31)

RazorPagesWithEndpointRoutingTest.cs (4)

38Assert.Equal("/Login?ReturnUrl=%2FConventions%2FAuthFolder", response.Headers.Location.PathAndQuery); 51Assert.Equal("Hello from Anonymous", content.Trim()); 62Assert.Equal("/Login?ReturnUrl=%2FModelWithAuthFilter", response.Headers.Location.PathAndQuery); 73Assert.Equal("/Login?ReturnUrl=%2FAuthorizedAction%2FIndex", response.Headers.Location.PathAndQuery);

RemoteAttributeValidationTest.cs (8)

49Assert.Equal("text/html", response.Content.Headers.ContentType.MediaType); 50Assert.Equal("utf-8", response.Content.Headers.ContentType.CharSet); 74Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType); 75Assert.Equal("utf-8", response.Content.Headers.ContentType.CharSet); 77Assert.Equal(expectedContent, responseContent); 103Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType); 104Assert.Equal("utf-8", response.Content.Headers.ContentType.CharSet); 106Assert.Equal(expectedContent, responseContent);

RequestFormLimitsTest.cs (2)

76Assert.Equal(expected, result); 102Assert.Equal(expected, result);

RequestServicesTestBase.cs (3)

62Assert.Equal(requestId, body); 84Assert.Equal(expected, body); 102Assert.Equal(requestId1, body1);

RequestSizeLimitTest.cs (1)

92Assert.Equal(expected, actual);

RespectBrowserAcceptHeaderTests.cs (4)

53Assert.Equal("application/json; charset=utf-8", response.Content.Headers.ContentType.ToString()); 55Assert.Equal("\"Hello World!\"", responseData); 72Assert.Equal("text/plain; charset=utf-8", response.Content.Headers.ContentType.ToString()); 74Assert.Equal("Hello World!", responseData);

RoutingAcrossPipelineBranchesTest.cs (9)

59Assert.Equal("s", subdir); 63Assert.Equal("c", common); 67Assert.Equal("d", @default); 93Assert.Equal("/subdir/literal/Branches/Index/s", subdirContent.Link); 96Assert.Equal("/common/Branches/Index/c/literal", commonContent.Link); 99Assert.Equal("/Branches/literal/Index/d", defaultContent.Link); 128Assert.Equal("/subdir/Branches/Index/c/literal", subdirContent.Link); 131Assert.Equal("/literal/Branches/Index/s", defaultContent.Link); 175Assert.Equal("Index", action);

RoutingDynamicOrderTest.cs (5)

52Assert.Equal("AttributeRouteSlug", content.RouteName); 75Assert.Equal("slug", identifier); 120Assert.Equal("slug", identifier); 141Assert.Equal("Hello from dynamic page: /DynamicPagebefore", content); 164Assert.Equal("controller", identifier);

RoutingDynamicTest.cs (4)

78Assert.Equal("Hello from dynamic controller: /link_generation/dynamic/index", content); 108Assert.Equal("Hello from dynamic controller POST: /link_generation/dynamic/index", content); 124Assert.Equal("Hello from dynamic page: /DynamicPage", content); 156Assert.Equal("/Edit/10", editLink.GetAttribute("href"));

RoutingEndpointRoutingTest.cs (42)

RoutingFallbackTest.cs (5)

64Assert.Equal("Hello from Edit page", content.Trim()); 80Assert.Equal("Hello from fallback controller: /link_generation/Admin/Fallback/Index", content); 96Assert.Equal("Hello from fallback controller POST: /link_generation/Admin/Fallback/Index", content); 112Assert.Equal("Hello from fallback controller POST: /link_generation/Admin/Fallback/Index", content); 128Assert.Equal("Hello from fallback page: /FallbackPage", content);

RoutingGroupsTest.cs (3)

47Assert.Equal("contoso", org); 61Assert.Equal("/pages/Edit/10", editLink.GetAttribute("href")); 62Assert.Equal("/controllers/contoso/Home/Contact", contactLink.GetAttribute("href"));

RoutingTestsBase.cs (146)

RoutingWithoutRazorPagesTestsBase.cs (4)

49Assert.Equal("PageRoute", result.Controller); 50Assert.Equal("AttributeRoute", result.Action); 69Assert.Equal("PageRoute", result.Controller); 70Assert.Equal("ConventionalRoute", result.Action);

SerializableErrorTests.cs (2)

61Assert.Equal(acceptHeader, response.Content.Headers.ContentType.MediaType); 85Assert.Equal(acceptHeader, response.Content.Headers.ContentType.MediaType);

SimpleTests.cs (1)

42Assert.Equal(expected, content);

SimpleWithWebApplicationBuilderExceptionTests.cs (1)

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

SimpleWithWebApplicationBuilderTests.cs (12)

49Assert.Equal(expected, content); 64Assert.Equal(expected, content); 79Assert.Equal(expected, content); 93Assert.Equal("/ok-object", response.Headers.Location.ToString()); 95Assert.Equal(expected, content); 120Assert.Equal("/json", response.Headers.Location.ToString()); 134Assert.Equal("Hello human", content); 148Assert.Equal(expected, content); 175Assert.Equal(expected, content); 194Assert.Equal(expected, content); 215Assert.Equal(expectedWebRoot, content); 278Assert.Equal(expected, actual);

StreamOutputFormatterTest.cs (2)

42Assert.Equal(contentType, response.Content.Headers.ContentType?.ToString()); 44Assert.Equal("Sample text from a stream", body);

SystemTextJsonOutputFormatterTest.cs (5)

24Assert.Equal("\"Hello Mr. \\uD83E\\uDD8A\"", await response.Content.ReadAsStringAsync()); 43Assert.Equal("\"Une b\\u00EAte de cirque\"", await response.Content.ReadAsStringAsync()); 66Assert.Equal(expected, await response.Content.ReadAsStringAsync()); 81Assert.Equal(expected, await response.Content.ReadAsStringAsync()); 83Assert.Equal("t", headerValue);

TagHelpersFromServicesTest.cs (1)

41Assert.Equal(expected, responseText.Trim());

TagHelpersTest.cs (1)

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

TempDataInCookiesTest.cs (2)

94Assert.Equal(expected, body); 150Assert.Equal("Foo", body);

TempDataInCookiesUsingCookieConsentTest.cs (1)

60Assert.Equal("Foo", body);

TempDataPropertyTest.cs (5)

56Assert.Equal(expected, body.ToString().Trim()); 84Assert.Equal(expected, body); 113Assert.Equal(tempDataContent, body); 121Assert.Equal(tempDataContent, body); 150Assert.Equal(tempDataContent, body);

TempDataTestBase.cs (7)

57Assert.Equal("Foo", body); 82Assert.Equal("Foo", body); 113Assert.Equal("Foo", body); 138Assert.Equal("Foo", body); 146Assert.Equal("Foo", body); 178Assert.Equal($"Foo 10 3 10/10/2010 00:00:00 {testGuid.ToString()}", body); 217Assert.Equal("Michael", body);

TestingInfrastructureTests.cs (9)

40Assert.Equal("Test", response); 48Assert.Equal($"The provided Type '{typeof(RazorPagesClassLibrary.ClassLibraryStartup).Name}' does not belong to an assembly with an entry point. A common cause for this error is providing a Type from a class library.", 66Assert.Equal("Some-Value", xPassThruValue); 89Assert.Equal("Some-Value", xPassThruValue); 109Assert.Equal("false", modifiedHeaderWasSent); 123Assert.Equal("/Testing/Builder", response.Headers.Location?.OriginalString); 150Assert.Equal("Test", await response.Content.ReadAsStringAsync()); 168Assert.Equal("Value-4", handlerResponse.CookieValue); 191Assert.Equal("GenericTest", response);

VersioningEndpointRoutingTests.cs (4)

42Assert.Equal("Customers", result.Controller); 43Assert.Equal("Delete", result.Action); 64Assert.Equal("Customers", result.Controller); 65Assert.Equal("Post", result.Action);

VersioningTestsBase.cs (45)

ViewComponentFromServicesTests.cs (1)

42Assert.Equal(expected, responseText);

ViewEngineTests.cs (5)

117Assert.Equal(expected, body.Trim()); 201Assert.Equal(expected, body.Trim()); 386Assert.Equal(expected, body.Trim()); 399Assert.Equal(expected, body.Trim()); 478Assert.Equal(expected, responseContent.Trim());

XmlDataContractSerializerFormattersWrappingTest.cs (6)

238Assert.Equal("404", root.Element(root.Name.Namespace.GetName("status"))?.Value); 239Assert.Equal("Not Found", root.Element(root.Name.Namespace.GetName("title"))?.Value); 240Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.5", root.Element(root.Name.Namespace.GetName("type"))?.Value); 281Assert.Equal("400", root.Element(root.Name.Namespace.GetName("status"))?.Value); 282Assert.Equal("One or more validation errors occurred.", root.Element(root.Name.Namespace.GetName("title"))?.Value); 285Assert.Equal("The State field is required.", mvcErrors.Element(root.Name.Namespace.GetName("State"))?.Value);

XmlDataContractSerializerInputFormatterTest.cs (1)

74Assert.Equal("WA", modelBindingInfo.Store.Address.State);

XmlSerializerFormattersWrappingTest.cs (6)

221Assert.Equal("404", root.Element(root.Name.Namespace.GetName("status"))?.Value); 222Assert.Equal("Not Found", root.Element(root.Name.Namespace.GetName("title"))?.Value); 223Assert.Equal("https://tools.ietf.org/html/rfc9110#section-15.5.5", root.Element(root.Name.Namespace.GetName("type"))?.Value); 263Assert.Equal("400", root.Element(root.Name.Namespace.GetName("status"))?.Value); 264Assert.Equal("One or more validation errors occurred.", root.Element(root.Name.Namespace.GetName("title"))?.Value); 267Assert.Equal("The State field is required.", mvcErrors.Element(root.Name.Namespace.GetName("State"))?.Value);

XmlSerializerInputFormatterTests.cs (1)

48Assert.Equal(sampleInputInt.ToString(CultureInfo.InvariantCulture), await response.Content.ReadAsStringAsync());

ActionParametersIntegrationTest.cs (28)

ArrayModelBinderIntegrationTest.cs (22)

45Assert.Equal("10", entry.AttemptedValue); 49Assert.Equal("11", entry.AttemptedValue); 89Assert.Equal("10", entry.AttemptedValue); 93Assert.Equal("11", entry.AttemptedValue); 129Assert.Equal("10", entry.AttemptedValue); 133Assert.Equal("11", entry.AttemptedValue); 197Assert.Equal("bill", model[0].Name); 198Assert.Equal("lang", model[1].Name); 205Assert.Equal("bill", entry.AttemptedValue); 209Assert.Equal("lang", entry.AttemptedValue); 242Assert.Equal("bill", model[0].Name); 243Assert.Equal("lang", model[1].Name); 250Assert.Equal("bill", entry.AttemptedValue); 254Assert.Equal("lang", entry.AttemptedValue); 283Assert.Equal("bill", model[0].Name); 284Assert.Equal("lang", model[1].Name); 291Assert.Equal("bill", entry.AttemptedValue); 295Assert.Equal("lang", entry.AttemptedValue); 363Assert.Equal("James", model.Name); 367(e) => Assert.Equal("Alias1", e), 368(e) => Assert.Equal("Alias2", e)); 401Assert.Equal(expectedMessage, exception.Message);

BinderTypeBasedModelBinderIntegrationTest.cs (9)

117Assert.Equal("CustomParameter", key); 177Assert.Equal("SomeStreet", address.Street); 182Assert.Equal("Street", kvp.Key); 229Assert.Equal("SomeStreet", person.Address.Street); 234Assert.Equal("Address.Street", kvp.Key); 267Assert.Equal("SomeStreet", boundPerson.Address.Street); 272Assert.Equal("Address.Street", key); 306Assert.Equal("SomeStreet", boundPerson.Address.Street); 311Assert.Equal("CustomParameter.Address.Street", key);

BindingSourceMetadataProviderIntegrationTest.cs (3)

55Assert.Equal("Fred", boundPerson.Name); 107Assert.Equal("Fred", boundPerson.Name); 108Assert.Equal("text.txt", boundPerson.File.FileName);

BindPropertyIntegrationTest.cs (2)

47Assert.Equal("Joey", Assert.IsType<Person>(result.Model).Name); 74Assert.Equal("Joey", Assert.IsType<Person>(result.Model).Name);

BodyValidationIntegrationTests.cs (18)

ByteArrayModelBinderIntegrationTest.cs (4)

62Assert.Equal(queryStringKey, entry.Key); 65Assert.Equal(value, entry.Value.AttemptedValue); 143Assert.Equal("CustomParameter", entry.Key); 145Assert.Equal(value, entry.Value.AttemptedValue);

CollectionModelBinderIntegrationTest.cs (29)

ComplexRecordIntegrationTest.cs (199)

ComplexTypeIntegrationTestBase.cs (176)

DictionaryModelBinderIntegrationTest.cs (30)

ExcludeBindingMetadataProviderIntegrationTest.cs (2)

54Assert.Equal("Fred", boundPerson.Name); 113Assert.Equal("Fred", boundPerson.Name);

FormCollectionModelBindingIntegrationTest.cs (5)

61Assert.Equal("form-data; name=Address.File; filename=text.txt", file.ContentDisposition); 63Assert.Equal(data, reader.ReadToEnd()); 68Assert.Equal("Address.Zip", entry.Key); 109Assert.Equal("form-data; name=CustomParameter; filename=text.txt", file.ContentDisposition); 111Assert.Equal(data, reader.ReadToEnd());

FormFileModelBindingIntegrationTest.cs (57)

GenericModelBinderIntegrationTest.cs (20)

HeaderModelBinderIntegrationTest.cs (34)

JQueryFormatModelBindingIntegrationTest.cs (8)

44Assert.Equal("James", model.Name); 47Assert.Equal("Redmond", address.City); 49Assert.Equal("WA", address.State.ShortName); 50Assert.Equal("Washington", address.State.LongName); 82Assert.Equal("James", model.Name); 85Assert.Equal("Redmond", address.City); 87Assert.Equal("WA", address.State.ShortName); 88Assert.Equal("Washington", address.State.LongName);

KeyValuePairModelBinderIntegrationTest.cs (27)

NullableReferenceTypeIntegrationTest.cs (4)

53Assert.Equal("FirstName", kvp.Key); 140Assert.Equal("FirstName", kvp.Key); 144Assert.Equal("Test", error.ErrorMessage); 195Assert.Equal("param1", kvp.Key);

SimpleTypeModelBinderIntegrationTest.cs (34)

TryUpdateModelIntegrationTest.cs (84)

TryValidateModelIntegrationTest.cs (7)

42Assert.Equal("Product must be made in the USA if it is not named.", modelStateErrors["software"]); 122Assert.Equal("CompanyName cannot be null or empty.", modelStateErrors["[0].CompanyName"]); 123Assert.Equal(priceRange, modelStateErrors["[0].Price"]); 124Assert.Equal(categoryRequired, modelStateErrors["[0].Category"]); 126Assert.Equal("CompanyName cannot be null or empty.", modelStateErrors["[1].CompanyName"]); 127Assert.Equal(priceRange, modelStateErrors["[1].Price"]); 128Assert.Equal(categoryRequired, modelStateErrors["[1].Category"]);

ValidationIntegrationTests.cs (81)

ValidationWithRecordIntegrationTests.cs (83)

HtmlLocalizerTest.cs (13)

28Assert.Equal(localizedString.Name, actualLocalizedHtmlString.Name); 29Assert.Equal(localizedString.Value, actualLocalizedHtmlString.Value); 47Assert.Equal(localizedString.Name, actualLocalizedHtmlString.Name); 48Assert.Equal(localizedString.Value, actualLocalizedHtmlString.Value); 113Assert.Equal(format, localizedHtmlString.Value); 117Assert.Equal(expectedText, writer.ToString()); 168Assert.Equal("Hello John", actualLocalizedString.Value); 183Assert.Equal("Hello John Doe", actualLocalizedString.Value); 198Assert.Equal("Hello John", actualLocalizedHtmlString.Value); 213Assert.Equal("Bonjour John", actualLocalizedHtmlString.Value); 229Assert.Equal("World", allLocalizedStrings.First().Value); 245Assert.Equal("World", allLocalizedStrings[0].Value); 246Assert.Equal("Bar", allLocalizedStrings[1].Value);

MvcLocalizationMvcBuilderExtensionsTest.cs (1)

98Assert.Equal("TestResources", actualOptions.Value.ResourcesPath);

MvcLocalizationMvcCoreBuilderExtensionsTest.cs (1)

98Assert.Equal("TestResources", actualOptions.Value.ResourcesPath);

ViewLocalizerTest.cs (8)

136Assert.Equal("World", allLocalizedStrings.First().Value); 161Assert.Equal("World", allLocalizedStrings[0].Value); 162Assert.Equal("Bar", allLocalizedStrings[1].Value); 186Assert.Equal("Hello John", actualLocalizedString.Value); 210Assert.Equal("Hello John Doe", actualLocalizedString.Value); 234Assert.Equal("Hello John", actualLocalizedString.Value); 258Assert.Equal("Hello John Doe", actualLocalizedString.Value); 282Assert.Equal("Bonjour John", actualLocalizedString.Value);

BsonTempDataSerializerTest.cs (1)

223Assert.Equal(value.ToString(), roundTripValue);

DependencyInjection\MvcNewtonsoftJsonOptionsExtensionsTest.cs (11)

49Assert.Equal(expected, actual); 64Assert.Equal(expected, actual); 79Assert.Equal(expected, actual); 98Assert.Equal(expected, actual); 117Assert.Equal(expected, actual); 136Assert.Equal(expected, actual); 154Assert.Equal(expected, actual); 189Assert.Equal(expected, actual); 209Assert.Equal(expected, actual); 223Assert.Equal(expectedMessage, actual: exception.Message); 237Assert.Equal(expectedMessage, actual: exception.Message);

JsonPatchExtensionsTest.cs (5)

27Assert.Equal("The target location specified by path segment 'CustomerId' was not found.", error.ErrorMessage); 45Assert.Equal("The target location specified by path segment 'CustomerId' was not found.", error.ErrorMessage); 62Assert.Equal("James", model.CustomerName); 87Assert.Equal(nameof(Customer), modelState.First().Key); 89Assert.Equal(error, modelState.First().Value.Errors.First().ErrorMessage);

JsonResultTest.cs (1)

36Assert.Equal("application/json; charset=utf-8", context.HttpContext.Response.ContentType);

NewtonsoftJsonHelperTest.cs (3)

38Assert.Equal(expectedOutput, htmlString.ToString()); 66Assert.Equal(expectedOutput, htmlString.ToString()); 85Assert.Equal(expectedOutput, htmlString.ToString());

NewtonsoftJsonInputFormatterTest.cs (10)

53Assert.Equal("Person Name", userModel.Name); 89Assert.Equal("Person Name", userModel.Name); 127Assert.Equal("Person Name", userModel.Name); 251Assert.Equal(expectedMessage, modelError.ErrorMessage); 275Assert.Equal("[1]", kvp.Key); 281Assert.Equal("[3]", kvp.Key); 371Assert.Equal("The supplied value is invalid.", modelError.ErrorMessage); 402Assert.Equal("The supplied value is invalid for ShortValue.", modelError.ErrorMessage); 433Assert.Equal("The supplied value is invalid for ShortValue.", modelError.ErrorMessage); 560Assert.Equal("test location", location?.Name);

NewtonsoftJsonOutputFormatterTest.cs (8)

145Assert.Equal(expectedOutput, content); 177Assert.Equal(expectedOutput, content); 220Assert.Equal(expected, content); 272Assert.Equal(expected, content); 308Assert.Equal(expected, content); 343Assert.Equal(expected, content); 367Assert.Equal(beforeMessage, afterMessage); 430Assert.Equal(expected, content);

NewtonsoftJsonPatchInputFormatterTest.cs (10)

NewtonsoftJsonResultExecutorTest.cs (1)

49Assert.Equal(expected, Encoding.UTF8.GetString(written));

NewtonsoftJsonValidationMetadataProviderTest.cs (3)

28Assert.Equal(propertyName, context.ValidationMetadata.ValidationModelName); 46Assert.Equal(new CamelCaseNamingStrategy().GetPropertyName(propertyName, false), context.ValidationMetadata.ValidationModelName); 65Assert.Equal(namingStrategy.GetPropertyName(propertyName, false), context.ValidationMetadata.ValidationModelName);

src\Mvc\Mvc.Core\test\Formatters\JsonInputFormatterTestBase.cs (18)

src\Mvc\Mvc.Core\test\Formatters\JsonOutputFormatterTestBase.cs (1)

137Assert.Equal(expectedContent, actualContent);

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

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

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

src\Mvc\Mvc.ViewFeatures\test\Infrastructure\TempDataSerializerTestBase.cs (3)

108Assert.Equal(value, roundTripValue); 193Assert.Equal(value.ToString(CultureInfo.InvariantCulture), roundTripValue); 215Assert.Equal(value.ToString("N"), roundTripValue);

src\Mvc\Mvc.ViewFeatures\test\Rendering\JsonHelperTestBase.cs (4)

43Assert.Equal(expectedOutput, htmlString.ToString()); 62Assert.Equal(expectedOutput, htmlString.ToString()); 100Assert.Equal(expectedOutput, htmlString.ToString()); 119Assert.Equal(expectedOutput, htmlString.ToString());

AssemblyPartExtensionTest.cs (1)

41Assert.Equal(assembly.Location, actual);

CompilerFailedExceptionFactoryTest.cs (30)

34Assert.Equal(viewPath, failure.SourceFilePath); 65failure => Assert.Equal(expected, failure.FailureSummary)); 85Assert.Equal(physicalPath, failure.SourceFilePath); 110Assert.Equal(fileContent, failure.SourceFileContent); 135Assert.Equal(viewPath, failure.SourceFilePath); 139Assert.Equal(@"A space or line break was encountered after the ""@"" character. Only valid identifiers, keywords, comments, ""("" and ""{"" are valid at the start of a code block and they must occur immediately following ""@"" with no space in between.", 145Assert.Equal(importsPath, failure.SourceFilePath); 149Assert.Equal(@"The explicit expression block is missing a closing "")"" character. Make sure you have a matching "")"" character for all the ""("" characters within this block, and that none of the "")"" characters are being interpreted as markup.", 179Assert.Equal(viewPath, failure.SourceFilePath); 180Assert.Equal("View Content", failure.SourceFileContent); 184Assert.Equal(diagnostics[0].GetMessage(CultureInfo.CurrentCulture), message.Message); 185Assert.Equal(viewPath, message.SourceFilePath); 193Assert.Equal(diagnostics[1].GetMessage(CultureInfo.CurrentCulture), message.Message); 194Assert.Equal(viewPath, message.SourceFilePath); 202Assert.Equal(diagnostics[2].GetMessage(CultureInfo.CurrentCulture), message.Message); 203Assert.Equal(viewPath, message.SourceFilePath); 212Assert.Equal(viewImportsPath, failure.SourceFilePath); 213Assert.Equal("Global Import Content", failure.SourceFileContent); 217Assert.Equal(diagnostics[3].GetMessage(CultureInfo.CurrentCulture), message.Message); 218Assert.Equal(viewImportsPath, message.SourceFilePath); 269Assert.Equal(viewPath, failure.SourceFilePath); 270Assert.Equal("view-content", failure.SourceFileContent); 274Assert.Equal("message-1", message.Message); 275Assert.Equal(viewPath, message.SourceFilePath); 283Assert.Equal("message-3", message.Message); 284Assert.Equal(viewPath, message.SourceFilePath); 293Assert.Equal(generatedCodeFileName, failure.SourceFilePath); 294Assert.Equal("compilation-content", failure.SourceFileContent); 298Assert.Equal("message-2", message.Message); 299Assert.Equal(assemblyName, message.SourceFilePath);

CSharpCompilerTest.cs (3)

101Assert.Equal("CS1701", item.Key); 106Assert.Equal("CS1702", item.Key); 111Assert.Equal("CS1705", item.Key);

FileProviderRazorProjectFileSystemTest.cs (39)

RuntimeCompilationFileProviderTest.cs (1)

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

RuntimeViewCompilerTest.cs (4)

757Assert.Equal(viewPath, compilationFailure.SourceFilePath); 758Assert.Equal(fileContent, compilationFailure.SourceFileContent); 776Assert.Equal("Generated Code", compilationFailure.SourceFilePath); 777Assert.Equal(content, compilationFailure.SourceFileContent);

ApplicationParts\RazorCompiledItemFeatureProviderTest.cs (2)

108Assert.Equal(expected, ex.Message); 147Assert.Equal("mvc.1.0.razor-page", item.Item.Kind);

Compilation\DefaultRazorPageFactoryProviderTest.cs (1)

97Assert.Equal("/file-exists", actual.Path);

DefaultTagHelperFactoryTest.cs (4)

44Assert.Equal(name, helper.Name); 91Assert.Equal("Test 1, Test 2", helper.Name); 130Assert.Equal("Test 1", testTagHelper.Name); 132Assert.Equal("Test 2", anotherTestTagHelper.Name);

RazorPageCreateModelExpressionTest.cs (9)

119Assert.Equal(expectedName, modelExpression.Name); 143Assert.Equal(expected, result.Name); 161Assert.Equal(expected, result.Name); 179Assert.Equal(expected, result.Name); 197Assert.Equal(expected, result.Name); 216Assert.Equal(expectedName, result.Name); 234Assert.Equal(expectedName, result.Name); 252Assert.Equal(expectedName, result.Name); 270Assert.Equal(expectedName, result.Name);

RazorPageTest.cs (29)

52Assert.Equal( 79Assert.Equal("HtmlEncode[[Hello Prefix]]HtmlEncode[[From Scope: ]]HtmlEncode[[Hello In Scope]]", pageOutput); 111Assert.Equal( 131Assert.Equal( 184Assert.Equal("There is no active writing scope to end.", ex.Message); 201Assert.Equal("HtmlEncode[[Hello World!]]", content.GetContent()); 242Assert.Equal("HtmlEncode[[Hello World!]]", content); 263Assert.Equal("Nesting of TagHelper attribute writing scopes is not supported.", ex.Message); 381Assert.Equal( 411Assert.Equal("Section 'qux' is already defined.", ex.Message); 433Assert.Equal(expected, page.RenderedContent); 449Assert.Equal("RenderSection invocation in '/Views/TestPath/Test.cshtml' is invalid. " + 473Assert.Equal(message, ex.Message); 579Assert.Equal( 603Assert.Equal( 627Assert.Equal( 646Assert.Equal( 666Assert.Equal($"RenderBody has not been called for the page at '{path}'. To ignore call IgnoreBody().", ex.Message); 705Assert.Equal( 755Assert.Equal("not-ignored-section-content", page.RenderedContent); 825Assert.Equal(expected, actual); 858Assert.Equal($"HtmlEncode[[{expected}]]", actual); 897Assert.Equal(expected, ex.Message); 1224Assert.Equal(expectedOutput, writer.ToString()); 1261Assert.Equal(expectedOutput, writer.ToString()); 1335Assert.Equal("Not buffered", defaultWriter.ToString()); 1336Assert.Equal("This should be buffered", bufferWriter.ToString()); 1352Assert.Equal("HtmlEncode[[This should be encoded]]", bufferWriter.ToString()); 1372Assert.Equal("Hello world", HtmlContentUtilities.HtmlContentToString(buffer));

RazorViewEngineTest.cs (32)

159Assert.Equal("test-view", result.ViewName); 191Assert.Equal("test-view", result1.ViewName); 324Assert.Equal("test-view", result.ViewName); 383Assert.Equal(viewName, result.ViewName); 409Assert.Equal(viewName, result.ViewName); 435Assert.Equal(viewName, result.ViewName); 463Assert.Equal(viewName, result.ViewName); 491Assert.Equal(viewName, result.ViewName); 519Assert.Equal(viewName, result.ViewName); 1174Assert.Equal(expander.ToString(), c.Values["expander-key"]); 1189Assert.Equal("layout", result.Name); 1233Assert.Equal(expander.ToString(), c.Values["expander-key"]); 1248Assert.Equal("layout", result.Name); 1272Assert.Equal("layout", result.Name); 1308Assert.Equal("details", result.Name); 1342Assert.Equal("foo", result.Name); 1378Assert.Equal("foo", result.Name); 1407Assert.Equal("bar", result.Name); 1436Assert.Equal(pageName, result.Name); 1464Assert.Equal(pageName, result.Name); 1492Assert.Equal(pageName, result.Name); 1534Assert.Equal("/Views/Shared/_Partial.cshtml", result); 1550Assert.Equal(expected, result); 1586Assert.Equal(expectedPagePath, result); 1603Assert.Equal(expectedPagePath, result); 1626Assert.Equal("Route-Value", result); 1650Assert.Equal("10/31/2018 07:37:38 -07:00", result); 1673Assert.Equal("route-value", result); 1696Assert.Equal("route-value", result); 1723Assert.Equal("43", result); 1845Assert.Equal("MyController", c.ControllerName); 1881Assert.Equal("MyPage", c.PageName);

RazorViewTest.cs (31)

TagHelpers\TagHelperComponentTagHelperTest.cs (2)

181Assert.Equal("Processed1", output.PostContent.GetContent()); 214Assert.Equal("Processed0Processed1Processed2", output.PostContent.GetContent());

ViewPathTest.cs (2)

19Assert.Equal("/Views/Home/Index.cshtml", normalizedPath); 31Assert.Equal("/Views/Home/Index.cshtml", normalizedPath);

ApplicationModels\CompiledPageActionDescriptorBuilderTest.cs (3)

236Assert.Equal(handlerModel.HttpMethod, d.HttpMethod); 237Assert.Equal(handlerModel.HandlerName, d.Name); 290Assert.Equal(parameterModel1.ParameterName, p.Name);

ApplicationModels\CompiledPageRouteModelProviderTest.cs (81)

ApplicationModels\DefaultPageApplicationModelProviderTest.cs (35)

ApplicationModels\PageRouteModelFactoryTest.cs (35)

ApplicationModels\ResponseCacheFilterApplicationModelProviderTest.cs (1)

73Assert.Equal("Abc", filter.VaryByHeader);

ApplicationModels\TempDataFilterPageApplicationModelProviderTest.cs (3)

41Assert.Equal(expected, ex.Message); 94Assert.Equal("Test2", property.Key); 116Assert.Equal("Test2", property.Key);

Builder\PageActionEndpointConventionBuilderResourceCollectionExtensionsTest.cs (5)

79Assert.Equal("named.css", list[0].Url); 101Assert.Equal("default.css", list[0].Url); 124Assert.Equal("default.css", list[0].Url); 147Assert.Equal("named.css", list[0].Url); 173Assert.Equal("named.css", list[0].Url);

DependencyInjection\PageConventionCollectionExtensionsTest.cs (67)

Filters\PageSaveTempDataPropertyFilterTest.cs (3)

74Assert.Equal("Value", pageModel.Test); 155Assert.Equal("Value", model.Test); 185Assert.Equal("Test", item.Key);

Filters\PageViewDataAttributeFilterTest.cs (2)

82Assert.Equal("Prop1", kvp.Key); 87Assert.Equal("Prop2", kvp.Key);

Infrastructure\DefaultPageFactoryProviderTest.cs (2)

36Assert.Equal( 128Assert.Equal("/this/is/a/path.cshtml", testPage.Path);

Infrastructure\DefaultPageHandlerMethodSelectorTest.cs (2)

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

Infrastructure\DynamicPageEndpointMatcherPolicyTest.cs (8)

210Assert.Equal("page", kvp.Key); 251Assert.Equal("page", kvp.Key); 256Assert.Equal("slug", kvp.Key); 261Assert.Equal("state", kvp.Key); 378Assert.Equal("page", kvp.Key); 383Assert.Equal("slug", kvp.Key); 388Assert.Equal("state", kvp.Key); 391Assert.Equal("ReplacedLoaded", candidates[0].Endpoint.DisplayName);

Infrastructure\ExecutorFactoryTest.cs (3)

71Assert.Equal("Hello 0", contentResult.Content); 160Assert.Equal("value", contentResult.Content); 179Assert.Equal($"Unsupported handler method return type '{methodInfo.ReturnType}'.", ex.Message);

Infrastructure\PageActionDescriptorProviderTest.cs (29)

62Assert.Equal("/Test.cshtml", descriptor.RelativePath); 63Assert.Equal("/Test", descriptor.RouteValues["page"]); 64Assert.Equal("/Test/{id:int?}", descriptor.AttributeRouteInfo.Template); 101Assert.Equal(model.RelativePath, descriptor.RelativePath); 106Assert.Equal("custom-key", kvp.Key); 107Assert.Equal("custom-value", kvp.Value); 111Assert.Equal("page", kvp.Key); 112Assert.Equal("/Test", kvp.Value); 151Assert.Equal(model.RelativePath, descriptor.RelativePath); 156Assert.Equal("area", kvp.Key); 157Assert.Equal("Accounts", kvp.Value); 161Assert.Equal("page", kvp.Key); 162Assert.Equal("/Test", kvp.Value); 164Assert.Equal("Accounts", descriptor.AreaName); 165Assert.Equal("Accounts/Test/{id:int?}", descriptor.AttributeRouteInfo.Template); 197Assert.Equal(model.RelativePath, descriptor.RelativePath); 231Assert.Equal(model.RelativePath, descriptor.RelativePath); 284result => Assert.Equal("base-path/Test/Home", result.AttributeRouteInfo.Template), 285result => Assert.Equal("base-path/Index", result.AttributeRouteInfo.Template), 286result => Assert.Equal("base-path/", result.AttributeRouteInfo.Template), 287result => Assert.Equal("base-path/Admin/Index", result.AttributeRouteInfo.Template), 288result => Assert.Equal("base-path/Admin", result.AttributeRouteInfo.Template), 289result => Assert.Equal("base-path/Admin/User", result.AttributeRouteInfo.Template)); 331Assert.Equal("/Catalog/Details/Index.cshtml", descriptor.RelativePath); 332Assert.Equal("/Catalog/Details/Index", descriptor.RouteValues["page"]); 333Assert.Equal("/Catalog/Details/Index/{id:int?}", descriptor.AttributeRouteInfo.Template); 338Assert.Equal("/Catalog/Details/Index.cshtml", descriptor.RelativePath); 339Assert.Equal("/Catalog/Details/Index", descriptor.RouteValues["page"]); 340Assert.Equal("/Catalog/Details/{id:int?}", descriptor.AttributeRouteInfo.Template);

Infrastructure\PageActionEndpointDataSourceTest.cs (6)

87Assert.Equal("/test", e.RoutePattern.RawText); 89Assert.Equal("Hi there", e.Metadata.GetMetadata<string>()); 157Assert.Equal("/group1/test", e.RoutePattern.RawText); 164Assert.Equal("/group1/test2", e.RoutePattern.RawText); 207Assert.Equal("/test", e.RoutePattern.RawText); 255Assert.Equal("/test", e.RoutePattern.RawText);

Infrastructure\PageActionInvokerProviderTest.cs (1)

132Assert.Equal(descriptor.RelativePath, compiledPageActionDescriptor.RelativePath);

Infrastructure\PageActionInvokerTest.cs (13)

349Assert.Equal(relativePath, page.ViewContext.ExecutingFilePath); 1420m => Assert.Equal($"Route matched with {{page = \"foo\"}}. Executing page {pagePath}", m), 1421m => Assert.Equal("Execution plan of authorization filters (in the following order): None", m), 1422m => Assert.Equal("Execution plan of resource filters (in the following order): None", m), 1423m => Assert.Equal("Execution plan of action filters (in the following order): None", m), 1424m => Assert.Equal("Execution plan of exception filters (in the following order): None", m), 1425m => Assert.Equal("Execution plan of result filters (in the following order): None", m), 1426m => Assert.Equal($"Executing {factoryType} factory for page {pageName}", m), 1427m => Assert.Equal($"Executed {factoryType} factory for page {pageName}", m), 1428m => Assert.Equal($"Executing handler method {methodFullName} - ModelState is Valid", m), 1429m => Assert.Equal($"Executed handler method {methodName}, returned result {resultName}.", m), 1430m => Assert.Equal($"Before executing action result {resultName}.", m), 1431m => Assert.Equal($"After executing action result {resultName}.", m),

Infrastructure\PageBinderFactoryTest.cs (11)

230Assert.Equal("route-value", page.RouteDifferentValue); 296Assert.Equal("route-value", model.RouteDifferentValue); 342Assert.Equal(defaultValue, model.PropertyWithDefaultValue); 404Assert.Equal("value", model.SupportsGet); 405Assert.Equal("set", model.Default); 465Assert.Equal("value", model.SupportsGet); 466Assert.Equal("value", model.Default); 571Assert.Equal(nameof(PageModelWithValidation.Validated), kvp.Key); 613Assert.Equal("id", kvp.Key); 701Assert.Equal("name", kvp.Key); 751Assert.Equal("Some error", error.ErrorMessage);

Infrastructure\ServiceBasedPageModelActivatorProviderTest.cs (1)

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

PageLoggerExtensionsTest.cs (6)

35Assert.Equal( 63Assert.Equal( 91Assert.Equal( 119Assert.Equal( 152Assert.Equal( 183Assert.Equal(

PageModelTest.cs (94)

PageTest.cs (93)

src\Mvc\Mvc.Core\test\Routing\ActionEndpointDataSourceBaseTest.cs (4)

37Assert.Equal("/Template!", endpoint.RoutePattern.RawText); 61(e) => Assert.Equal("/test", Assert.IsType<RouteEndpoint>(e).RoutePattern.RawText)); 99Assert.Equal("/test", routePattern.RawText); 121Assert.Equal("/test", routePattern.RawText);

VirtualPathDataTests.cs (2)

22Assert.Equal(path, pathData.VirtualPath); 41Assert.Equal(path, pathData.VirtualPath);

AnchorTagHelperTest.cs (12)

83Assert.Equal("Something", output.Content.GetContent()); 84Assert.Equal(expectedTagName, output.TagName); 132Assert.Equal("a", output.TagName); 184Assert.Equal("a", output.TagName); 242Assert.Equal("a", output.TagName); 301Assert.Equal("a", output.TagName); 359Assert.Equal("a", output.TagName); 454Assert.Equal("area", item.Key); 527Assert.Equal(expectedErrorMessage, ex.Message); 567Assert.Equal(expectedErrorMessage, ex.Message); 605Assert.Equal(expectedErrorMessage, ex.Message); 643Assert.Equal(expectedErrorMessage, ex.Message);

CacheTagHelperTest.cs (23)

CacheTagKeyTest.cs (13)

40Assert.Equal(expected, key); 166Assert.Equal(expected, key); 189Assert.Equal(expected, key); 219Assert.Equal(expected, key); 247Assert.Equal(expected, key); 273Assert.Equal(expected, key); 299Assert.Equal(expected, key); 324Assert.Equal(expected, key); 344Assert.Equal(expected, key); 366Assert.Equal(expected, key); 387Assert.Equal(expected, key); 413Assert.Equal(expected, key); 438Assert.Equal(expected, key);

ComponentTagHelperTest.cs (2)

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

DefaultFileVersionProviderTest.cs (15)

34Assert.Equal(expected, result); 54Assert.Equal(path, result); 62Assert.Equal(path, result); 84Assert.Equal($"{path}?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", result); 92Assert.Equal($"{path}?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", result); 109Assert.Equal("file.txt", result); 117Assert.Equal("file.txt?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", result); 133Assert.Equal("file.txt?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", result); 141Assert.Equal("file.txt", result); 157Assert.Equal("/wwwroot/file.txt?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", result); 165Assert.Equal("/wwwroot/file.txt", result); 210Assert.Equal(filePath + "?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", result); 226Assert.Equal("http://contoso.com/hello/world", result); 245Assert.Equal("FromCache", result); 280Assert.Equal(expected, result);

DistributedCacheTagHelperTest.cs (16)

FormActionTagHelperTest.cs (17)

87Assert.Equal(expectedTagName, output.TagName); 161Assert.Equal(expectedTagName, output.TagName); 247Assert.Equal("button", output.TagName); 249Assert.Equal("formaction", attribute.Name); 305Assert.Equal("button", output.TagName); 307Assert.Equal("formaction", attribute.Name); 378Assert.Equal("submit", output.TagName); 380Assert.Equal("formaction", attribute.Name); 431Assert.Equal("submit", output.TagName); 433Assert.Equal("formaction", attribute.Name); 465Assert.Equal("area", item.Key); 470Assert.Equal("page", item.Key); 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 (26)

GlobbingUrlBuilderTest.cs (14)

29Assert.Collection(urlList, url => Assert.Equal("/site.css", url)); 46url => Assert.Equal("/site.css", url), 47url => Assert.Equal("/blank.css", url)); 218actual => Assert.Equal(expected, actual)); 241url => Assert.Equal($"{pathBase}/blank.css", url), 242url => Assert.Equal($"{pathBase}/site.css", url)); 263url => Assert.Equal("/blank.css", url), 264url => Assert.Equal("/site.css", url)); 293url => Assert.Equal("/blank.css", url), 294url => Assert.Equal("/site.css", url)); 378Assert.Collection(includePatterns, pattern => Assert.Equal("**/*.css", pattern)); 379Assert.Collection(excludePatterns, pattern => Assert.Equal("**/*.min.css", pattern)); 406Assert.Collection(includePatterns, pattern => Assert.Equal($"{prefix}**/*.css", pattern)); 407Assert.Collection(excludePatterns, pattern => Assert.Equal($"{prefix}**/*.min.css", pattern));

ImageTagHelperTest.cs (7)

119Assert.Equal(expectedOutput.TagName, output.TagName); 126Assert.Equal(expectedAttribute.Name, actualAttribute.Name); 127Assert.Equal(expectedAttribute.Value.ToString(), actualAttribute.Value.ToString()); 158Assert.Equal("img", output.TagName); 210Assert.Equal("img", output.TagName); 253Assert.Equal("img", output.TagName); 285Assert.Equal("img", output.TagName);

InputTagHelperTest.cs (62)

JavaScriptResourcesTest.cs (4)

25Assert.Equal(expected, result); 44Assert.Equal("test.js", kvp.Key); 45Assert.Equal(expected, kvp.Value); 87Assert.Equal(expected, result);

LabelTagHelperTest.cs (5)

219Assert.Equal(expectedPreContent, output.PreContent.GetContent()); 220Assert.Equal( 223Assert.Equal(expectedPostContent, output.PostContent.GetContent()); 225Assert.Equal(expectedTagName, output.TagName); 328Assert.Equal(expectedContent, HtmlContentUtilities.HtmlContentToString(output.Content));

LinkTagHelperTest.cs (23)

OptionTagHelperTest.cs (2)

436Assert.Equal(expectedTagHelperOutput.TagName, output.TagName); 437Assert.Equal(expectedTagHelperOutput.Content.GetContent(), output.Content.GetContent());

PartialTagHelperTest.cs (14)

PrerenderComponentApplicationStoreTest.cs (1)

26Assert.Equal(expected, store.PersistedState);

ProtectedPrerenderComponentApplicationStateTest.cs (1)

33Assert.Equal(expected, _protector.Unprotect(store.PersistedState));

RenderAtEndOfFormTagHelperTest.cs (2)

77Assert.Equal(expectedOutput, tagHelperOutput.PostContent.GetContent()); 117Assert.Equal(expectedOutput, tagHelperExecutionContext.Output.PostContent.GetContent());

ScriptTagHelperTest.cs (27)

SelectTagHelperTest.cs (20)

TagHelperOutputExtensionsTest.cs (7)

987Assert.Equal(expectedValue, HtmlContentUtilities.HtmlContentToString(classAttribute)); 1009Assert.Equal(expectedValue, HtmlContentUtilities.HtmlContentToString(classAttribute)); 1035Assert.Equal(expectedValue, HtmlContentUtilities.HtmlContentToString(classAttribute)); 1055Assert.Equal(expected, exceptionAdd.Message); 1056Assert.Equal(expected, exceptionRemove.Message); 1101Assert.Equal(expectedValue, HtmlContentUtilities.HtmlContentToString(classAttribute)); 1145Assert.Equal(expectedValue, HtmlContentUtilities.HtmlContentToString(classAttribute));

TextAreaTagHelperTest.cs (5)

153Assert.Equal(expectedContent, HtmlContentUtilities.HtmlContentToString(output.Content)); 154Assert.Equal(expectedTagName, output.TagName); 227Assert.Equal(expectedTagName, output.TagName); 228Assert.Equal(expectedContent, HtmlContentUtilities.HtmlContentToString(output.Content)); 231Assert.Equal("name", attribute.Name);

ValidationMessageTagHelperTest.cs (22)

ValidationSummaryTagHelperTest.cs (35)

MvcOptionsSetupTest.cs (3)

118Assert.Equal("application/json", mapping); 267Assert.Equal(typeof(XObject).FullName, excludeFilter.FullTypeName); 272Assert.Equal(typeof(XmlNode).FullName, excludeFilter.FullTypeName);

AntiforgeryExtensionsTest.cs (1)

29Assert.Equal(

AttributeDictionaryTest.cs (8)

202key => Assert.Equal("one", key), 203key => Assert.Equal("two", key), 204key => Assert.Equal("zero", key)); 314Assert.Equal("2", value); 354key => Assert.Equal("1", key), 355key => Assert.Equal("2", key), 356key => Assert.Equal("0", key)); 373Assert.Equal("2", value);

Buffers\PagedBufferedTextWriterTest.cs (3)

201Assert.Equal("abcdefghi", inner.ToString()); 220Assert.Equal("abcdefg", inner.ToString()); 239Assert.Equal("abcdefghi", inner.ToString());

Buffers\ViewBufferTest.cs (8)

59Assert.Equal("Hello world", Assert.IsType<string>(page.Buffer[0].Value)); 178Assert.Equal("HtmlEncode[[Hello]] world 123", writer.ToString()); 201Assert.Equal(expected, writer.ToString()); 219Assert.Equal("HtmlEncode[[Hello]] world 123", writer.ToString()); 243Assert.Equal(expected, writer.ToString()); 265Assert.Equal("Hello", Assert.IsType<HtmlString>(nestedItems[0]).Value); 266Assert.Equal("Hello", Assert.IsType<HtmlString>(destinationItems[0]).Value); 289Assert.Equal("Hello", Assert.IsType<HtmlString>(destinationItems[0]).Value);

Builder\ControllerActionEndpointConventionBuilderResourceCollectionExtensionsTest.cs (5)

106Assert.Equal("named.css", list[0].Url); 137Assert.Equal("default.css", list[0].Url); 169Assert.Equal("default.css", list[0].Url); 201Assert.Equal("named.css", list[0].Url); 236Assert.Equal("named.css", list[0].Url);

ControllerTest.cs (4)

123Assert.Equal("CustomViewName", actualViewResult.ViewName); 167Assert.Equal("CustomViewName", actualViewResult.ViewName); 236Assert.Equal("CustomViewName", actualViewResult.ViewName); 280Assert.Equal("CustomViewName", actualViewResult.ViewName);

ControllerUnitTestabilityTests.cs (26)

30Assert.Equal(viewName, viewResult.ViewName); 52Assert.Equal(viewName, viewResult.ViewName); 76Assert.Equal(content, contentResult.Content); 77Assert.Equal("text/asp; charset=us-ascii", contentResult.ContentType.ToString()); 97Assert.Equal(uri, createdResult.Location); 117Assert.Equal(uri, acceptedResult.Location); 138Assert.Equal(contentType, fileContentResult.ContentType.ToString()); 139Assert.Equal(fileName ?? string.Empty, fileContentResult.FileDownloadName); 147Assert.Equal(content, Encoding.UTF8.GetString(fileContentResult.FileContents)); 171Assert.Equal(contentType, fileStreamResult.ContentType.ToString()); 172Assert.Equal(fileName ?? string.Empty, fileStreamResult.FileDownloadName); 182Assert.Equal(content, stream.ReadToEnd()); 334Assert.Equal(routeName, createdAtRouteResult.RouteName); 370Assert.Equal(routeName, acceptedAtRouteResult.RouteName); 407Assert.Equal(actionName, createdAtActionResult.ActionName); 408Assert.Equal(controllerName, createdAtActionResult.ControllerName); 446Assert.Equal(actionName, acceptedAtActionResult.ActionName); 447Assert.Equal(controllerName, acceptedAtActionResult.ControllerName); 483Assert.Equal(routeName, redirectToRouteResult.RouteName); 517Assert.Equal(actionName, redirectToActionResult.ActionName); 518Assert.Equal(controllerName, redirectToActionResult.ControllerName); 551Assert.Equal(url, redirectResult.Url); 648Assert.Equal("TagCloud", result.ViewComponentName); 695Assert.Equal(detail, problemDetails.Detail); 712Assert.Equal(detail, validationProblemDetails.Detail); 714Assert.Equal("some-key", error.Key);

CookieTempDataProviderTest.cs (12)

49Assert.Equal(expectedDataInCookie, cookieInfo.Value); 50Assert.Equal("/", cookieInfo.Options.Path); 91Assert.Equal(CookieTempDataProvider.CookieName, setCookieHeader.Name.ToString()); 92Assert.Equal(string.Empty, setCookieHeader.Value.ToString()); 136Assert.Equal(expectedDataInCookie, cookieInfo.Value); 172Assert.Equal(expectedDataInCookie, cookieInfo.Value); 174Assert.Equal("/", cookieInfo.Options.Path); 207Assert.Equal(expectedDataInCookie, cookieInfo.Value); 209Assert.Equal(expectedCookiePath, cookieInfo.Options.Path); 256Assert.Equal(expectedDataInCookie, cookieInfo.Value); 258Assert.Equal(expectedCookiePath, cookieInfo.Options.Path); 259Assert.Equal(expectedDomain, cookieInfo.Options.Domain);

DefaultDisplayTemplatesTest.cs (12)

DefaultEditorTemplatesTest.cs (30)

DefaultHtmlGeneratorTest.cs (6)

133Assert.Equal(expected, attribute.Value); 187Assert.Equal(expected, attribute.Value); 487Assert.Equal(expected, attribute.Value); 530Assert.Equal( 974Assert.Equal(expectedAntiforgeryHtmlField, antiforgeryField); 998Assert.Equal(expected, antiforgeryField);

DefaultValidationHtmlAttributeProviderTest.cs (12)

45Assert.Equal("data-val", kvp.Key); 46Assert.Equal("true", kvp.Value); 50Assert.Equal("data-val-number", kvp.Key); 51Assert.Equal(expectedMessage, kvp.Value); 81Assert.Equal("data-val", kvp.Key); 82Assert.Equal("true", kvp.Value); 86Assert.Equal("data-val-number", kvp.Key); 87Assert.Equal(expectedMessage, kvp.Value); 180Assert.Equal("data-val", kvp.Key); 181Assert.Equal("true", kvp.Value); 185Assert.Equal("data-val-number", kvp.Key); 186Assert.Equal(expectedMessage, kvp.Value);

ExpressionHelperTest.cs (2)

373Assert.Equal(expressionText, text); 452Assert.Equal(expectedText, result);

Filters\AntiforgeryApplicationModelProviderTest.cs (6)

30Assert.Equal(nameof(TestController.WithAntiforgeryMetadata), model.ActionName); 35Assert.Equal(nameof(TestController.WithMvcAttribute), model.ActionName); 40Assert.Equal(nameof(TestController.NoAttributes), model.ActionName); 115Assert.Equal(nameof(AntiforgeryMetadataWithActionsController.Post), model.ActionName); 120Assert.Equal(nameof(AntiforgeryMetadataWithActionsController.Post2), model.ActionName); 137Assert.Equal(

Filters\ControllerSaveTempDataPropertyFilterTest.cs (5)

55Assert.Equal("SecondValue", controller.Test); 99Assert.Equal("FirstValue", controller.Test); 142Assert.Equal("Value", controller.Test); 189Assert.Equal(nameof(TestController.Test), item.Key); 194Assert.Equal(nameof(TestController.Test2), item.Key);

Filters\ControllerViewDataAttributeFilterTest.cs (2)

77Assert.Equal("Prop1", kvp.Key); 82Assert.Equal("Prop2", kvp.Key);

Filters\LifecyclePropertyTest.cs (1)

35Assert.Equal("new-value", subject.TestProperty);

Filters\TempDataApplicationModelProviderTest.cs (1)

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

FormatWeekHelperTest.cs (1)

39Assert.Equal(expectedOutput, formattedValue);

HtmlAttributePropertyHelperTest.cs (7)

22Assert.Equal("bar_baz", property.Name); 23Assert.Equal("bar-baz", helper.Name); 37Assert.Equal("foo", property.Name); 38Assert.Equal("foo", helper.Name); 52Assert.Equal("bar", helper.Name); 67Assert.Equal("foo", helper.Name); 107Assert.Equal("bar-baz1", helpers1[0].Name);

Infrastructure\DefaultTempDataSerializerTest.cs (2)

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

Infrastructure\TempDataSerializerTestBase.cs (3)

108Assert.Equal(value, roundTripValue); 193Assert.Equal(value.ToString(CultureInfo.InvariantCulture), roundTripValue); 215Assert.Equal(value.ToString("N"), roundTripValue);

ModelExplorerExtensionsTest.cs (1)

58Assert.Equal(expectedResult, result);

ModelStateDictionaryExtensionsTest.cs (21)

PageRemoteAttributeTest.cs (4)

57Assert.Equal("/Foo", routeDictionary["page"] as string); 58Assert.Equal("Bar", routeDictionary["handler"] as string); 124Assert.Equal("/Page?handler=Handler", actualUrl); 155Assert.Equal("/Page?handler=Handler", actualUrl);

PartialViewResultExecutorTest.cs (7)

51Assert.Equal(viewName, viewEngineResult.ViewName); 73Assert.Equal(viewName, viewEngineResult.ViewName); 97Assert.Equal(viewName, viewEngineResult.ViewName); 228Assert.Equal(viewName, viewEngineResult.ViewName); 235Assert.Equal("myview", listener.ViewFound.ViewName); 277Assert.Equal("myview", listener.ViewNotFound.ViewName); 301Assert.Equal("application/x-my-content-type", context.HttpContext.Response.ContentType);

PartialViewResultTest.cs (4)

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

RemoteAttributeBaseTest.cs (84)

RemoteAttributeTest.cs (30)

57Assert.Equal("controller", keyValuePair.Key); 68Assert.Equal("action", keyValuePair.Key); 82Assert.Equal(routeName, attribute.RouteName); 150Assert.Equal("No URL for remote validation could be found.", exception.Message); 167Assert.Equal(url, actualUrl); 186Assert.Equal(url, actualUrl); 190Assert.Equal("Action", routeDictionary["action"] as string); 191Assert.Equal("Controller", routeDictionary["controller"] as string); 207Assert.Equal(url, actualUrl); 211Assert.Equal("Action", routeDictionary["action"] as string); 212Assert.Equal("Controller", routeDictionary["controller"] as string); 213Assert.Equal("Test", routeDictionary["area"] as string); 228Assert.Equal("/Controller/Action", actualUrl); 243Assert.Equal("/Test/Controller/Action", actualUrl); 259Assert.Equal("/Controller/Action", actualUrl); 275Assert.Equal("/Controller/Action", actualUrl); 290Assert.Equal("/Test/Controller/Action", actualUrl); 305Assert.Equal("/Test/Controller/Action", actualUrl); 320Assert.Equal("/AnotherArea/Controller/Action", actualUrl); 347kvp => { Assert.Equal("data-val", kvp.Key); Assert.Equal("original", kvp.Value); }, 348kvp => { Assert.Equal("data-val-remote", kvp.Key); Assert.Equal("original", kvp.Value); }, 349kvp => { Assert.Equal("data-val-remote-additionalfields", kvp.Key); Assert.Equal("original", kvp.Value); }, 350kvp => { Assert.Equal("data-val-remote-type", kvp.Key); Assert.Equal("original", kvp.Value); }, 351kvp => { Assert.Equal("data-val-remote-url", kvp.Key); Assert.Equal("original", kvp.Value); }); 536Assert.Equal(_routeName, routeContext.RouteName);

Rendering\HtmlHelperCheckboxTest.cs (40)

Rendering\HtmlHelperDisplayExtensionsTest.cs (17)

Rendering\HtmlHelperDisplayNameExtensionsTest.cs (19)

49Assert.Equal("Property1", displayNameResult); 50Assert.Equal("Property1", displayNameForResult); 51Assert.Equal("Property1", displayNameForEnumerableResult); 66Assert.Equal("value", displayNameResult); 82Assert.Equal("Id", displayNameResult); 83Assert.Equal("Id", displayNameForResult); 84Assert.Equal("Id", displayNameForEnumerableResult); 108Assert.Equal(displayName, displayNameResult); 109Assert.Equal(displayName, displayNameForResult); 110Assert.Equal(displayName, displayNameForEnumerableResult); 111Assert.Equal(displayName, displayNameForModelResult); 134Assert.Equal(displayName, displayNameResult); 135Assert.Equal(displayName, displayNameForResult); 136Assert.Equal(displayName, displayNameForEnumerableResult); 156Assert.Equal(expectedResult, result); 168Assert.Equal( 183Assert.Equal( 199Assert.Equal("unknownKey", result); 214Assert.Equal("unknownKey", result);

Rendering\HtmlHelperDisplayTextTest.cs (19)

57Assert.Equal("Null display Text", result); 76Assert.Equal("Null display Text", result); 91Assert.Equal("Model value", result); 92Assert.Equal("Model value", nullResult); 120Assert.Equal("Model value", result); 144Assert.Equal("Simple display text", result); 168Assert.Equal("Simple display text", result); 193Assert.Equal("Property value", result); 210Assert.Equal("Property value", result); 228Assert.Equal("View data dictionary value", result); 246Assert.Equal("Property value", result); 271Assert.Equal("View data dictionary value", result); 296Assert.Equal("Property value", result); 311Assert.Equal("Value One", result); 312Assert.Equal("Value One", forResult); 327Assert.Equal("Value One", result); 328Assert.Equal("Value One", forResult); 343Assert.Equal("Value1", result); 344Assert.Equal("Value1", forResult);

Rendering\HtmlHelperDropDownListExtensionsTest.cs (9)

Rendering\HtmlHelperEditorExtensionsTest.cs (2)

35Assert.Equal(expectedResult, HtmlContentUtilities.HtmlContentToString(displayResult)); 61Assert.Equal(expectedResult, HtmlContentUtilities.HtmlContentToString(displayResult));

Rendering\HtmlHelperFormExtensionsTest.cs (27)

Rendering\HtmlHelperHiddenTest.cs (43)

Rendering\HtmlHelperLabelExtensionsTest.cs (51)

Rendering\HtmlHelperLinkGenerationTest.cs (2)

87Assert.Equal(expectedLink, HtmlContentUtilities.HtmlContentToString(actualLink)); 154Assert.Equal(expectedLink, HtmlContentUtilities.HtmlContentToString(actualLink));

Rendering\HtmlHelperListBoxExtensionsTest.cs (6)

40Assert.Equal(expectedHtml, HtmlContentUtilities.HtmlContentToString(listBoxResult)); 65Assert.Equal(expectedHtml, HtmlContentUtilities.HtmlContentToString(listBoxResult)); 90Assert.Equal(expectedHtml, HtmlContentUtilities.HtmlContentToString(listBoxResult)); 112Assert.Equal(expectedHtml, HtmlContentUtilities.HtmlContentToString(listBoxForResult)); 137Assert.Equal(expectedHtml, HtmlContentUtilities.HtmlContentToString(listBoxForResult)); 162Assert.Equal(expectedHtml, HtmlContentUtilities.HtmlContentToString(listBoxForResult));

Rendering\HtmlHelperNameExtensionsTest.cs (22)

Rendering\HtmlHelperPartialExtensionsTest.cs (9)

Rendering\HtmlHelperPasswordTest.cs (19)

Rendering\HtmlHelperRadioButtonExtensionsTest.cs (9)

26Assert.Equal( 41Assert.Equal( 61Assert.Equal( 81Assert.Equal( 96Assert.Equal( 114Assert.Equal( 134Assert.Equal( 155Assert.Equal( 197Assert.Equal(

Rendering\HtmlHelperSelectTest.cs (41)

Rendering\HtmlHelperTest.cs (7)

198Assert.Equal(expectedString, result); 215Assert.Equal(expectedString, result); 267Assert.Equal(expectedString, result.ToString()); 284Assert.Equal(expectedString, result.ToString()); 376Assert.Equal(expected, result); 389Assert.Equal(expected, result); 406Assert.Equal(expected, result);

Rendering\HtmlHelperTextAreaExtensionsTest.cs (7)

28Assert.Equal( 47Assert.Equal( 66Assert.Equal( 85Assert.Equal( 105Assert.Equal( 122Assert.Equal( 139Assert.Equal(

Rendering\HtmlHelperTextAreaTest.cs (2)

85Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(result)); 136Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(result));

Rendering\HtmlHelperTextBoxExtensionsTest.cs (8)

29Assert.Equal( 47Assert.Equal( 65Assert.Equal( 83Assert.Equal( 101Assert.Equal( 128Assert.Equal( 156Assert.Equal( 202Assert.Equal(

Rendering\HtmlHelperTextBoxTest.cs (2)

103Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(result)); 154Assert.Equal(expected, HtmlContentUtilities.HtmlContentToString(result));

Rendering\HtmlHelperValidationMessageExtensionsTest.cs (8)

23Assert.Equal( 38Assert.Equal( 53Assert.Equal( 68Assert.Equal( 83Assert.Equal( 98Assert.Equal( 113Assert.Equal( 128Assert.Equal(

Rendering\HtmlHelperValidationSummaryTest.cs (19)

Rendering\HtmlHelperValueExtensionsTest.cs (4)

21Assert.Equal("ModelValue", result); 35Assert.Equal("ModelValue", result); 49Assert.Equal("{ SomeProperty = ModelValue }", result); 63Assert.Equal("-{ SomeProperty = ModelValue }-", result);

Rendering\HtmlHelperValueTest.cs (21)

27Assert.Equal("ViewDataValue", html); 42Assert.Equal("PrefixedViewDataValue", html); 56Assert.Equal("ContainedViewDataValue", html); 71Assert.Equal("ContainedViewDataValue", html); 85Assert.Equal("ModelStringPropertyValue", html); 100Assert.Equal("ModelStringPropertyValue", html); 144Assert.Equal("ModelStringPropertyValue", html); 174Assert.Equal("StringPropertyRawValue", helper.Value("StringProperty", format: null)); 175Assert.Equal("StringPropertyRawValue", helper.ValueFor(m => m.StringProperty, format: null)); 176Assert.Equal("ModelRawValue", helper.ValueForModel(format: null)); 189Assert.Equal(expectedModelValue, helper.Value(expression: string.Empty, format: null)); 190Assert.Equal(expectedModelValue, helper.Value(expression: null, format: null)); // null is another alias for current model 191Assert.Equal(expectedModelValue, helper.ValueFor(m => m, format: null)); 192Assert.Equal(expectedModelValue, helper.ValueForModel(format: null)); 206Assert.Equal(expectedModelValue, helper.ValueForModel("-{0}-")); 207Assert.Equal(expectedObjectPropertyValue, helper.Value("ObjectProperty", "-{0}-")); 208Assert.Equal(expectedObjectPropertyValue, helper.ValueFor(m => m.ObjectProperty, "-{0}-")); 226Assert.Equal( 229Assert.Equal("<ViewDataValue <\"\">>", helper.Value("StringProperty", "<{0}>")); 230Assert.Equal("<ModelStringPropertyValue <\"\">>", helper.ValueFor(m => m.StringProperty, "<{0}>")); 231Assert.Equal("ObjectPropertyRawValue <\"\">", helper.ValueFor(m => m.ObjectProperty, format: null));

Rendering\HtmlStringTest.cs (4)

23Assert.Equal(expectedText, writer.ToString()); 37Assert.Equal(expectedText, content.ToString()); 47Assert.Equal(string.Empty, content.ToString()); 61Assert.Equal(expectedText, result);

Rendering\JsonHelperTestBase.cs (4)

43Assert.Equal(expectedOutput, htmlString.ToString()); 62Assert.Equal(expectedOutput, htmlString.ToString()); 100Assert.Equal(expectedOutput, htmlString.ToString()); 119Assert.Equal(expectedOutput, htmlString.ToString());

Rendering\SystemTextJsonHelperTest.cs (2)

35Assert.Equal(expectedOutput, htmlString.ToString()); 54Assert.Equal(expectedOutput, htmlString.ToString());

Rendering\TagBuilderTest.cs (16)

StringHtmlContentTest.cs (1)

21Assert.Equal("HtmlEncode[[Hello World]]", writer.ToString());

TemplateRendererTest.cs (1)

57actual => Assert.Equal(expected, actual));

ViewComponentResultTest.cs (15)

ViewComponents\ContentViewComponentResultTest.cs (1)

34Assert.Equal("HtmlEncode[[<Test />]]", new StreamReader(buffer).ReadToEnd());

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\DefaultViewComponentHelperTest.cs (6)

43Assert.Equal("a", item.Key); 63Assert.Equal("a", item.Key); 83Assert.Equal("a", item1.Key); 89Assert.Equal("b", item2.Key); 110Assert.Equal("o", item.Key); 134Assert.Equal("a", item.Key);

ViewComponents\DefaultViewComponentSelectorTest.cs (2)

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

ViewComponents\HtmlContentViewComponentResultTest.cs (1)

35Assert.Equal("<Test />", new StreamReader(buffer).ReadToEnd());

ViewComponents\ViewComponentConventionsTest.cs (2)

71Assert.Equal(expected, result); 90Assert.Equal(expected, result);

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

ViewComponentTests.cs (4)

116Assert.Equal("CustomViewName", actualResult.ViewName); 175Assert.Equal("CustomViewName", actualResult.ViewName); 194Assert.Equal("CustomViewName", actualResult.ViewName); 214Assert.Equal("CustomViewName", actualResult.ViewName);

ViewDataDictionaryOfTModelTest.cs (15)

ViewDataDictionaryTest.cs (5)

142Assert.Equal( 203Assert.Equal("prefix", viewData.TemplateInfo.HtmlFieldPrefix); 403Assert.Equal( 741Assert.Equal("value", formattedValue); 755Assert.Equal("forvaluemat", formattedValue);

ViewDataOfTTest.cs (4)

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); 70Assert.Equal(string.Empty, viewData.TemplateInfo.HtmlFieldPrefix); 88Assert.Equal(string.Empty, viewData.TemplateInfo.HtmlFieldPrefix);

ViewEngines\CompositeViewEngineTest.cs (6)

46Assert.Equal(expected, exception.Message); 124Assert.Equal(viewName, result.ViewName); 174Assert.Equal(expected, exception.Message); 262Assert.Equal(expectedViewName, result.ViewName); 313Assert.Equal(expected, exception.Message); 391Assert.Equal(viewName, result.ViewName);

ViewExecutorTest.cs (4)

115Assert.Equal("This should be raw!", exception.Message); 156Assert.Equal("abcd", Encoding.UTF8.GetString(memoryStream.ToArray())); 247Assert.Equal("abcd", Encoding.UTF8.GetString(memoryStream.ToArray())); 286Assert.Equal("abcd", Encoding.UTF8.GetString(memoryStream.ToArray()));

ViewResultExecutorTest.cs (7)

50Assert.Equal(viewName, viewEngineResult.ViewName); 72Assert.Equal(viewName, viewEngineResult.ViewName); 96Assert.Equal(viewName, viewEngineResult.ViewName); 224Assert.Equal(viewName, viewEngineResult.ViewName); 231Assert.Equal("myview", listener.ViewFound.ViewName); 272Assert.Equal("myview", listener.ViewNotFound.ViewName); 296Assert.Equal("application/x-my-content-type", context.HttpContext.Response.ContentType);

ViewResultTest.cs (4)

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

Extensions\ApiDescriptionExtensionsTests.cs (1)

72Assert.Equal($"Unsupported HTTP method: {methodName}", exception.Message);

Extensions\OpenApiEndpointRouteBuilderExtensionsTests.cs (8)

45Assert.Equal(expectedPath, generatedEndpoint.RoutePattern.RawText); 70Assert.Equal("OpenApiEndpointRouteBuilderExtensionsTests | v1", document.Info.Title); 71Assert.Equal("1.0.0", document.Info.Version); 96Assert.Equal("OpenApiEndpointRouteBuilderExtensionsTests | v1", document.Info.Title); 97Assert.Equal("1.0.0", document.Info.Version); 121Assert.Equal("No OpenAPI document with the name 'v2' was found.", Encoding.UTF8.GetString(responseBodyStream.ToArray())); 149Assert.Equal($"OpenApiEndpointRouteBuilderExtensionsTests | {documentName}", document.Info.Title); 150Assert.Equal("1.0.0", document.Info.Version);

Extensions\OpenApiRouteHandlerBuilderExtensionTests.cs (2)

87Assert.Equal("number", parameter.Schema.Type); 178Assert.Equal("Set from outer group", operation.Summary);

Extensions\OpenApiServiceCollectionExtensionsTests.cs (6)

43Assert.Equal(documentName, namedOption.DocumentName); 77Assert.Equal(documentName, namedOption.DocumentName); 110Assert.Equal(documentName, namedOption.DocumentName); 143Assert.Equal(documentName, namedOption.DocumentName); 165Assert.Equal(documentName, namedOption.DocumentName); 189Assert.Equal(documentName, namedOption.DocumentName);

Services\CreateSchemaReferenceIdTests.cs (58)

Services\OpenApiDocumentProviderTests.cs (6)

28Assert.Equal($"{nameof(OpenApiDocumentProviderTests)} | {documentName}", document.Info.Title); 29Assert.Equal("1.0.0", document.Info.Version); 46x => Assert.Equal("v2", x), 47x => Assert.Equal("internal", x), 48x => Assert.Equal("public", x), 49x => Assert.Equal("v1", x));

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.Info.cs (2)

33Assert.Equal("TestApplication | v1", info.Title); 56Assert.Equal("TestApplication | v2", info.Title);

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.Operations.cs (16)

26Assert.Equal(summary, operation.Summary); 44Assert.Equal(summary + "1", operation.Summary); 62Assert.Equal(description, operation.Description); 80Assert.Equal(description + "1", operation.Description); 99Assert.Equal("todos", tag.Name); 103Assert.Equal("v1", tag.Name); 123Assert.Equal("todos", tag.Name); 127Assert.Equal("v2", tag.Name); 147Assert.Equal(nameof(OpenApiDocumentServiceTests), tag.Name); 151Assert.Equal(nameof(OpenApiDocumentServiceTests), tag.Name); 171Assert.Equal("todos", tag.Name); 175Assert.Equal("v1", tag.Name); 179Assert.Equal("users", tag.Name); 197Assert.Equal("GetTodos", operation.OperationId); 215Assert.Equal("GetTodos", operation.OperationId); 230Assert.Equal("GetTodos", operation.OperationId);

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.Parameters.cs (15)

26Assert.Equal("id", pathParameter.Name); 30Assert.Equal("id", queryParameter.Name); 34Assert.Equal("X-Header", headerParameter.Name); 55Assert.Equal("id", pathParameter.Name); 58Assert.Equal("guid", guidParameter.Name); 61Assert.Equal("isCompleted", isCompletedParameter.Name); 81Assert.Equal("id", queryParameter.Name); 84Assert.Equal("id", nullableQueryParameter.Name); 87Assert.Equal("id", defaultQueryParameter.Name); 107Assert.Equal("X-Header", headerParameter.Name); 110Assert.Equal("X-Header", nullableHeaderParameter.Name); 113Assert.Equal("X-Header", defaultHeaderParameter.Name); 136Assert.Equal("id", pathParameter.Name); 139Assert.Equal("guid", guidParameter.Name); 142Assert.Equal("isCompleted", isCompletedParameter.Name);

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.Paths.cs (6)

26Assert.Equal("/api/todos", path.Key); 35Assert.Equal("/api/users", path.Key); 64Assert.Equal("/api/todos", path.Key); 86Assert.Equal("/api/todos", path.Key); 118Assert.Equal("/api/todos/{id}", path.Key); 157Assert.Equal("/api/todos/{id}", path.Key);

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.RequestBody.cs (107)

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.Responses.cs (48)

Services\OpenApiGeneratorTests.cs (71)

Services\OpenApiSchemaService\OpenApiSchemaService.ParameterSchemas.cs (18)

160[(string id = "test") => { }, (IOpenApiAny defaultValue) => Assert.Equal("test", ((OpenApiString)defaultValue).Value)], 164[(Status status = Status.Pending) => { }, (IOpenApiAny defaultValue) => Assert.Equal("Pending", ((OpenApiString)defaultValue).Value)], 167[([DefaultValue("test")] string id) => { }, (IOpenApiAny defaultValue) => Assert.Equal("test", ((OpenApiString)defaultValue).Value)], 170[([DefaultValue(Status.Pending)] Status status) => { }, (IOpenApiAny defaultValue) => Assert.Equal("Pending", ((OpenApiString)defaultValue).Value)], 174[([DefaultValue("foo")] string? id) => { }, (IOpenApiAny defaultValue) => Assert.Equal("foo", ((OpenApiString)defaultValue).Value)], 240Assert.Equal("Pending", openApiString.Value); 245Assert.Equal("Approved", openApiString.Value); 250Assert.Equal("Rejected", openApiString.Value); 343[([Url] string url) => {}, (OpenApiSchema schema) => { Assert.Equal("string", schema.Type); Assert.Equal("uri", schema.Format); }], 345[([Url][StringLength(10)] string url) => {}, (OpenApiSchema schema) => { Assert.Equal("string", schema.Type); Assert.Equal("uri", schema.Format); Assert.Equal(10, schema.MaxLength); }], 346[([Base64String] string base64string) => {}, (OpenApiSchema schema) => { Assert.Equal("string", schema.Type); Assert.Equal("byte", schema.Format); }], 564Assert.Equal(parameter.Schema.Reference.Id, response.Reference.Id); 570Assert.Equal("Pending", openApiString.Value); 575Assert.Equal("Approved", openApiString.Value); 580Assert.Equal("Rejected", openApiString.Value);

Services\OpenApiSchemaService\OpenApiSchemaService.PolymorphicSchemas.cs (53)

Services\OpenApiSchemaService\OpenApiSchemaService.RequestBodySchemas.cs (103)

Transformers\DocumentTransformerTests.cs (7)

28Assert.Equal("1", document.Info.Description); 35Assert.Equal("2", document.Info.Description); 52Assert.Equal("Info Description", document.Info.Description); 69Assert.Equal("Info Description", document.Info.Description); 94Assert.Equal(description, document.Info.Description); 139Assert.Equal("Info Description", document.Info.Description); 158Assert.Equal("Info Description", document.Info.Description);

Transformers\Implementations\OpenApiSchemaReferenceTransformerTests.cs (32)

Transformers\OperationTransformerTests.cs (46)

Transformers\SchemaTransformerTests.cs (32)

OutputCacheEntryFormatterTests.cs (1)

77Assert.Equal(KnownV2Payload, hex);

OutputCacheKeyProviderTests.cs (19)

OutputCacheMiddlewareTests.cs (8)

119Assert.Equal("NewValue", context.HttpContext.Response.Headers["MyHeader"]); 547Assert.Equal(HeaderUtilities.FormatDate(utcNow), context.HttpContext.Response.Headers.Date); 565Assert.Equal(HeaderUtilities.FormatDate(utcNow), context.HttpContext.Response.Headers.Date); 569Assert.Equal(HeaderUtilities.FormatDate(responseTime), context.HttpContext.Response.Headers.Date); 911Assert.Equal("Hello1", Encoding.UTF8.GetString(memoryStream1.ToArray())); 912Assert.Equal("Hello2", Encoding.UTF8.GetString(memoryStream2.ToArray())); 1036Assert.Equal(initialResponse, cachedResponse); 1038Assert.Equal(refreshedResponse, cachedResponseAfterRefresh);

OutputCachePoliciesTests.cs (4)

51Assert.Equal("*", context.CacheVaryByRules.QueryKeys); 204Assert.Equal(header, context.CacheVaryByRules.HeaderNames); 242Assert.Equal(query, context.CacheVaryByRules.QueryKeys); 281Assert.Equal(value, context.CacheVaryByRules.CacheKeyPrefix);

OutputCachePolicyBuilderTests.cs (6)

211Assert.Equal("tenant1", context1.CacheVaryByRules.CacheKeyPrefix); 212Assert.Equal("tenant2", context2.CacheVaryByRules.CacheKeyPrefix); 213Assert.Equal("tenant3", context3.CacheVaryByRules.CacheKeyPrefix); 231Assert.Equal("circle", context.CacheVaryByRules.VaryByValues["shape"]); 232Assert.Equal("blue", context.CacheVaryByRules.VaryByValues["color"]); 233Assert.Equal("1m", context.CacheVaryByRules.VaryByValues["size"]);

OutputCacheTests.cs (1)

1059Assert.Equal(await initialResponse.Content.ReadAsStringAsync(), await subsequentResponse.Content.ReadAsStringAsync());

OwinEnvironmentTests.cs (20)

36Assert.Equal("SomeMethod", Get<string>(env, "owin.RequestMethod")); 38Assert.Equal("Foo", Get<ClaimsPrincipal>(env, "server.User").Identity.AuthenticationType); 39Assert.Equal("Foo", Get<ClaimsPrincipal>(env, "owin.RequestUser").Identity.AuthenticationType); 43Assert.Equal("CustomRequestValue", requestHeaders["CustomRequestHeader"].First()); 44Assert.Equal("/path", Get<string>(env, "owin.RequestPath")); 45Assert.Equal("/pathBase", Get<string>(env, "owin.RequestPathBase")); 46Assert.Equal("http/1.0", Get<string>(env, "owin.RequestProtocol")); 47Assert.Equal("key=value", Get<string>(env, "owin.RequestQueryString")); 48Assert.Equal("http", Get<string>(env, "owin.RequestScheme")); 53Assert.Equal("CustomResponseValue", responseHeaders["CustomResponseHeader"].First()); 65Assert.Equal("Foo", context.User.Identity.AuthenticationType); 68Assert.Equal("Bar", context.User.Identity.AuthenticationType); 84Assert.Equal("SomeMethod", context.Request.Method); 86Assert.Equal("CustomRequestValue", context.Request.Headers["CustomRequestHeader"]); 87Assert.Equal("/path", context.Request.Path.Value); 88Assert.Equal("/pathBase", context.Request.PathBase.Value); 89Assert.Equal("http/1.0", context.Request.Protocol); 90Assert.Equal("?key=value", context.Request.QueryString.Value); 91Assert.Equal("http", context.Request.Scheme); 94Assert.Equal("CustomResponseValue", context.Response.Headers["CustomResponseHeader"]);

OwinFeatureCollectionTests.cs (8)

35Assert.Equal(requestFeature.Method, HttpMethods.Post); 36Assert.Equal("/path", requestFeature.Path); 37Assert.Equal("/pathBase", requestFeature.PathBase); 38Assert.Equal("?name=value", requestFeature.QueryString); 59Assert.Equal(HttpMethods.Get, Get<string>(env, "owin.RequestMethod")); 60Assert.Equal("/path2", Get<string>(env, "owin.RequestPath")); 61Assert.Equal("/pathBase2", Get<string>(env, "owin.RequestPathBase")); 62Assert.Equal("name=value2", Get<string>(env, "owin.RequestQueryString"));

RateLimiterEndpointConventionBuilderExtensionsTests.cs (1)

31Assert.Equal("TestPolicyName", metadata.PolicyName);

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

RateLimitingMetricsTests.cs (3)

58Assert.Equal("global_limiter", (string)m.Tags["aspnetcore.rate_limiting.result"]); 117Assert.Equal("acquired", (string)m.Tags["aspnetcore.rate_limiting.result"]); 238Assert.Equal("acquired", (string)m.Tags["aspnetcore.rate_limiting.result"]);

RateLimitingMiddlewareTests.cs (1)

162Assert.Equal("The request was canceled.", message.State.ToString());

Runtime\TagHelpers\TagHelperExecutionContextTest.cs (6)

84Assert.Equal(content, executionContext.Output.Content.GetContent()); 130Assert.Equal(updatedTagName, output.TagName); 133Assert.Equal("Another attribute", attribute.Name); 183Assert.Equal(tagName, context.TagName); 184Assert.Equal("Another attribute", attribute.Name); 185Assert.Equal(updatedUniqueId, context.UniqueId);

Runtime\TagHelpers\TagHelperRunnerTest.cs (1)

166Assert.Equal("foo", output.TagName);

Runtime\TagHelpers\TagHelperScopeManagerTest.cs (4)

135Assert.Equal("p", output.TagName); 150Assert.Equal("div", output.TagName); 183Assert.Equal("p", output.TagName); 220Assert.Equal(expectedError, ex.Message);

TagHelpers\DefaultTagHelperContentTest.cs (36)

TagHelpers\NullHtmlEncoderTest.cs (4)

34Assert.Equal(value, result); 55Assert.Equal(value, result); 92Assert.Equal(expectedResult, result); 130Assert.Equal(expectedResult, result);

TagHelpers\TagHelperContextTest.cs (3)

37Assert.Equal(tagName, context.TagName); 39Assert.Equal(expectedUniqueId, context.UniqueId); 60Assert.Equal("test", context.TagName);

TagHelpers\TagHelperOutputTest.cs (12)

46Assert.Equal(expectedTagName, output.TagName); 55Assert.Equal(expectedGetChildContentContent, content); 219Assert.Equal( 237Assert.Equal( 278Assert.Equal( 296Assert.Equal( 314Assert.Equal( 1081Assert.Equal(string.Empty, output.PreElement.GetContent()); 1082Assert.Equal(string.Empty, output.PreContent.GetContent()); 1083Assert.Equal(string.Empty, output.Content.GetContent()); 1084Assert.Equal(string.Empty, output.PostContent.GetContent()); 1085Assert.Equal(string.Empty, output.PostElement.GetContent());

DefaultRequestDecompressionProviderTests.cs (2)

100Assert.Equal(contentEncoding, contentEncodingHeader); 174Assert.Equal(message, log.State.ToString());

RequestDecompressionMiddlewareTests.cs (4)

329Assert.Equal(contentEncoding, contentEncodingHeader); 503Assert.Equal("The maximum number of bytes have been read.", exception.Message); 587Assert.Equal("The maximum number of bytes have been read.", exception.Message); 663Assert.Equal(message, log.State.ToString());

SizeLimitedStreamTests.cs (1)

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

ResponseCachingKeyProviderTests.cs (12)

25Assert.Equal($"HEAD{KeyDelimiter}HTTPS{KeyDelimiter}EXAMPLE.COM:80/PATHBASE/PATH/SUBPATH", cacheKeyProvider.CreateBaseKey(context)); 39Assert.Equal($"{HttpMethods.Get}{KeyDelimiter}{KeyDelimiter}/PATH", cacheKeyProvider.CreateBaseKey(context)); 53Assert.Equal($"{HttpMethods.Get}{KeyDelimiter}{KeyDelimiter}/Path", cacheKeyProvider.CreateBaseKey(context)); 75Assert.Equal($"{context.CachedVaryByRules.VaryByKeyPrefix}", cacheKeyProvider.CreateStorageVaryByKey(context)); 90Assert.Equal($"{context.CachedVaryByRules.VaryByKeyPrefix}{KeyDelimiter}H{KeyDelimiter}HeaderA=ValueA{KeyDelimiter}HeaderC=", 106Assert.Equal($"{context.CachedVaryByRules.VaryByKeyPrefix}{KeyDelimiter}H{KeyDelimiter}HeaderA=ValueAValueB{KeyDelimiter}HeaderC=", 122Assert.Equal($"{context.CachedVaryByRules.VaryByKeyPrefix}{KeyDelimiter}Q{KeyDelimiter}QueryA=ValueA{KeyDelimiter}QueryC=", 138Assert.Equal($"{context.CachedVaryByRules.VaryByKeyPrefix}{KeyDelimiter}Q{KeyDelimiter}QueryA=ValueA{KeyDelimiter}QueryC=", 156Assert.Equal($"{context.CachedVaryByRules.VaryByKeyPrefix}{KeyDelimiter}Q{KeyDelimiter}QUERYA=ValueA{KeyDelimiter}QUERYB=ValueB", 174Assert.Equal($"{context.CachedVaryByRules.VaryByKeyPrefix}{KeyDelimiter}Q{KeyDelimiter}QUERYA=ValueA{KeySubDelimiter}ValueB", 192Assert.Equal($"{context.CachedVaryByRules.VaryByKeyPrefix}{KeyDelimiter}Q{KeyDelimiter}QUERYA=ValueA{KeySubDelimiter}ValueB", 211Assert.Equal($"{context.CachedVaryByRules.VaryByKeyPrefix}{KeyDelimiter}H{KeyDelimiter}HeaderA=ValueA{KeyDelimiter}HeaderC={KeyDelimiter}Q{KeyDelimiter}QueryA=ValueA{KeyDelimiter}QueryC=",

ResponseCachingTests.cs (1)

963Assert.Equal(await initialResponse.Content.ReadAsStringAsync(), await subsequentResponse.Content.ReadAsStringAsync());

ResponseCompressionBodyTest.cs (1)

25Assert.Equal(expectedVaryHeader, httpContext.Response.Headers.Vary);

ResponseCompressionMiddlewareTest.cs (2)

1006Assert.Equal("MD5", md5.SingleOrDefault()); 1333Assert.Equal(message, log.State.ToString());

ApacheModRewrite\ConditionPatternParserTest.cs (1)

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

ApacheModRewrite\CookieActionFactoryTest.cs (17)

15Assert.Equal("NAME", cookie.Name); 16Assert.Equal("VALUE", cookie.Value); 17Assert.Equal("DOMAIN", cookie.Domain); 19Assert.Equal("path", cookie.Path); 29Assert.Equal("NAME", action.Name); 30Assert.Equal("VALUE:WithColon", action.Value); 31Assert.Equal("DOMAIN", action.Domain); 33Assert.Equal("path", action.Path); 43Assert.Equal("NAME", action.Name); 44Assert.Equal("VALUE", action.Value); 45Assert.Equal("DOMAIN", action.Domain); 47Assert.Equal(string.Empty, action.Path); 62Assert.Equal("NAME", action.Name); 64Assert.Equal(value, action.Value); 65Assert.Equal(domain, action.Domain); 77Assert.Equal(Resources.FormatError_InvalidChangeCookieFlag(flagValue), ex.Message); 88Assert.Equal(Resources.FormatError_CouldNotParseInteger(badInt), ex.Message);

ApacheModRewrite\FlagParserTest.cs (2)

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

ApacheModRewrite\FormatExceptionTests.cs (1)

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

ApacheModRewrite\ModRewriteMiddlewareTest.cs (17)

37Assert.Equal("/hello", response); 63Assert.Equal("/hello", response); 89Assert.Equal("/what", response); 114Assert.Equal("/hey/hello", response); 139Assert.Equal("/homepage.html", response); 164Assert.Equal("/homepage.html", response); 189Assert.Equal("/", response); 216Assert.Equal(expected, response); 247Assert.Equal(expected, response); 273Assert.Equal(@"/blog/2016-jun/", response); 299Assert.Equal(@"http://www.example.com/blog/2016-jun/", response); 325Assert.Equal(@"http://www.example.com/blog/2016-jun/", response); 353Assert.Equal(@"https://www.example.com/foo/", response.Headers.Location.AbsoluteUri); 381Assert.Equal("/", response.Headers.Location.OriginalString); 407Assert.Equal("/", response); 435Assert.Equal("/foo", response.Headers.Location.OriginalString); 464Assert.Equal("http://localhost:80/home/report/123", response.Headers.Location.OriginalString);

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

27Assert.Equal("(.*)", results.Operand);

ApacheModRewrite\TestStringParserTests.cs (1)

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

IISUrlRewrite\FileParserTests.cs (1)

205Assert.Equal(r1.Name, r2.Name);

IISUrlRewrite\FormatExceptionHandlingTests.cs (1)

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

IISUrlRewrite\InputParserTests.cs (6)

50Assert.Equal(expected, result); 63Assert.Equal(expected, result); 73Assert.Equal(expected, result); 82Assert.Equal(expected, result); 101Assert.Equal(expected, result); 156Assert.Equal(expectedValue, result);

IISUrlRewrite\InvalidUrlRewriteFormatExceptionHandlingTests.cs (1)

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

IISUrlRewrite\MiddleWareTests.cs (21)

IISUrlRewrite\ServerVariableTests.cs (4)

37Assert.Equal(expected, lookup); 85Assert.Equal(expected, lookup); 132Assert.Equal(expected, lookup); 180Assert.Equal(string.Empty, lookup);

MiddlewareTests.cs (33)

PatternSegments\ConditionMatchSegmentTests.cs (1)

26Assert.Equal(expected, results);

PatternSegments\DateTimeSegmentTests.cs (1)

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

PatternSegments\IsHttpsModSegmentTests.cs (1)

25Assert.Equal(expected, results);

PatternSegments\IsHttpsSegmentTests.cs (1)

25Assert.Equal(expected, results);

PatternSegments\IsIPV6SegmentTests.cs (3)

24Assert.Equal("off", results); 39Assert.Equal("on", results); 54Assert.Equal("off", results);

PatternSegments\LIteralSegmentTests.cs (1)

20Assert.Equal("foo", results);

PatternSegments\LocalAddressSegmentTests.cs (1)

23Assert.Equal("20.30.40.50", results);

PatternSegments\LocalPortSegmentTests.cs (1)

22Assert.Equal("800", results);

PatternSegments\QueryStringSegmentTests.cs (1)

20Assert.Equal("hey=1", results);

PatternSegments\RemoteAddressSegmentTests.cs (1)

23Assert.Equal("20.30.40.50", results);

PatternSegments\RemotePortSegmentTests.cs (1)

22Assert.Equal("800", results);

PatternSegments\RequestFilenameSegmentTests.cs (1)

22Assert.Equal("/foo/bar", results);

PatternSegments\RequestMethodSegmentTests.cs (1)

22Assert.Equal(HttpMethods.Get, results);

PatternSegments\RuleMatchSegmentTests.cs (1)

25Assert.Equal(expected, results);

PatternSegments\SchemeSegmentTests.cs (1)

22Assert.Equal("http", results);

PatternSegments\ServerNameSegmentTests.cs (1)

32Assert.Equal(expectedResult, results);

PatternSegments\ServerProtocolSegmentTests.cs (1)

24Assert.Equal("http", results);

PatternSegments\ToLowerSegmentTests.cs (1)

26Assert.Equal(expected, results);

PatternSegments\UrlDecodeSegmentTests.cs (1)

26Assert.Equal(expected, results);

PatternSegments\UrlEncodeSegmentTests.cs (1)

26Assert.Equal(expected, results);

PatternSegments\UrlSegmentTests.cs (1)

41Assert.Equal(expectedResult, results);

UrlActions\ChangeCookieActionTests.cs (3)

31Assert.Equal($"Cookie=Chocolate%20Chip; expires={HeaderUtilities.FormatDate(now.AddMinutes(1440))}; domain=contoso.com; path=/recipes; secure; httponly", header); 47Assert.Equal($"Cookie=Chocolate%20Chip", header); 60Assert.Equal($"Cookie=", header);

UrlMatches\IntegerMatchTests.cs (1)

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

Benchmarks\EndpointRoutingBenchmarkTest.cs (3)

30Assert.Equal(nameof(Benchmarks.StartupUsingEndpointRouting), startupName); 52Assert.Equal(expectedContentType, response.Content.Headers.ContentType.MediaType); 54Assert.Equal(expectedContent, actualContent);

Benchmarks\RouterBenchmarkTest.cs (3)

31Assert.Equal(nameof(Benchmarks.StartupUsingRouter), startupName); 53Assert.Equal(expectedContentType, response.Content.Headers.ContentType.MediaType); 55Assert.Equal(expectedContent, actualContent);

EndpointRoutingIntegrationTest.cs (4)

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

EndpointRoutingSampleTest.cs (13)

HostMatchingTests.cs (5)

41Assert.Equal("*:*", responseContent); 59Assert.Equal("*.0.0.1:*", responseContent); 77Assert.Equal("127.0.0.1:*", responseContent); 95Assert.Equal("*.0.0.1:5000,*.0.0.1:5001", responseContent); 113Assert.Equal("contoso.com:*,*.contoso.com:*", responseContent);

MapFallbackTest.cs (3)

33Assert.Equal("Hello World", responseContent); 67Assert.Equal("FallbackCustomPattern", responseContent); 101Assert.Equal("FallbackDefaultPattern", responseContent);

MinimalFormTests.cs (9)

69Assert.Equal("Test task", result.Name); 129Assert.Equal("Test task", result.Name); 210Assert.Equal( 245Assert.Equal( 290Assert.Equal("Test task", result.Name); 337Assert.Equal("Test task", result.Name); 430Assert.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); 489Assert.Equal("The maximum number of bytes have been read.", exception.Message); 497Assert.Equal("Test task", result.Name);

RouteHandlerTest.cs (1)

58Assert.Equal(todo.Name, echoedTodo?.Name);

RouterSampleTest.cs (4)

41Assert.Equal($"{branch} - API Get 5", await response.Content.ReadAsStringAsync()); 55Assert.Equal($"API Get 5", await response.Content.ReadAsStringAsync()); 69Assert.Equal($"Middleware!", await response.Content.ReadAsStringAsync()); 93Assert.Equal(expectedBody, body);

WebHostBuilderExtensionsTest.cs (1)

102Assert.Equal(expected, actual);

Builder\EndpointRoutingApplicationBuilderExtensionsTest.cs (21)

Builder\GroupTest.cs (25)

40Assert.Equal("GET", method); 42Assert.Equal("HTTP: GET /{id}", endpoint.DisplayName); 43Assert.Equal("/{id}", routeEndpoint.RoutePattern.RawText); 72Assert.Equal("GET", method); 74Assert.Equal("HTTP: GET /{org}/{id}", endpoint.DisplayName); 75Assert.Equal("/{org}/{id}", routeEndpoint.RoutePattern.RawText); 106Assert.Equal("GET", method); 108Assert.Equal("HTTP: GET /{org}/{id}/", endpoint.DisplayName); 109Assert.Equal("/{org}/{id}/", routeEndpoint.RoutePattern.RawText); 129Assert.Equal("/{ID}/{id}", ex.Pattern); 130Assert.Equal("The route parameter name 'id' appears more than one time in the route template.", ex.Message); 139Assert.Equal("prefix", ex.ParamName); 141Assert.Equal("prefix", ex.ParamName); 146Assert.Equal("endpoints", ex.ParamName); 148Assert.Equal("endpoints", ex.ParamName); 175Assert.Equal("/outer/inner/foo", outerPattern?.RawText); 176Assert.Equal("/outer/inner/foo", innerPattern?.RawText); 253Assert.Equal("/bar", routeEndpoint.RoutePattern.RawText); 294Assert.Equal("Prefixed! HTTP: GET /group/", endpoint.DisplayName); 310Assert.Equal( 349Assert.Equal("/group/foo", routeEndpoint.RoutePattern.RawText); 351Assert.Equal("/group", routeEndpoint.Metadata.GetMetadata<string>()); 355Assert.Equal("/group/bar", routeEndpoint.RoutePattern.RawText); 357Assert.Equal("/group", routeEndpoint.Metadata.GetMetadata<string>()); 383Assert.Equal("/group/foo", prefixedEndpoint.RoutePattern.RawText);

Builder\OpenApiRouteHandlerBuilderExtensionsTest.cs (9)

35tag => Assert.Equal("a", tag), 36tag => Assert.Equal("b", tag), 37tag => Assert.Equal("c", tag)); 54Assert.Equal("application/json", Assert.Single(metadata.ContentTypes)); 82Assert.Equal("application/problem+json", Assert.Single(metadata.ContentTypes)); 100Assert.Equal("application/problem+json", Assert.Single(metadata.ContentTypes)); 117Assert.Equal("text/plain", Assert.Single(metadata.ContentTypes)); 128Assert.Equal("test description", metadata.Description); 138Assert.Equal("test summary", metadata.Summary);

Builder\RequestDelegateEndpointRouteBuilderExtensionsTest.cs (16)

74Assert.Equal("/", endpointBuilder1.DisplayName); 75Assert.Equal("/", endpointBuilder1.RoutePattern.RawText); 107Assert.Equal("Response string text", responseBody); 143Assert.Equal("filtered!", responseBody); 171Assert.Equal("filtered!", responseBody); 286Assert.Equal(@"{""name"":""你好""}", responseBody); 361Assert.Equal("/", endpointBuilder1.DisplayName); 362Assert.Equal("/", endpointBuilder1.RoutePattern.RawText); 376Assert.Equal("/", endpointBuilder1.RoutePattern.RawText); 395Assert.Equal("/", endpointBuilder1.RoutePattern.RawText); 415Assert.Equal("METHOD", GetMethod(endpoint.Metadata[0])); 416Assert.Equal("ATTRIBUTE", GetMethod(endpoint.Metadata[1])); 417Assert.Equal("BUILDER", GetMethod(endpoint.Metadata[2])); 420Assert.Equal("BUILDER", endpoint.Metadata.GetMetadata<IHttpMethodMetadata>()?.HttpMethods.Single()); 502m => Assert.Equal("System.Runtime.CompilerServices.NullableContextAttribute", m.ToString()), 521Assert.Equal("/", endpointBuilder1.RoutePattern.RawText);

Builder\RouteHandlerEndpointRouteBuilderExtensionsTest.cs (73)

Builder\RoutingBuilderExtensionsTest.cs (3)

28Assert.Equal( 45Assert.Equal( 62Assert.Equal(

Builder\RoutingEndpointConventionBuilderExtensionsTest.cs (7)

29Assert.Equal("contoso.com:8080", hostMetadata.Hosts.Single()); 73Assert.Equal("test", endpoint.DisplayName); 100Assert.Equal("test", endpoint.DisplayName); 120Assert.Equal("test", @string); 150Assert.Equal(name, endpointName.EndpointName); 153Assert.Equal(name, routeName.RouteName); 169Assert.Equal("SomeEndpointGroupName", endpointGroupName.EndpointGroupName);

CompositeEndpointDataSourceTest.cs (11)

310Assert.Equal("/prefix/a", resolvedEndpoint.RoutePattern.RawText); 359Assert.Equal("/prefix/a", endpoint.RoutePattern.RawText); 361Assert.Equal("initial-metadata", endpoint.Metadata.GetMetadata<string>()); 366Assert.Equal("/prefix/b", endpoint.RoutePattern.RawText); 368Assert.Equal("initial-metadata", endpoint.Metadata.GetMetadata<string>()); 414Assert.Equal("/prefix/a", endpoint.RoutePattern.RawText); 416Assert.Equal("initial-metadata", endpoint.Metadata.GetMetadata<string>()); 421Assert.Equal("/prefix/b", endpoint.RoutePattern.RawText); 423Assert.Equal("initial-metadata", endpoint.Metadata.GetMetadata<string>()); 480Assert.Equal("/prefix/a", endpoint.RoutePattern.RawText); 487Assert.Equal("/prefix/b", endpoint.RoutePattern.RawText);

ConstraintMatcherTest.cs (2)

62Assert.Equal(expectedMessage, write.State?.ToString()); 230Assert.Equal(_expectedKey, routeKey);

DefaultEndpointDataSourceTests.cs (6)

21endpoint => Assert.Equal("1", endpoint.DisplayName), 22endpoint => Assert.Equal("2", endpoint.DisplayName)); 50Assert.Equal("endpoints", actual.ParamName); 65endpoint => Assert.Equal("1", endpoint.DisplayName), 66endpoint => Assert.Equal("2", endpoint.DisplayName)); 94Assert.Equal("endpoints", actual.ParamName);

DefaultInlineConstraintResolverTest.cs (5)

51Assert.Equal("Could not find a constructor for constraint type 'IntRouteConstraint'" + 292Assert.Equal("System.String must implement Microsoft.AspNetCore.Routing.IParameterPolicy", ex.Message); 320Assert.Equal("The constraint type 'System.String' which is mapped to constraint key 'custom'" + 335Assert.Equal("The constructor to use for activating the constraint type 'MultiConstructorRouteConstraint' is ambiguous." + 361Assert.Equal("Could not find a constructor for constraint type 'IntRouteConstraint'" +

DefaultLinkGeneratorProcessTemplateTest.cs (95)

DefaultLinkGeneratorTest.cs (24)

90Assert.Equal("/Home/Index", path); 106Assert.Equal("/Home/Index", path); 126Assert.Equal("http://example.com/Home/Index", path); 146Assert.Equal("http://example.com/Home/Index", uri); 165Assert.Equal("/Home/Index/", path); 191Assert.Equal("/test-controller/Index", path); 218Assert.Equal("/test-controller/index", path); 238Assert.Equal("/Home/Index/", path); 259Assert.Equal("http://example.com/Home/Index/", path); 283Assert.Equal("http://example.com/Home/Index/", uri); 304Assert.Equal("/Foo/Bar%3Fencodeme%3F/Home/In%3Fdex?query=some%3Fquery#Fragment?", path); 327Assert.Equal("/HOME/Test", link); 353Assert.Equal("/HOME/Test?c=HITHERE", link); 377Assert.Equal("/Foo/Bar%3Fencodeme%3F/Home/In%3Fdex?query=some%3Fquery#Fragment?", path); 400Assert.Equal("http://example.com/Foo/Bar%3Fencodeme%3F/Home/In%3Fdex?query=some%3Fquery#Fragment?", path); 426Assert.Equal("http://example.com/Foo/Bar%3Fencodeme%3F/Home/In%3Fdex?query=some%3Fquery#Fragment?", uri); 450Assert.Equal("/Home/Index", uri); 474Assert.Equal("http://example.com/Home/Index", uri); 497Assert.Equal("/Home/Index", uri); 524Assert.Equal("ftp://example.com:5000/Home/Index", uri); 548Assert.Equal("/Home/Index", uri); 649Assert.Equal(expectedPath, generatedPath); 688Assert.Equal(expectedPath, generatedPath); 726Assert.Equal(expectedPath, generatedPath);

DefaultLinkParserTest.cs (5)

37w => Assert.Equal("No endpoints found for address 0", w.Message)); 59w => Assert.Equal("Found the endpoints Test2 for address 0", w.Message), 60w => Assert.Equal("Path parsing failed for endpoints Test2 and URI path /", w.Message)); 83w => Assert.Equal("Found the endpoints Test1, Test2, Test3 for address 0", w.Message), 84w => Assert.Equal("Path parsing succeeded for endpoint Test2 and URI path /Home/Index/17", w.Message));

DefaultParameterPolicyFactoryTest.cs (5)

25Assert.Equal( 47Assert.Equal( 335Assert.Equal($"The constructor to use for activating the constraint type '{nameof(CustomParameterPolicyWithAmbiguousMultipleCtors)}' is ambiguous. " 357Assert.Equal("\\\\d{1,2}", constraint.Constraint.ToString()); 377Assert.Equal($"No service for type '{typeof(ITestService).FullName}' has been registered.", inner.Message);

EndpointNameAddressSchemeTest.cs (1)

173Assert.Equal(String.Join(Environment.NewLine, @"The following endpoints with a duplicate endpoint name were found.",

EndpointRoutingMiddlewareTest.cs (12)

55Assert.Equal("myapp", endpoint.DisplayName); 73Assert.Equal("Microsoft.AspNetCore.Routing.EndpointMatched", pair.Key); 88Assert.Equal(expectedMessage, write.State?.ToString()); 107Assert.Equal("Home", (string)routeValue); 130Assert.Equal("Home", (string)routeValue); 260Assert.Equal("Matched endpoint 'myapp' is a fallback endpoint.", write.Message); 294Assert.Equal($"A request body size limit could not be applied. The {nameof(IHttpMaxRequestBodySizeFeature)} for the server is read-only.", write.Message); 323Assert.Equal($"A request body size limit could not be applied. This server does not support the {nameof(IHttpMaxRequestBodySizeFeature)}.", write.Message); 351Assert.Equal($"The endpoint does not specify the {nameof(IRequestSizeLimitMetadata)}.", write.Message); 385Assert.Equal("The maximum request body size has been disabled.", write.Message); 390Assert.Equal($"The maximum request body size has been set to {expectedRequestSizeLimit}.", write.Message); 451Assert.Equal(message, log.State.ToString());

InlineRouteParameterParserTests.cs (129)

Internal\DfaGraphWriterTest.cs (3)

33Assert.Equal(String.Join(Environment.NewLine, @"digraph DFA {", 56Assert.Equal(String.Join(Environment.NewLine, @"digraph DFA {", 80Assert.Equal(String.Join(Environment.NewLine, @"digraph DFA {",

LinkGeneratorEndpointNameExtensionsTest.cs (4)

64Assert.Equal("/Foo/Bar%3Fencodeme%3F/some%23-other-endpoint/In%3Fdex/?query=some%3Fquery#Fragment?", path); 90Assert.Equal("/Foo/Bar%3Fencodeme%3F/some%23-other-endpoint/In%3Fdex/?query=some%3Fquery#Fragment?", path); 115Assert.Equal("http://example.com/Foo/Bar%3Fencodeme%3F/some%23-other-endpoint/In%3Fdex/?query=some%3Fquery#Fragment?", path); 143Assert.Equal("http://example.com/Foo/Bar%3Fencodeme%3F/some%23-other-endpoint/In%3Fdex/?query=some%3Fquery#Fragment?", uri);

LinkGeneratorIntegrationTest.cs (23)

230Assert.Equal("/api/Pets/17", path); 251Assert.Equal("/", path); 272Assert.Equal("/Admin/Users/Add", path); 293Assert.Equal("/api/Store/17", path); 314Assert.Equal("/Pages", path); 335Assert.Equal("/Admin/Pages", path); 356Assert.Equal("/Home/Fake/17", path); 381Assert.Equal("/api/Pets/17", path); 402Assert.Equal("/Pets/GetById", path); 423Assert.Equal("/Pets/GetById", path); 444Assert.Equal("/Home/Index/17", path); 465Assert.Equal("/", path); 486Assert.Equal("/", path); 507Assert.Equal("/Home/Index11", path); 528Assert.Equal("/Admin/Home/Index11", path); 549Assert.Equal("/api/Store", path); 570Assert.Equal("/api/Store/17", path); 591Assert.Equal("/api/Foo/17", path); 612Assert.Equal("/Pages/Help/17", path); 633Assert.Equal("/Pages/Help", path); 654Assert.Equal("/Pages/Help", path); 675Assert.Equal("/Pets/Update?page=%2FPages%2FHelp2", path); 696Assert.Equal("/Admin/Pages", path);

LinkGeneratorRouteValuesAddressExtensionsTest.cs (6)

45Assert.Equal("/Foo/Bar%3Fencodeme%3F/Home/Index/?query=some%3Fquery#Fragment?", path); 72Assert.Equal("/Foo/Bar%3Fencodeme%3F/Home/Index/?query=some%3Fquery#Fragment?", path); 102Assert.Equal("/Foo/Bar%3Fencodeme%3F/Home/Index/?query=some%3Fquery#Fragment?", path); 131Assert.Equal("http://example.com/Foo/Bar%3Fencodeme%3F/Home/Index/?query=some%3Fquery#Fragment?", path); 163Assert.Equal("http://example.com/Foo/Bar%3Fencodeme%3F/Home/Index/?query=some%3Fquery#Fragment?", uri); 195Assert.Equal("http://example.com/Foo/Bar%3Fencodeme%3F/Home/Index/?query=some%3Fquery#Fragment?", uri);

Matching\AcceptsMatcherPolicyTest.cs (1)

245Assert.Equal(AcceptsMatcherPolicy.Http415EndpointDisplayName, Assert.Single(e.Endpoints).DisplayName);

Matching\CandidateSetTest.cs (1)

324Assert.Equal(@"Using ExpandEndpoint requires that the replaced endpoint have a unique priority. The following endpoints were found with the same priority:" +

Matching\ContentEncodingNegotiationMatcherPolicyTest.cs (16)

361e => Assert.Equal("gzip", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue), 362e => Assert.Equal("br", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue), 365Assert.Equal("identity", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue); 367Assert.Equal("406 HTTP Unsupported Encoding", endpoint.DisplayName); 371Assert.Equal("", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue); 373Assert.Equal("406 HTTP Unsupported Encoding", endpoint.DisplayName); 396Assert.Equal("gzip", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue); 398e => Assert.Equal("Endpoint -> gzip: 1", e.DisplayName), 399e => Assert.Equal("Identity", e.DisplayName)); 403Assert.Equal("br", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue); 405e => Assert.Equal("Endpoint -> br: 1", e.DisplayName), 406e => Assert.Equal("Identity", e.DisplayName)); 410Assert.Equal("identity", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue); 412Assert.Equal("Identity", endpoint.DisplayName); 416Assert.Equal("", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue); 418Assert.Equal("Identity", endpoint.DisplayName);

Matching\DataSourceDependentMatcherTest.cs (3)

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

Matching\DfaMatcherTest.cs (22)

Matching\HostMatcherPolicyTest.cs (7)

223Assert.Equal("*:*", e.State.ToString()); 228Assert.Equal("*:5000", e.State.ToString()); 233Assert.Equal("*:5001", e.State.ToString()); 238Assert.Equal("*.contoso.com:*", e.State.ToString()); 243Assert.Equal("*.sub.contoso.com:*", e.State.ToString()); 248Assert.Equal("www.contoso.com:*", e.State.ToString()); 253Assert.Equal("www.contoso.com:5000", e.State.ToString());

Matching\HttpMethodMatcherPolicyIntegrationTestBase.cs (3)

204Assert.Equal("DELETE, GET, PUT", httpContext.Response.Headers["Allow"]); 314Assert.Equal("DELETE, GET, PUT", httpContext.Response.Headers["Allow"]); 319Assert.Equal("DELETE, GET, PUT", httpContext.Response.Headers["Allow"]);

Matching\HttpMethodMatcherPolicyTest.cs (2)

310Assert.Equal(Http405EndpointDisplayName, e.Endpoints.Single().DisplayName); 354Assert.Equal(Http405EndpointDisplayName, e.Endpoints.Single().DisplayName);

MetadataTest.cs (7)

22Assert.Equal("DataTokens: key1=1,key2=2", value); 35Assert.Equal("EndpointName: Name", value); 48Assert.Equal("Hosts: Host1:*,Host2:80", value); 61Assert.Equal("HttpMethods: GET,POST, Cors: True", value); 74Assert.Equal("RouteName: RouteName", value); 87Assert.Equal("SuppressLinkGeneration: True", value); 100Assert.Equal("SuppressMatching: True", value);

Patterns\InlineRouteParameterParserTest.cs (145)

Patterns\RoutePatternFactoryTest.cs (60)

36kvp => { Assert.Equal("a", kvp.Key); Assert.Equal("15", kvp.Value); }, 37kvp => { Assert.Equal("b", kvp.Key); Assert.Equal(17, kvp.Value); }, 38kvp => { Assert.Equal("c", kvp.Key); Assert.Equal("19", kvp.Value); }); 61kvp => { Assert.Equal("d", kvp.Key); Assert.Equal("15", kvp.Value); }, 62kvp => { Assert.Equal("e", kvp.Key); Assert.Equal(17, kvp.Value); }); 83Assert.Equal( 110kvp => { Assert.Equal("a", kvp.Key); Assert.Equal("13", kvp.Value); }); 131Assert.Equal( 157c => Assert.Equal("int", c.Content)); 166Assert.Equal("a", kvp.Key); 170c => Assert.Equal("int", c.Content)); 174Assert.Equal("b", kvp.Key); 203Assert.Equal("d", kvp.Key); 210Assert.Equal("e", kvp.Key); 239Assert.Equal("d", kvp.Key); 242c => Assert.Equal("foo", Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy).Constraint.ToString()), 243c => Assert.Equal("bar", Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy).Constraint.ToString()), 244c => Assert.Equal("^(baz)$", Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy).Constraint.ToString())); 270Assert.Equal("a", kvp.Key); 273c => Assert.Equal("int", c.Content)); 277Assert.Equal("b", kvp.Key); 280c => Assert.Equal("^(fizz)$", Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy).Constraint.ToString())); 284Assert.Equal("c", kvp.Key); 287c => Assert.Equal("foo", Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy).Constraint.ToString()), 288c => Assert.Equal("bar", Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy).Constraint.ToString()), 289c => Assert.Equal("^(baz)$", Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy).Constraint.ToString()), 290c => Assert.Equal("int", c.Content)); 337Assert.Equal("d", kvp.Key); 344Assert.Equal("e", kvp.Key); 373Assert.Equal("d", kvp.Key); 375Assert.Equal("^(foo)$", regex.Constraint.ToString()); 397Assert.Equal( 484Assert.Equal(paramPartB.Name, actual.Parameters[0].Name); 488Assert.Equal(paramPartC.Name, actual.Parameters[1].Name); 492Assert.Equal(paramPartD.Name, actual.Parameters[2].Name); 524Assert.Equal(paramPartB.Name, actual.Parameters[0].Name); 528Assert.Equal(paramPartC.Name, actual.Parameters[1].Name); 532Assert.Equal(paramPartD.Name, actual.Parameters[2].Name); 553kvp => { Assert.Equal("action", kvp.Key); Assert.Equal("Index", kvp.Value); }, 554kvp => { Assert.Equal("area", kvp.Key); Assert.Equal("Admin", kvp.Value); }, 555kvp => { Assert.Equal("controller", kvp.Key); Assert.Equal("Store", kvp.Value); }); 573kvp => { Assert.Equal("action", kvp.Key); Assert.Equal("Index", kvp.Value); }, 574kvp => { Assert.Equal("area", kvp.Key); Assert.Null(kvp.Value); }, 575kvp => { Assert.Equal("controller", kvp.Key); Assert.Equal("Store", kvp.Value); }); 593kvp => { Assert.Equal("action", kvp.Key); Assert.Equal("Index", kvp.Value); }, 594kvp => { Assert.Equal("area", kvp.Key); Assert.Equal("", kvp.Value); }, 595kvp => { Assert.Equal("controller", kvp.Key); Assert.Equal("Store", kvp.Value); }); 614Assert.Equal( 742Assert.Equal(literal, part.Content); 746Assert.Equal("/a/b/", combined.RawText); 759Assert.Equal("/{id}/{ID}", ex.Pattern); 760Assert.Equal("The route parameter name 'ID' appears more than one time in the route template.", ex.Message); 772Assert.Equal("/a/{x=foo}/b", combined.RawText); 775Assert.Equal("x", key); 789Assert.Equal("/a/b", combined.RawText); 792Assert.Equal("x", key); 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);

Patterns\RoutePatternParserTest.cs (1)

600Assert.Equal(routePattern, pattern.RawText);

RouteBuilderTest.cs (1)

45Assert.Equal(

RouteCollectionTest.cs (12)

RouteConstraintBuilderTest.cs (6)

27Assert.Equal("controller", result.First().Key); 48Assert.Equal("controller", kvp.Key); 67Assert.Equal("controller", kvp.Key); 111Assert.Equal("id", result.First().Key); 124Assert.Equal("id", result.First().Key); 139Assert.Equal("name", result.First().Key);

RouteEndpointBuilderTest.cs (5)

24Assert.Equal("routePattern", ex.ParamName); 41Assert.Equal("Display name!", endpoint.DisplayName); 44Assert.Equal("/", endpoint.RoutePattern.RawText); 63Assert.Equal("/", endpoint.RoutePattern.RawText); 68Assert.Equal("Test", metadata.Route);

RouteOptionsTests.cs (1)

25Assert.Equal("TestRouteConstraint", accessor.Value.ConstraintMap["foo"].Name);

RouterMiddlewareTest.cs (1)

93Assert.Equal(expectedMessage, write.State?.ToString());

RouteTest.cs (42)

RoutingMetricsTests.cs (7)

44Assert.Equal(RoutingMetrics.MeterName, meter.Name); 78Assert.Equal(RoutingMetrics.MeterName, meter.Name); 105Assert.Equal(RoutingMetrics.MeterName, meter.Name); 129Assert.Equal(RoutingMetrics.MeterName, meter.Name); 139Assert.Equal("failure", (string)measurement.Tags["aspnetcore.routing.match_status"]); 145Assert.Equal("success", (string)measurement.Tags["aspnetcore.routing.match_status"]); 146Assert.Equal(route, (string)measurement.Tags["http.route"]);

RoutingServiceCollectionExtensionsTests.cs (3)

25Assert.Equal("services", (ex as ArgumentNullException).ParamName); 39Assert.Equal("configureOptions", (ex as ArgumentNullException).ParamName); 51Assert.Equal("services", (ex as ArgumentNullException).ParamName);

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

Template\TemplateBinderTests.cs (13)

Template\TemplateParserTests.cs (1)

767Assert.Equal(routeTemplate, pattern.TemplateText);

Template\TemplateSegmentTest.cs (5)

16Assert.Equal(nameof(other), actual.ParamName); 38Assert.Equal(paramPartC.Name, ((RoutePatternParameterPart)routePatternPathSegment.Parts[0]).Name); 40Assert.Equal(literalPartA.Content, ((RoutePatternLiteralPart)routePatternPathSegment.Parts[1]).Content); 42Assert.Equal(separatorPartE.Content, ((RoutePatternSeparatorPart)routePatternPathSegment.Parts[2]).Content); 44Assert.Equal(paramPartB.Name, ((RoutePatternParameterPart)routePatternPathSegment.Parts[3]).Name);

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

Tree\LinkGenerationDecisionTreeTest.cs (1)

738Assert.Equal(expected, flattenedTree);

Tree\TreeRouteBuilderTest.cs (11)

90Assert.Equal("a", firstSegment.Key); 97Assert.Equal("c", thirdSegment.Key); 122Assert.Equal("a", firstSegment.Key); 129Assert.Equal("c", thirdSegment.Key); 137Assert.Equal("e", fifthSegment.Key); 166Assert.Equal("a", firstSegment.Key); 173Assert.Equal("c", thirdSegment.Key); 198Assert.Equal("a", firstSegment.Key); 205Assert.Equal("c", thirdSegment.Key); 230Assert.Equal("a", firstSegment.Key); 237Assert.Equal("c", thirdSegment.Key);

Tree\TreeRouterTest.cs (32)

UriBuildingContextTest.cs (4)

23Assert.Equal(expected, uriBuilldingContext.ToString()); 39Assert.Equal(expected, uriBuilldingContext.ToString()); 65Assert.Equal(expected, uriBuilldingContext.ToString()); 96Assert.Equal(expected, uriBuilldingContext.ToPathString().Value);

AuthenticationTests.cs (1)

367Assert.Equal(authType.ToString(), response.Headers.WwwAuthenticate.First().Scheme);

DelegateTests.cs (6)

62Assert.Equal(_expectedResponseString, responseString); 95Assert.Equal(_expectedResponseString, responseString); 128Assert.Equal(_expectedResponseString, responseString); 214Assert.Equal(_expectedResponseString, responseString); 244Assert.Equal(_expectedResponseString, responseString); 263Assert.Equal(_expectedResponseString, responseString);

Http2Tests.cs (34)

Http3Tests.cs (9)

45Assert.Equal("HTTP/3", response); 80Assert.Equal("HTTP/1.1", await response1.Content.ReadAsStringAsync()); 81Assert.Equal(altsvc, response1.Headers.GetValues(HeaderNames.AltSvc).SingleOrDefault()); 85Assert.Equal("HTTP/3", response3); 118Assert.Equal(altsvc, response2.Headers.GetValues(HeaderNames.AltSvc).SingleOrDefault()); 119Assert.Equal("HTTP/2", await response2.Content.ReadAsStringAsync()); 123Assert.Equal("HTTP/3", response3); 151Assert.Equal("HTTP/3", result); 152Assert.Equal("value", response.TrailingHeaders.GetValues("custom").SingleOrDefault());

HttpsTests.cs (10)

33Assert.Equal(string.Empty, response); 48Assert.Equal("Hello World", response); 58Assert.Equal("Hello World", input); 65Assert.Equal("Hello World", response); 90Assert.Equal(string.Empty, response); 124Assert.Equal(string.Empty, response); 146Assert.Equal(string.Empty, response); 189Assert.Equal("localhost", hostName); 230Assert.Equal(string.Empty, response); 260Assert.Equal(string.Empty, response);

Listener\RequestBodyTests.cs (4)

41Assert.Equal("Hello World", response); 65Assert.Equal(string.Empty, response); 89Assert.Equal(string.Empty, response); 114Assert.Equal(string.Empty, response);

Listener\RequestTests.cs (6)

27Assert.Equal("400", responseStatusCode); 81Assert.Equal("200", response.Substring(9)); 84Assert.Equal(expect, actualPath.TrimStart('/')); 104Assert.Equal("400", response.Substring(9)); 131Assert.Equal("200", response.Substring(9)); 169Assert.Equal("200", response.Substring(9));

Listener\ResponseHeaderTests.cs (7)

43Assert.Equal("Microsoft-HTTPAPI/2.0", response.Headers.Server.ToString()); 66Assert.Equal("Microsoft-HTTPAPI/2.0", response.Headers.Server.ToString()); 88Assert.Equal("Microsoft-HTTPAPI/2.0", response.Headers.Server.ToString()); 117Assert.Equal("Microsoft-HTTPAPI/2.0", response.Headers.Server.ToString()); 146Assert.Equal("Microsoft-HTTPAPI/2.0", response.Headers.Server.ToString()); 175Assert.Equal("Microsoft-HTTPAPI/2.0", response.Headers.Server.ToString()); 198Assert.Equal("Microsoft-HTTPAPI/2.0", response.Headers.Server.ToString());

Listener\ServerOnExistingQueueTests.cs (17)

Listener\ServerTests.cs (7)

68Assert.Equal(string.Empty, await response.Content.ReadAsStringAsync()); 108Assert.Equal("Hello World", response); 124Assert.Equal(string.Empty, response); 157Assert.Equal(string.Empty, response); 170Assert.Equal(string.Empty, response); 190Assert.Equal(string.Empty, response); 202Assert.Equal(string.Empty, response);

OpaqueUpgradeTests.cs (4)

43Assert.Equal(string.Empty, await response.Content.ReadAsStringAsync()); 71Assert.Equal(string.Empty, await response.Content.ReadAsStringAsync()); 273Assert.Equal("The response status code was incorrect: HTTP/1.1 200 OK", ex.Message); 355Assert.Equal("Upgrade requires HTTP/1.1.", ex.Message);

RequestBodyLimitTests.cs (30)

RequestBodyTests.cs (13)

39Assert.Equal("Hello World", response); 61Assert.Equal("Hello World", response); 79Assert.Equal("Hello World", response); 99Assert.Equal("Hello World", response); 117Assert.Equal("Hello World", response); 139Assert.Equal(string.Empty, response); 161Assert.Equal(string.Empty, response); 181Assert.Equal(string.Empty, response); 203Assert.Equal("HTTP/1.1 200 OK", lines[0]); 204Assert.Equal("0123456789", lines[12]); 235Assert.Equal("Hello World", response); 270Assert.Equal("", httpContext.Request.Headers[HeaderNames.ContentLength].ToString()); 282Assert.Equal("", httpContext.Request.Headers["Custom-Header"].ToString());

RequestHeaderTests.cs (13)

34Assert.Equal(string.Empty, response); 46Assert.Equal("close", requestHeaders["Connection"]); 49Assert.Equal("custom1, and custom2, custom3", requestHeaders["Custom-Header"]); 51Assert.Equal("spacervalue, spacervalue", requestHeaders["Spacer-Header"]); 80Assert.Equal("200", responseStatusCode); 98Assert.Equal(string.Empty, response); 111Assert.Equal("chunked", requestHeaders.TransferEncoding); 121Assert.Equal("200", responseStatusCode); 134Assert.Equal("gzip, chunked", requestHeaders.TransferEncoding); 144Assert.Equal("200", responseStatusCode); 157Assert.Equal("gzip, chunked", requestHeaders.TransferEncoding); 166Assert.Equal("1", requestHeaders["X-Content-Length"]); 176Assert.Equal("200", responseStatusCode);

RequestTests.cs (52)

ResponseBodyTests.cs (5)

38Assert.Equal("Hello World", await response.Content.ReadAsStringAsync()); 204Assert.Equal("Manually Chunked", await response.Content.ReadAsStringAsync()); 227Assert.Equal("30", contentLength.First()); 307Assert.Equal("10", contentLength.First()); 431Assert.Equal("hello, world", Encoding.UTF8.GetString(payload));

ResponseCachingTests.cs (38)

ResponseHeaderTests.cs (15)

34Assert.Equal("Microsoft-HTTPAPI/2.0", response.Headers.Server.ToString()); 61Assert.Equal("Microsoft-HTTPAPI/2.0", response.Headers["Server"]); 62Assert.Equal("custom1", response.Headers["WWW-Authenticate"]); 86Assert.Equal("Microsoft-HTTPAPI/2.0", response.Headers["Server"]); 87Assert.Equal("custom1, and custom2, custom3", response.Headers["WWW-Authenticate"]); 111Assert.Equal("Microsoft-HTTPAPI/2.0", response.Headers["Server"]); 112Assert.Equal("custom1, and custom2, custom3", response.Headers["Custom-Header1"]); 133Assert.Equal("Dašta", header.Single()); 208Assert.Equal("Manually Chunked", await response.Content.ReadAsStringAsync()); 238Assert.Equal("value1a", response.Headers.GetValues("Custom1").First()); 239Assert.Equal("value1b", response.Headers.GetValues("Custom1").Skip(1).First()); 241Assert.Equal("value2a, value2b", response.Headers.GetValues("Custom2").First()); 268Assert.Equal("value1a", response.Headers.GetValues("Custom1").First()); 269Assert.Equal("value1b", response.Headers.GetValues("Custom1").Skip(1).First()); 271Assert.Equal("value2a, value2b", response.Headers.GetValues("Custom2").First());

ResponseSendFileTests.cs (3)

229Assert.Equal(FileLength.ToString(CultureInfo.InvariantCulture), contentLength.First()); 250Assert.Equal("10", contentLength.First()); 271Assert.Equal("0", contentLength.First());

ResponseTests.cs (8)

35Assert.Equal("OK", response.ReasonPhrase); 37Assert.Equal(string.Empty, await response.Content.ReadAsStringAsync()); 54Assert.Equal("Created", response.ReasonPhrase); 56Assert.Equal(string.Empty, await response.Content.ReadAsStringAsync()); 74Assert.Equal("CustomReasonPhrase", response.ReasonPhrase); 76Assert.Equal(string.Empty, await response.Content.ReadAsStringAsync()); 92Assert.Equal(string.Empty, response.ReasonPhrase); 93Assert.Equal(string.Empty, await response.Content.ReadAsStringAsync());

ResponseTrailersTests.cs (20)

27Assert.Equal("HTTP/1.1", httpContext.Request.Protocol); 45Assert.Equal("HTTP/2", httpContext.Request.Protocol); 93Assert.Equal("TrailerValue", response.TrailingHeaders.GetValues("TrailerName").Single()); 110Assert.Equal("Hello World", await response.Content.ReadAsStringAsync()); 112Assert.Equal("Trailer Value", response.TrailingHeaders.GetValues("TrailerName").Single()); 140Assert.Equal(body.Length.ToString(CultureInfo.InvariantCulture), response.Content.Headers.GetValues(HeaderNames.ContentLength).Single()); 141Assert.Equal(body, await response.Content.ReadAsStringAsync()); 165Assert.Equal((2 * body.Length).ToString(CultureInfo.InvariantCulture), contentLength.First()); 166Assert.Equal(body + body, await response.Content.ReadAsStringAsync()); 168Assert.Equal("Trailer Value", response.TrailingHeaders.GetValues("TrailerName").Single()); 190Assert.Equal(body.Length.ToString(CultureInfo.InvariantCulture), contentLength.First()); 191Assert.Equal("TrailerName", response.Headers.Trailer.Single()); 192Assert.Equal(body, await response.Content.ReadAsStringAsync()); 194Assert.Equal("Trailer Value", response.TrailingHeaders.GetValues("TrailerName").Single()); 216Assert.Equal(body.Length.ToString(CultureInfo.InvariantCulture), contentLength.First()); 217Assert.Equal("TrailerName", response.Headers.Trailer.Single()); 218Assert.Equal(body, await response.Content.ReadAsStringAsync()); 239Assert.Equal("TrailerValue", response.TrailingHeaders.GetValues("TrailerName").Single()); 260Assert.Equal("Hello World", await response.Content.ReadAsStringAsync()); 262Assert.Equal("Trailer Value", response.TrailingHeaders.GetValues("TrailerName").Single());

ServerTests.cs (13)

DelegateOutOfProcTests.cs (2)

50Assert.Equal("Hello from delegatee", responseString); 66Assert.Equal("Hello from delegatee", responseString);

UrlPrefixTests.cs (6)

68Assert.Equal(scheme, urlPrefix.Scheme); 69Assert.Equal(host, urlPrefix.Host); 70Assert.Equal(port, urlPrefix.Port); 71Assert.Equal(pathBase, urlPrefix.Path); 73Assert.Equal(toString ?? url, urlPrefix.ToString()); 82Assert.Equal("/p\u0041\u030Athbase/", urlPrefix.Path);

IISMiddlewareTests.cs (7)

322Assert.Equal("http://127.0.0.1:12345", configuration[WebHostDefaults.ServerUrlsKey]); 323Assert.Equal("true", configuration[WebHostDefaults.PreferHostingUrlsKey]); 350Assert.Equal("http://127.0.0.1:12345", configuration[WebHostDefaults.ServerUrlsKey]); 387Assert.Equal("/PathBase", requestPathBase); 388Assert.Equal("/Path", requestPath); 412Assert.Equal("Microsoft.AspNetCore.Server.IISIntegration.AuthenticationHandler", windows.HandlerType.FullName); 457Assert.Equal("AuthenticationHandler", windowsAuth.HandlerType.Name);

AddressBinderTests.cs (10)

92Assert.Equal("HelloWorld", listenOptions.PipeName); 94Assert.Equal(address, listenOptions.GetDisplayName()); 103Assert.Equal(@"LOCAL\HelloWorld", listenOptions.PipeName); 105Assert.Equal(address, listenOptions.GetDisplayName()); 114Assert.Equal("/tmp/kestrel-test.sock", listenOptions.PipeName); 116Assert.Equal(address, listenOptions.GetDisplayName()); 125Assert.Equal("/tmp/kestrel-test.sock", listenOptions.SocketPath); 136Assert.Equal("c:/foo/bar/pipe.socket", listenOptions.SocketPath); 195Assert.Equal(CoreStrings.FormatOverridingWithKestrelOptions(overriddenAddress), log.Message); 223Assert.Equal(CoreStrings.FormatOverridingWithPreferHostingUrls(nameof(addressBindContext.ServerAddressesFeature.PreferHostingUrls), overriddenAddress), log.Message);

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

69Assert.Equal("Unexpected error listening", critical.Exception.Message); 115Assert.Equal("An error occurred running an IConnectionCompleteFeature.OnCompleted callback.", errors[0].Message);

DateHeaderValueManagerTests.cs (7)

31Assert.Equal(now.ToString(Rfc1123DateFormat), dateHeaderValueManager.GetDateHeaderValues().String); 47Assert.Equal(now.ToString(Rfc1123DateFormat), dateHeaderValueManager.GetDateHeaderValues().String); 49Assert.Equal(now.ToString(Rfc1123DateFormat), dateHeaderValueManager.GetDateHeaderValues().String); 71Assert.Equal(now.ToString(Rfc1123DateFormat), dateHeaderValueManager.GetDateHeaderValues().String); 78Assert.Equal(future.ToString(Rfc1123DateFormat), dateHeaderValueManager.GetDateHeaderValues().String); 96Assert.Equal(now.ToString(Rfc1123DateFormat), dateHeaderValueManager.GetDateHeaderValues().String); 100Assert.Equal(now.ToString(Rfc1123DateFormat), dateHeaderValueManager.GetDateHeaderValues().String);

DiagnosticMemoryPoolTests.cs (12)

Http1\Http1ConnectionTests.cs (19)

Http2\Http2HeadersEnumeratorTests.cs (14)

94Assert.Equal("Name1", e.Current.Key); 95Assert.Equal("Value1", e.Current.Value); 99Assert.Equal("Name2", e.Current.Key); 100Assert.Equal("Value2-1", e.Current.Value); 104Assert.Equal("Name2", e.Current.Key); 105Assert.Equal("Value2-2", e.Current.Value); 119Assert.Equal("Grpc-Status", e.Current.Key); 120Assert.Equal("1", e.Current.Value); 124Assert.Equal("Name1", e.Current.Key); 125Assert.Equal("Value1", e.Current.Value); 129Assert.Equal("Name2", e.Current.Key); 130Assert.Equal("Value2-1", e.Current.Value); 134Assert.Equal("Name2", e.Current.Key); 135Assert.Equal("Value2-2", e.Current.Value);

Http2\Http2HPackEncoderTests.cs (60)

29Assert.Equal("48-03-33-30-32", hex); 32Assert.Equal(":status", statusHeader.Name); 33Assert.Equal("302", statusHeader.Value); 52Assert.Equal("58-07-70-72-69-76-61-74-65", hex); 55Assert.Equal("Cache-Control", statusHeader.Name); 56Assert.Equal("private", statusHeader.Value); 80Assert.Equal( 91Assert.Equal("Location", e.Name); 92Assert.Equal("https://www.example.com", e.Value); 97Assert.Equal("Cache-Control", e.Name); 98Assert.Equal("private", e.Value); 103Assert.Equal("Date", e.Name); 104Assert.Equal("Mon, 21 Oct 2013 20:13:21 GMT", e.Value); 109Assert.Equal(":status", e.Name); 110Assert.Equal("302", e.Value); 122Assert.Equal("48-03-33-30-37-C1-C0-BF", hex); 128Assert.Equal(":status", e.Name); 129Assert.Equal("307", e.Value); 134Assert.Equal("Location", e.Name); 135Assert.Equal("https://www.example.com", e.Value); 140Assert.Equal("Cache-Control", e.Name); 141Assert.Equal("private", e.Value); 146Assert.Equal("Date", e.Name); 147Assert.Equal("Mon, 21 Oct 2013 20:13:21 GMT", e.Value); 163Assert.Equal( 176Assert.Equal("Content-Encoding", e.Name); 177Assert.Equal("gzip", e.Value); 182Assert.Equal("Date", e.Name); 183Assert.Equal("Mon, 21 Oct 2013 20:13:22 GMT", e.Value); 188Assert.Equal(":status", e.Name); 189Assert.Equal("307", e.Value); 194Assert.Equal("Location", e.Name); 195Assert.Equal("https://www.example.com", e.Value); 224Assert.Equal( 235Assert.Equal("Location", e.Name); 236Assert.Equal("你好你好你好你.c", e.Value); 241Assert.Equal("Cache-Control", e.Name); 242Assert.Equal("你好e", e.Value); 247Assert.Equal("Date", e.Name); 248Assert.Equal("Mon, 21 Oct 2013 20:13:21 GMT", e.Value); 253Assert.Equal(":status", e.Name); 254Assert.Equal("302", e.Value); 266Assert.Equal("48-03-33-30-37-C1-C0-BF", hex); 272Assert.Equal(":status", e.Name); 273Assert.Equal("307", e.Value); 278Assert.Equal("Location", e.Name); 279Assert.Equal("你好你好你好你.c", e.Value); 284Assert.Equal("Cache-Control", e.Name); 285Assert.Equal("你好e", e.Value); 290Assert.Equal("Date", e.Name); 291Assert.Equal("Mon, 21 Oct 2013 20:13:21 GMT", e.Value); 307Assert.Equal( 320Assert.Equal("Content-Encoding", e.Name); 321Assert.Equal("gzip", e.Value); 326Assert.Equal("Date", e.Name); 327Assert.Equal("Mon, 21 Oct 2013 20:13:22 GMT", e.Value); 332Assert.Equal(":status", e.Name); 333Assert.Equal("307", e.Value); 338Assert.Equal("Location", e.Name); 339Assert.Equal("你好你好你好你.c", e.Value);

Http3\Http3QPackEncoderTests.cs (6)

26Assert.Equal("00-00-5F-30-03-34-31-38", hex); 43Assert.Equal("00-00-D9", hex); 92Assert.Equal("EE", hex); 111Assert.Equal("37-02-74-72-61-6E-73-6C-61-74-65-07-70-72-69-76-61-74-65", hex); 130Assert.Equal("37-03-6E-65-77-2D-68-65-61-64-65-72-05-76-61-6C-75-65", hex); 149Assert.Equal("5F-1D-12-61-70-70-6C-69-63-61-74-69-6F-6E-2F-63-75-73-74-6F-6D", hex);

HttpHeadersTests.cs (2)

262Assert.Equal("1", value[0]); 268Assert.Equal(HeaderUtilities.FormatNonNegativeInt64(long.MaxValue), value[0]);

HttpParserTests.cs (21)

HttpRequestHeadersTests.cs (28)

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

HttpUtilitiesTest.cs (3)

50Assert.Equal(toString, expectedKnownString); 79Assert.Equal(expectedKnownString, toString); 133Assert.Equal(knownString1, expected);

KestrelEventSourceTests.cs (1)

25Assert.Equal("Microsoft-AspNetCore-Server-Kestrel", EventSource.GetName(esType));

KestrelServerLimitsTests.cs (2)

175Assert.Equal("value", exception.ParamName); 204Assert.Equal("value", exception.ParamName);

KestrelServerOptionsTests.cs (1)

103Assert.Equal("value", ex.ParamName);

KestrelServerTests.cs (6)

88Assert.Equal(CoreStrings.NoCertSpecifiedNoDevelopmentCertificateFound, ex.Message); 128Assert.Equal( 234Assert.Equal( 261Assert.Equal( 287Assert.Equal("transportFactory", exception.ParamName); 324Assert.Equal(CoreStrings.TransportNotFound, exception.Message);

ListenOptionsTests.cs (1)

73Assert.Equal("http://127.0.0.1:5555/", ((UriEndPoint)listenOptions.EndPoint).Uri.ToString());

LoggingStreamTests.cs (2)

39Assert.Equal($"Write[{bufferLength}]{Environment.NewLine}{expectedOutput}", mockLogger.Logs); 50Assert.Equal($"Write[0]", mockLogger.Logs);

MemoryPoolTests.cs (1)

47Assert.Equal($"Cannot access a disposed object.{Environment.NewLine}Object name: 'MemoryPool'.", 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);

MinDataRateTests.cs (2)

28Assert.Equal("bytesPerSecond", exception.ParamName); 45Assert.Equal("gracePeriod", exception.ParamName);

ReasonPhrasesTests.cs (1)

22Assert.Equal(expectedResult, Encoding.ASCII.GetString(bytes));

SniOptionsSelectorTests.cs (24)

src\Servers\Kestrel\shared\test\MetricsAssert.cs (1)

14Assert.Equal(KestrelMetrics.GetErrorType(expectedReason), errorType);

src\Servers\Kestrel\shared\test\StreamBackedTestConnection.cs (2)

126Assert.Equal(expected, actualText); 135Assert.Equal("", text);

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

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

StartLineTests.cs (39)

StringUtilitiesTests.cs (2)

22Assert.Equal($"{str}:{value:X8}", StringUtilities.ConcatAsHexSuffix(str, ':', value)); 29Assert.Equal(":23BC0234", StringUtilities.ConcatAsHexSuffix(null, ':', value));

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

ConfigurationReaderTests.cs (1)

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

HttpsConnectionAdapterOptionsTest.cs (1)

39Assert.Equal("value", exception.ParamName);

KestrelConfigurationLoaderTests.cs (11)

268Assert.Equal(opt.HttpsOptions.ServerCertificate.SerialNumber, certificate.SerialNumber); 352Assert.Equal(expectedCert.SerialNumber, httpsOptions.ServerCertificate.SerialNumber); 693Assert.Equal(opt.HttpsOptions.ServerCertificate.SerialNumber, certificate.SerialNumber); 776Assert.Equal(CoreStrings.FormatEndpointHasUnusedHttpsConfig("End1", "Certificate"), ex.Message); 785Assert.Equal(CoreStrings.FormatEndpointHasUnusedHttpsConfig("End1", "Certificate"), ex.Message); 794Assert.Equal(CoreStrings.FormatEndpointHasUnusedHttpsConfig("End1", "ClientCertificateMode"), ex.Message); 803Assert.Equal(CoreStrings.FormatEndpointHasUnusedHttpsConfig("End1", "SslProtocols"), ex.Message); 812Assert.Equal(CoreStrings.FormatEndpointHasUnusedHttpsConfig("End1", "Sni"), ex.Message); 884Assert.Equal(opt.HttpsOptions.ServerCertificate.SerialNumber, expectedSerialNumber); 983Assert.Equal(opt.HttpsOptions.ServerCertificate.SerialNumber, expectedSerialNumber); 1861Assert.Equal("abc", serverOptions.CodeBackedListenOptions[0].PipeName);

QuicConnectionListenerTests.cs (1)

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

WebHostTests.cs (8)

90Assert.Equal("hello, world", responseText); 254Assert.Equal("hello, world", responseText1); 268Assert.Equal("hello, world", responseText2); 325Assert.Equal("hello, world", responseText1); 338Assert.Equal("hello, world", responseText2); 363Assert.Equal("hello, world", responseText1); 375Assert.Equal("hello, world", responseText2); 412Assert.Equal("No registered IMultiplexedConnectionListenerFactory supports endpoint UnixDomainSocketEndPoint: /test-path", ex.Message);

SessionTests.cs (18)

76Assert.Equal("Value", context.Session.GetString("Key")); 131Assert.Equal("Value", context.Session.GetString("Key")); 200Assert.Equal("0", await response.Content.ReadAsStringAsync()); 205Assert.Equal("1", await client.GetStringAsync("/")); 206Assert.Equal("2", await client.GetStringAsync("/")); 207Assert.Equal("3", await client.GetStringAsync("/")); 260Assert.Equal("0", await response.Content.ReadAsStringAsync()); 265Assert.Equal("1", await client.GetStringAsync("/second")); 266Assert.Equal("2", await client.GetStringAsync("/third")); 318Assert.Equal("0", await response.Content.ReadAsStringAsync()); 323Assert.Equal("1", await client.GetStringAsync("/second")); 324Assert.Equal("2", await client.GetStringAsync("/third")); 433Assert.Equal("2", result); 505Assert.Equal("10", data); 615Assert.Equal("VALUE", context.Session.GetString("KEY")); 616Assert.Equal("value", context.Session.GetString("key")); 656Assert.Equal(string.Empty, context.Session.Id); 706Assert.Equal(string.Empty, context.Session.Id);

AdaptiveCapacityDictionaryTests.cs (20)

CommandLineApplicationTests.cs (63)

ObjectMethodExecutorTest.cs (12)

52Assert.Equal("Hello", resultObject.value); 65Assert.Equal("HelloWorld", resultObject.value); 100Assert.Equal("Hello", resultObject.value); 113Assert.Equal("HelloWorld", resultObject.value); 175Assert.Equal("Hello 123", result.value); 207Assert.Equal("Hello 123", ((TestObject)result).value); 259Assert.Equal("Used UnsafeOnCompleted", (string)result); 274Assert.Equal("Used OnCompleted", (string)result); 304Assert.Equal("test result", result); 353Assert.Equal("test result", result); 374Assert.Equal("Test exception", exception.InnerException.Message); 407Assert.Equal("Test exception", exception.InnerException.Message);

PathNormalizerTests.cs (1)

85Assert.Equal(expected, Encoding.ASCII.GetString(data, 0, length));

PropertyHelperTest.cs (29)

25Assert.Equal("foo", property.Name); 26Assert.Equal("foo", helper.Name); 40Assert.Equal("bar", helper.Name); 72Assert.Equal(expected, instance.PropA); 89Assert.Equal(expected, instance.PropA); 103Assert.Equal("foo", helper.Name); 131Assert.Equal("bar_baz2", helper.Name); 142Assert.Equal("Prop1", helper.Name); 153Assert.Equal("Prop5", helper.Name); 165Assert.Equal("Prop5", helper.Name); 180Assert.Equal("Prop6", helper.Name); 206Assert.Equal("Foo", property.Name); 330Assert.Equal("Visible", result[0].Name); 331Assert.Equal("PropA", result[1].Name); 332Assert.Equal("PropB", result[2].Name); 346Assert.Equal("Length", property.Name); 361Assert.Equal("Id", result[0].Name); 363Assert.Equal("Name", result[1].Name); 378Assert.Equal("Id", result[0].Name); 380Assert.Equal("Name", result[1].Name); 395Assert.Equal("Length", property.Name); 410Assert.Equal("Id", result[0].Name); 412Assert.Equal("Name", result[1].Name); 427Assert.Equal("Id", result[0].Name); 429Assert.Equal("Name", result[1].Name); 449Assert.Equal("TestPublic", instance.PropA); 450Assert.Equal("TestProtected", instance.GetPropProtected()); 466Assert.Equal("OverridenTest value", instance.PropA); 482Assert.Equal("NewedTest value", instance.PropB);

QueryStringEnumerableTest.cs (4)

94Assert.Equal(expectedDecodedName, kvp.DecodeName().ToString()); 95Assert.Equal(expectedDecodedValue, kvp.DecodeValue().ToString()); 111Assert.Equal(expectedKey, actual.key); 112Assert.Equal(expectedValue, actual.value);

runtime\Http2\HPackDecoderTest.cs (39)

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

runtime\Http3\QPackDecoderTest.cs (14)

SecurityHelperTests.cs (14)

19Assert.Equal("Alpha", user.Identity.AuthenticationType); 20Assert.Equal("Test1", user.Identity.Name); 31Assert.Equal("Alpha", user.Identity.AuthenticationType); 32Assert.Equal("Test1", user.Identity.Name); 36Assert.Equal("Beta", user.Identity.AuthenticationType); 37Assert.Equal("Test2", user.Identity.Name); 41Assert.Equal("Gamma", user.Identity.AuthenticationType); 42Assert.Equal("Test3", user.Identity.Name); 45Assert.Equal("Test3", user.Identities.Skip(0).First().Name); 46Assert.Equal("Test2", user.Identities.Skip(1).First().Name); 47Assert.Equal("Test1", user.Identities.Skip(2).First().Name); 83Assert.Equal("Gamma", user.Identity.AuthenticationType); 84Assert.Equal("Test3", user.Identity.Name); 87Assert.Equal("Test3", user.Identities.Skip(0).First().Name);

StackTraceHelperTest.cs (13)

TypeNameHelperTest.cs (9)

47Assert.Equal(expected, TypeNameHelper.GetTypeDisplayName(type)); 57Assert.Equal("ClassInGlobalNamespace<int>", TypeNameHelper.GetTypeDisplayName(type)); 82Assert.Equal(expected, TypeNameHelper.GetTypeDisplayName(type, false)); 104Assert.Equal(expected, TypeNameHelper.GetTypeDisplayName(type)); 117Assert.Equal(expected, TypeNameHelper.GetTypeDisplayName(type, fullName)); 176Assert.Equal(expected, TypeNameHelper.GetTypeDisplayName(type, fullName)); 196Assert.Equal(expected, actual); 216Assert.Equal(expected, actual); 257Assert.Equal(expectedTypeName, displayName);

WebEncodersTests.cs (4)

51Assert.Equal(expectedBase64Url, actualBase64Url); 57Assert.Equal(roundTrippedAsBase64, base64Input); 83Assert.Equal(expectedBase64Url, encodedString); 92Assert.Equal(roundTrippedAsBase64, base64Input);

HubConnectionTests.cs (62)

108Assert.Equal("Hello World!", result); 144Assert.Equal("The client requested version '1', but the server does not support this version.", ex.Message); 202Assert.Equal(originalMessage, result); 258Assert.Equal(originalMessage, result); 262Assert.Equal(originalMessage, result); 291Assert.Equal(connection.ConnectionId, connectionIdFromServer); 297Assert.Equal(connection.ConnectionId, connectionIdFromServer); 349Assert.Equal(originalMessage, result); 359Assert.Equal(originalMessage, result); 389Assert.Equal(originalMessage, result); 428Assert.Equal(originalMessage, await echoTcs.Task.DefaultTimeout()); 429Assert.Equal("Hello World!", await helloWorldTcs.Task.DefaultTimeout()); 665Assert.Equal("An unexpected error occurred invoking 'StreamException' on the server. InvalidOperationException: Error occurred while streaming.", ex.Message); 700Assert.Equal(originalMessage, await tcs.Task.DefaultTimeout()); 803Assert.Equal("1", await channel.ReadAsync().AsTask().DefaultTimeout()); 805Assert.Equal("2", await channel.ReadAsync().AsTask().DefaultTimeout()); 850Assert.Equal("A", await channel.ReadAsync().AsTask().DefaultTimeout()); 851Assert.Equal("B", await channel.ReadAsync().AsTask().DefaultTimeout()); 852Assert.Equal("C", await channel.ReadAsync().AsTask().DefaultTimeout()); 853Assert.Equal("D", await channel.ReadAsync().AsTask().DefaultTimeout()); 1055Assert.Equal("An unexpected error occurred invoking 'StreamException' on the server. InvalidOperationException: Error occurred while streaming.", ex.Message); 1082Assert.Equal("Failed to invoke '!@#$%' due to an error on the server. HubException: Method does not exist.", ex.Message); 1109Assert.Equal("Failed to invoke '!@#$%' due to an error on the server. HubException: Method does not exist.", ex.Message); 1136Assert.Equal("Failed to invoke 'Echo' due to an error on the server. InvalidDataException: Invocation provides 2 argument(s) but target expects 1.", ex.Message); 1191Assert.Equal("Failed to invoke '!@#$%' due to an error on the server. HubException: Method does not exist.", ex.Message); 1219Assert.Equal("Failed to invoke 'Stream' due to an error on the server. InvalidDataException: Invocation provides 2 argument(s) but target expects 1.", ex.Message); 1247Assert.Equal("Failed to invoke 'Stream' due to an error on the server. InvalidDataException: Error binding arguments. Make sure that the types of the provided values match the types of the hub method being invoked.", ex.Message); 1274Assert.Equal("The client attempted to invoke the non-streaming 'HelloWorld' method with a streaming invocation.", ex.Message); 1301Assert.Equal("The client attempted to invoke the streaming 'Stream' method with a non-streaming invocation.", ex.Message); 1328Assert.Equal("The value returned by the streaming method 'StreamBroken' is not a ChannelReader<> or IAsyncEnumerable<>.", ex.Message); 1464Assert.Equal("Failed to invoke 'StreamEcho' due to an error on the server. InvalidDataException: Invocation provides 1 argument(s) but target expects 0.", 1494Assert.Equal("Hello, World!", message); 1526Assert.Equal("Response status code does not indicate success: 401 (Unauthorized).", ex.Message); 1549Assert.Equal("Hello, World!", message); 1693Assert.Equal("User Value", userAgent); 1728Assert.Equal("Bar", cookieValue); 1779Assert.Equal("Foo", echoResponse); 1838Assert.Equal("Foo", echoResponse); 1946Assert.Equal("Bearer test", headerResponse[0]); 1981Assert.Equal("a value", cookieValue); 2016Assert.Equal("127.0.0.1", localIP); 2017Assert.Equal("127.0.0.1", remoteIP); 2048Assert.Equal("SuperAdmin", userIdentifier); 2178Assert.Equal(connection.ConnectionId, newConnectionId); 2181Assert.Equal(echoMessage, result); 2238Assert.Equal(connection.ConnectionId, newConnectionId); 2241Assert.Equal(echoMessage, result); 2307Assert.Equal(echoMessage, result); 2344Assert.Equal("Hello World!", invokeTask.Result); 2390Assert.Equal("HTTP/2", httpProtocol); 2443Assert.Equal("HTTP/2", httpProtocol); 2486Assert.Equal("HTTP/2", httpProtocol); 2536Assert.Equal("HTTP/2", httpProtocol); 2584Assert.Equal(originalMessage, result); 2594Assert.Equal(originalMessage, result); 2595Assert.Equal(originalConnectionId, connection.ConnectionId); 2652Assert.Equal(originalMessage, result); 2662Assert.Equal(originalMessage, result); 2663Assert.Equal(originalConnectionId, connection.ConnectionId); 2733Assert.Equal(originalConnectionId, connection.ConnectionId); 2831Assert.Equal(originalMessage, result); 2895Assert.Equal(originalMessage, result);

HubConnectionTests.Tracing.cs (55)

HubProtocolVersionTests.cs (2)

53Assert.Equal("Hello World!", result); 86Assert.Equal("Hello World!", result);

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.ConnectionLifecycle.cs (3)

72Assert.Equal(typeof(HttpConnection).FullName, exception.ObjectName); 158Assert.Equal("Unable to connect to the server with any of the available transports. " + 539Assert.Equal(typeof(HttpConnection).FullName, exception.ObjectName);

HttpConnectionTests.cs (5)

53Assert.Equal("url", exception.ParamName); 60Assert.Equal("httpConnectionOptions", exception.ParamName); 68Assert.Equal("The ConnectionId is set internally and should not be set by user code.", exception.Message); 162Assert.Equal("SendingHttpRequest", writeList[0].EventId.Name); 163Assert.Equal("UnsuccessfulHttpResponse", writeList[1].EventId.Name);

HttpConnectionTests.Negotiate.cs (25)

HttpConnectionTests.Transport.cs (10)

44Assert.Equal("Bearer", request.Headers.Authorization.Scheme); 47Assert.Equal(callCount.ToString(CultureInfo.InvariantCulture), request.Headers.Authorization.Parameter); 169Assert.Equal("XMLHttpRequest", requestedWithValue); 263Assert.Equal($"Cannot access the {nameof(Transport)} pipe before the connection has started.", exception.Message); 279Assert.Equal(typeof(HttpConnection).FullName, exception.ObjectName); 389Assert.Equal("Bearer", request.Headers.Authorization.Scheme); 391Assert.Equal(accessTokenCallCount.ToString(CultureInfo.InvariantCulture), request.Headers.Authorization.Parameter); 410Assert.Equal("This is a test", Encoding.UTF8.GetString(message.Buffer)); 489Assert.Equal("Bearer", request.Headers.Authorization.Scheme); 491Assert.Equal(accessTokenCallCount.ToString(CultureInfo.InvariantCulture), request.Headers.Authorization.Parameter);

HubConnectionBuilderTests.cs (4)

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); 57Assert.Equal("JUST A TEST", actualProtocol.PayloadSerializer.DateFormatString); 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 (7)

197Assert.Equal("{\"type\":7}", await connection.ReadSentTextMessageAsync().DefaultTimeout()); 216Assert.Equal("{\"type\":7}", await connection.ReadSentTextMessageAsync().DefaultTimeout()); 258Assert.Equal("{\"type\":7}", await connection.ReadSentTextMessageAsync().DefaultTimeout()); 277Assert.Equal("{\"type\":7}", await connection.ReadSentTextMessageAsync().DefaultTimeout()); 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); 538Assert.Equal(expected.Foo, result.Foo);

HubConnectionTests.Protocol.cs (25)

HubConnectionTests.Reconnect.cs (3)

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

HubConnectionTests.Tracing.cs (3)

46Assert.Equal(clientActivity.Id, traceParent); 83Assert.Equal(clientActivity.Id, traceParent); 121Assert.Equal(clientActivity.Id, traceParent);

ServerSentEventsTransportTests.cs (3)

289Assert.Equal("3:abc", Encoding.ASCII.GetString(message)); 377Assert.Equal($"The 'Binary' transfer format is not supported by this transport.", ex.GetLocalizationSafeMessage()); 490Assert.Equal(expectedMessage, Encoding.ASCII.GetString(message));

TestServerTests.cs (2)

60Assert.Equal(originalMessage, receivedMessage); 105Assert.Equal(originalMessage, receivedMessage);

Internal\Formatters\BinaryMessageParserTests.cs (1)

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

Internal\Formatters\TextMessageFormatterTests.cs (1)

22Assert.Equal("ABC\u001e", Encoding.UTF8.GetString(ms.ToArray()));

Internal\Formatters\TextMessageParserTests.cs (5)

20Assert.Equal("ABC", Encoding.UTF8.GetString(payload.ToArray())); 36Assert.Equal("ABC", Encoding.UTF8.GetString(payload.ToArray())); 38Assert.Equal("XYZ", Encoding.UTF8.GetString(payload.ToArray())); 46Assert.Equal("ABC", Encoding.UTF8.GetString(payload.ToArray())); 48Assert.Equal("XYZ", Encoding.UTF8.GetString(payload.ToArray()));

Internal\Protocol\HandshakeProtocolTests.cs (6)

30Assert.Equal(protocol, deserializedMessage.Protocol); 41Assert.Equal("json", deserializedMessage.Protocol); 55Assert.Equal(error, response.Error); 65Assert.Equal("dummy", response.Error); 94Assert.Equal(expectedMessage, exception.Message); 110Assert.Equal(expectedMessage, exception.Message);

Internal\Protocol\JsonHubProtocolTests.cs (12)

55Assert.Equal(expectedMessage, ex.Message); 73Assert.Equal(expectedOutput, json); 127Assert.Equal(Frame(expectedJson), json); 160Assert.Equal(Frame(expectedJson), json); 167Assert.Equal("1", streamItemMessage.InvocationId); 193Assert.Equal(Frame(expectedJson), json); 200Assert.Equal("1", completionMessage.InvocationId); 258Assert.Equal(expectedPersonExtended.Name, actualPersonExtended.Name); 267Assert.Equal(expectedPersonExtended2.Name, actualPersonExtended2.Name); 268Assert.Equal(expectedPersonExtended2.Location, actualPersonExtended2.Location); 276Assert.Equal(expectedJsonPerson.Name, actualJsonPerson.Name); 284Assert.Equal(expectedPerson.Name, actualPerson.Name);

Internal\Protocol\JsonHubProtocolTestsBase.cs (8)

128Assert.Equal(expectedOutput, json); 197Assert.Equal(expectedMessage, ex.Message); 258Assert.Equal(expectedMessage, bindingFailure.BindingFailure.SourceException.Message); 270Assert.Equal("Error reading JSON.", ex.Message); 310Assert.Equal("foo", bindingFailure.Target); 352Assert.Equal(expectedOutput, json); 479Assert.Equal("1", completion.InvocationId); 495Assert.Equal("1", completion.InvocationId);

Internal\Protocol\MessagePackHubProtocolTestBase.cs (2)

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

Internal\Protocol\MessagePackHubProtocolTests.cs (2)

256Assert.Equal("xyz", completion.InvocationId); 270Assert.Equal("xyz", completion.InvocationId);

Internal\Protocol\NewtonsoftJsonHubProtocolTests.cs (2)

53Assert.Equal(expectedMessage, ex.Message); 72Assert.Equal(expectedOutput, json);

Internal\Protocol\Utf8BufferTextReaderTests.cs (8)

25Assert.Equal("Hello World", new string(chars, 0, read)); 39Assert.Equal("a\u00E4\u00E4\u00a9o", new string(chars, 0, read)); 57Assert.Equal("Hello World", new string(chars, 10, read)); 71Assert.Equal("Hello", new string(chars, 0, read)); 76Assert.Equal(" Worl", new string(chars, 0, read)); 81Assert.Equal("d", new string(chars, 0, read)); 103Assert.Equal("\u00E4\u00E4", new string(chars, 0, read)); 108Assert.Equal("\u00E5", new string(chars, 0, read));

Internal\Protocol\Utf8BufferTextWriterTests.cs (4)

233Assert.Equal("Hello", Encoding.UTF8.GetString(bufferWriter1.ToArray())); 242Assert.Equal("World", Encoding.UTF8.GetString(bufferWriter2.ToArray())); 292Assert.Equal(testString, Encoding.UTF8.GetString(bufferWriter.ToArray())); 340Assert.Equal(expected, result);

HubLifetimeManagerTestBase.cs (15)

49Assert.Equal("Hello", message.Target); 51Assert.Equal("World", (string)message.Arguments[0]); 54Assert.Equal("Hello", message.Target); 56Assert.Equal("World", (string)message.Arguments[0]); 82Assert.Equal("Hello", message.Target); 84Assert.Equal("World", (string)message.Arguments[0]); 112Assert.Equal("Hello", message.Target); 114Assert.Equal("World", (string)message.Arguments[0]); 143Assert.Equal("Hello", message.Target); 145Assert.Equal("World", (string)message.Arguments[0]); 168Assert.Equal("Hello", message.Target); 170Assert.Equal("World", (string)message.Arguments[0]); 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 (5)

33Assert.Equal("Hello", message.Target); 35Assert.Equal("World", (string)message.Arguments[0]); 525Assert.Equal("Error from client", ex.Message); 576Assert.Equal("Connection disconnected.", ex.Message); 627Assert.Equal("Connection '1234' does not exist.", ex.Message);

RedisDependencyInjectionExtensionsTests.cs (2)

30Assert.Equal(password, options.Value.Configuration.Password); 35Assert.Equal(host, dnsEndpoint.Host);

RedisEndToEnd.cs (10)

RedisHubLifetimeManagerTests.cs (6)

73Assert.Equal("Hello", message.Target); 82Assert.Equal("testProperty", prop.Name); 83Assert.Equal("Foo", prop.Value.Value<string>()); 117Assert.Equal("throw from connect", ex.Message); 124Assert.Equal("Error connecting to Redis.", logs[0].Message); 125Assert.Equal("throw from connect", logs[0].Exception.Message);

RedisProtocolTests.cs (4)

75Assert.Equal(testData.Decoded.ServerName, decoded.ServerName); 77Assert.Equal(testData.Decoded.GroupName, decoded.GroupName); 78Assert.Equal(testData.Decoded.ConnectionId, decoded.ConnectionId); 258Assert.Equal(testData.Decoded.ProtocolName, completionMessage.ProtocolName);

AddSignalRTests.cs (2)

185Assert.Equal("json", p); 189Assert.Equal("messagepack", p);

DefaultHubActivatorTests.cs (1)

60Assert.Equal("hub",

DefaultHubLifetimeManagerTests.cs (6)

40Assert.Equal("Hello", message.Target); 42Assert.Equal("World", (string)message.Arguments[0]); 216Assert.Equal("Hello", message.Target); 218Assert.Equal("World", (string)message.Arguments[0]); 246Assert.Equal("Hello", message.Target); 248Assert.Equal("World", (string)message.Arguments[0]);

DefaultTransportFactoryTests.cs (3)

38Assert.Equal("httpClient", exception.ParamName); 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); 293Assert.Equal(message, Encoding.UTF8.GetString(await connection.Transport.Input.ReadAsync(bytes.Length).DefaultTimeout())); 345Assert.Equal(message, Encoding.UTF8.GetString(receivedData)); 451Assert.Equal("Response status code does not indicate success: 401 (Unauthorized).", ex.Message); 625Assert.Equal("Response status code does not indicate success: 401 (Unauthorized).", ex.Message);

HubConnectionHandlerTests.Activity.cs (19)

61Assert.Equal("test", res); 79Assert.Equal("inner", userCodeActivity.OperationName); 143Assert.Equal("test", res); 150Assert.Equal("0123456789abcdef0123456789abcdef", invocationActivity.TraceId.ToHexString()); 151Assert.Equal("0123456789abcdef", invocationActivity.ParentSpanId.ToHexString()); 152Assert.Equal("TraceState1", invocationActivity.TraceStateString); 276Assert.Equal("0123456789abcdef0123456789abcdef", invocationActivity.TraceId.ToHexString()); 277Assert.Equal("0123456789abcdef", invocationActivity.ParentSpanId.ToHexString()); 278Assert.Equal("TraceState1", invocationActivity.TraceStateString); 495Assert.Equal(SignalRServerActivitySource.Name, activity.Source.Name); 497Assert.Equal($"{typeof(THub).FullName}/{methodName}", activity.DisplayName); 504Assert.Equal("error.type", tags[3].Key); 505Assert.Equal(exceptionType.FullName, tags[3].Value); 513Assert.Equal("rpc.method", tags[0].Key); 514Assert.Equal(methodName, tags[0].Value); 515Assert.Equal("rpc.system", tags[1].Key); 516Assert.Equal("signalr", tags[1].Value); 517Assert.Equal("rpc.service", tags[2].Key); 518Assert.Equal(typeof(THub).FullName, tags[2].Value);

HubConnectionHandlerTests.ClientResult.cs (18)

35Assert.Equal(invocationId, completion.InvocationId); 66Assert.Equal("An unexpected error occurred invoking 'GetClientResult' on the server. HubException: Client error", completion.Error); 67Assert.Equal(invocationId, completion.InvocationId); 92Assert.Equal("Connection closed with an error. InvalidOperationException: Client results inside OnConnectedAsync Hub methods are not allowed.", closeMessage.Error); 123Assert.Equal($"Connection '{client.Connection.ConnectionId}' disconnected.", ex.Message); 153Assert.Equal("GetClientResult", invocation.Target); 187Assert.Equal("GetClientResult", invocation.Target); 264Assert.Equal(invocationId, completion.InvocationId); 270Assert.Equal(invocationId2, completion.InvocationId); 276Assert.Equal(invocationId3, completion.InvocationId); 380Assert.Equal("GetClientResultWithCancellation", invocation.Target); 385Assert.Equal("Invocation canceled by the server.", ex.Message); 425Assert.Equal("GetClientResult", invocation.Target); 430Assert.Equal("Invocation canceled by the server.", ex.Message); 465Assert.Equal("s1", invocationMessage.InvocationId); 472Assert.Equal(invocationId, completion.InvocationId); 507Assert.Equal(invocationId, streamItem.InvocationId); 510Assert.Equal(invocationId, completionMessage.InvocationId);

HubConnectionHandlerTests.cs (81)

HubConnectionHandlerTestUtils\Utils.cs (2)

34Assert.Equal(expectedCompletion.Error, actualCompletion.Error); 48Assert.Equal(expectedInvocation.Target, actualInvocation.Target);

HubFilterTests.cs (3)

639Assert.Equal("Failed to invoke 'Method' due to an error on the server. HubException: Method does not exist.", message.Error); 670Assert.Equal("Failed to invoke 'Method' due to an error on the server. HubException: Method does not exist.", message.Error); 891Assert.Equal("An unexpected error occurred invoking 'Echo' on the server. HubException: Unknown hub method 'BaseMethod'", message.Error);

Internal\DefaultHubProtocolResolverTests.cs (1)

62Assert.Equal("protocolName", exception.ParamName);

Internal\TypedClientBuilderTests.cs (18)

24Assert.Equal("Method", send.Method); 48Assert.Equal("Method", send.Method); 75Assert.Equal("Method", send1.Method); 85Assert.Equal("SubMethod", send2.Method); 112Assert.Equal("Method", send1.Method); 121Assert.Equal("NoArgumentMethod", send2.Method); 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); 176Assert.Equal( 185Assert.Equal( 194Assert.Equal("Type must not contain properties.", ex.Message); 202Assert.Equal("Type must not contain events.", ex.Message); 218Assert.Equal("GetValue", send.Method); 260Assert.Equal("MethodReturning", send1.Method); 269Assert.Equal("NoArgumentMethodReturning", send2.Method);

MapSignalRTests.cs (22)

SerializedHubMessageTests.cs (1)

87Assert.Equal("test", serializedMessage.ProtocolName);

UserAgentHeaderTest.cs (1)

19Assert.Equal(testData.Expected, Constants.ConstructUserAgent(testData.Version, testData.DetailedVersion, testData.Os, testData.Runtime, testData.RuntimeVersion));

WebSocketsTransportTests.cs (1)

152Assert.Equal("XMLHttpRequest", headerValue);

SpaProxyTests.cs (1)

59Assert.Equal(expected, forwardedRequestMessage.RequestUri.ToString());

SpaServicesExtensionsTests.cs (1)

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

StaticAssetsIntegrationTests.cs (19)

64Assert.Equal($"\"{GetEtag("Hello, World!")}\"", response.Headers.ETag.Tag); 66Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 67Assert.Equal("Hello, World!", await response.Content.ReadAsStringAsync()); 114Assert.Equal($"\"{GetEtag("Hello, World!")}\"", response.Headers.ETag.Tag); 116Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 117Assert.Equal("Hello, World!", await response.Content.ReadAsStringAsync()); 166Assert.Equal($"\"{GetEtag("Hello, World!")}\"", response.Headers.ETag.Tag); 168Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 169Assert.Equal("Hello, World!", await response.Content.ReadAsStringAsync()); 170Assert.Equal("immutable", response.Headers.CacheControl.ToString()); 335Assert.Equal($"\"3/1gIbsr1bCvZ2KQgJ7DpTGR3YHH9wpLKGiKNiGCmG8=\"", response.Headers.ETag.Tag); 337Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 338Assert.Equal("Hello, World!", await response.Content.ReadAsStringAsync()); 388Assert.Equal($"\"+fvSyRQcr4/t/rcA0u1KfZ8c3CpXxBDxsxDhnAftNqg=\"", response.Headers.ETag.Tag); 390Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 391Assert.Equal("Hello, World! Modified", await response.Content.ReadAsStringAsync()); 444Assert.Equal(GetGzipEtag(Path.Combine(webRoot, "sample.txt")), response.Headers.ETag.Tag); 446Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 451Assert.Equal("Hello, World! Modified", content);

FallbackStaticFileTest.cs (2)

63Assert.Equal("Hello, world!", responseText); 112Assert.Equal("Hello, world!", responseText);

StaticFileMiddlewareTests.cs (3)

86Assert.Equal("Hi from endpoint.", await response.Content.ReadAsStringAsync()); 163Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 205Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());

DefaultContentTypeProviderTests.cs (6)

21Assert.Equal("text/plain", contentType); 37Assert.Equal("video/x-ms-dvr", contentType); 45Assert.Equal("text/plain", contentType); 47Assert.Equal("text/plain", contentType); 55Assert.Equal("text/plain", contentType); 57Assert.Equal("text/plain", contentType);

DefaultFilesMiddlewareTests.cs (5)

76Assert.Equal(requestUrl, await response.Content.ReadAsStringAsync()); // Should not be modified 119Assert.Equal("/SubFolder/", await response.Content.ReadAsStringAsync()); // Should not be modified 161Assert.Equal("/SubFolder/default.html", responseContent); // Should be modified and be valid path to file 226Assert.Equal(requestUrlWithSlash + "default.html", await response.Content.ReadAsStringAsync()); // Should be modified and be valid path to file 268Assert.Equal("http://localhost" + baseUrl + new PathString(requestUrl + "/") + queryString, actualURL);

DirectoryBrowserMiddlewareTests.cs (5)

134Assert.Equal("Hi from endpoint.", await response.Content.ReadAsStringAsync()); 171Assert.Equal("text/html; charset=utf-8", response.Content.Headers.ContentType.ToString()); 228Assert.Equal("text/html; charset=utf-8", response.Content.Headers.ContentType.ToString()); 272Assert.Equal("http://localhost" + requestUrl + "/" + queryString, response.Headers.GetValues("Location").FirstOrDefault()); 371Assert.Equal("text/html; charset=utf-8", response.Content.Headers.ContentType.ToString());

RangeHeaderTests.cs (28)

StaticFileMiddlewareTests.cs (8)

190Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 229Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 271Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 321Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 364Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString()); 412Assert.Equal("text/customfortest+plain", response.Content.Headers.ContentType.ToString()); 413Assert.Equal(responseText, responseContent); 482Assert.Equal("text/plain", response.Content.Headers.ContentType.ToString());

ClientHandlerTests.cs (39)

HttpContextBuilderTests.cs (23)

31Assert.Equal(HttpProtocol.Http11, context.Request.Protocol); 32Assert.Equal("POST", context.Request.Method); 33Assert.Equal("https", context.Request.Scheme); 34Assert.Equal("example.com", context.Request.Host.Value); 35Assert.Equal("/A/Path", context.Request.PathBase.Value); 36Assert.Equal("/and/file.txt", context.Request.Path.Value); 37Assert.Equal("?and=query", context.Request.QueryString.Value); 60Assert.Equal(userAgent, actualResult); 73Assert.Equal("", context.Request.PathBase.Value); 74Assert.Equal("/", context.Request.Path.Value); 91Assert.Equal("TestValue", context.Response.Headers["TestHeader"]); 137Assert.Equal("TestValue", context.Response.Headers["TestHeader"]); 139Assert.Equal("BodyStarted", reader.ReadLine()); 141Assert.Equal("BodyFinished", reader.ReadToEnd()); 161Assert.Equal("TestValue", context.Response.Headers["TestHeader"]); 163Assert.Equal("BodyStarted", await reader.ReadLineAsync()); 165Assert.Equal("BodyFinished", await reader.ReadToEndAsync()); 185Assert.Equal("TestValue", context.Response.Headers["TestHeader"]); 187Assert.Equal("BodyFinished", new StreamReader(context.Response.Body).ReadToEnd()); 207Assert.Equal("TestValue", context.Response.Headers["TestHeader"]); 256Assert.Equal("TestValue", context.Response.Headers["TestHeader"]); 297Assert.Equal("TestValue", context.Response.Headers["TestHeader"]); 344Assert.Equal("The application aborted the request.", ex.Message);

RequestBuilderTests.cs (2)

19Assert.Equal("MyHost:90", request.Headers.Host.ToString()); 33Assert.Equal("Test/Value", request.Content.Headers.ContentType.ToString());

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

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

37Assert.Equal(expected, actual); 47Assert.Equal("", ctx.Request.PathBase.Value); 48Assert.Equal("/", ctx.Request.Path.Value); 59Assert.Equal(expected, actual); 69Assert.Equal("", ctx.Request.PathBase.Value); 70Assert.Equal("/", ctx.Request.Path.Value); 81Assert.Equal(expected, actual); 102Assert.Equal("Hello world PUT Response", await response.Content.ReadAsStringAsync().DefaultTimeout()); 120Assert.Equal("Hello world POST Response", await response.Content.ReadAsStringAsync().DefaultTimeout()); 219Assert.Equal("STARTED", Encoding.UTF8.GetString(buffer, 0, length)); 228Assert.Equal("Hello world POST Response", Encoding.UTF8.GetString(buffer, 0, length)); 257Assert.Equal("HttpContent exception", ex.Message); 282Assert.Equal("SENT", Encoding.UTF8.GetString(serverBuffer, 0, serverLength)); 379Assert.Equal("POST Response", Encoding.UTF8.GetString(buffer, 0, length)); 438Assert.Equal("true", response.Headers.GetValues("test-header").Single()); 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); 485Assert.Equal("true", response.Headers.GetValues("test-header").Single()); 688Assert.Equal("Normal Closure", result.CloseStatusDescription); 690Assert.Equal("charlie", clientSocket.SubProtocol); 959Assert.Equal(expected, actual); 961Assert.Equal(protocol, HttpProtocol.Http11); 986Assert.Equal(expected, actual); 988Assert.Equal(protocol, HttpProtocol.Http2); 1013Assert.Equal(expected, actual); 1015Assert.Equal(protocol, HttpProtocol.Http3); 1044Assert.Equal("test", actual);

TestServerTests.cs (17)

134Assert.Equal("OverridesConfigureServices, OverridesConfigureContainer", response); 204Assert.Equal("RequestServices:True", result); 227Assert.Equal("Hello World", await response.Content.ReadAsStringAsync()); 256Assert.Equal("ApplicationServicesEqual:True", result); 441Assert.Equal("Found:True", result); 463Assert.Equal("Success", result); 511Assert.Equal("Success", result); 552Assert.Equal("Success", result); 569Assert.Equal("FoundLogger:True", result); 590Assert.Equal("HasContext:True", result); 622Assert.Equal("HasContext:True", result); 638Assert.Equal("CreateInvokesApp", result); 656Assert.Equal("Response", await result.Content.ReadAsStringAsync()); 704Assert.Equal("FoundService:True", await result.Content.ReadAsStringAsync()); 717Assert.Equal("FoundFoo:False", await result.Content.ReadAsStringAsync()); 743Assert.Equal("Hello World", result); 796Assert.Equal("otherhost:5678", responseBody);

WebSocketClientTests.cs (3)

51Assert.Equal("http", capturedScheme); 52Assert.Equal(expectedHost, capturedHost); 53Assert.Equal("/connect", capturedPath);

FakeCertificateFactoryTests.cs (2)

19Assert.Equal("CN=dotnet-extensions-self-signed-unit-test-certificate", certificate.SubjectName.Name); 20Assert.Equal("localhost", certificate.GetNameInfo(X509NameType.DnsFromAlternativeName, false));

FakesExtensionsTests.cs (7)

101Assert.Equal(_urlAddresses[0], client.BaseAddress?.AbsoluteUri); 112Assert.Equal("No suitable address found to call the server.", exception.Message); 123Assert.Equal("No suitable address found to call the server.", exception.Message); 152Assert.Equal(_urlAddresses[1], client.BaseAddress?.AbsoluteUri); 220address => Assert.Equal(address.AbsoluteUri, _urlAddresses[0]), 221address => Assert.Equal(address.AbsoluteUri, _urlAddresses[1]), 222address => Assert.Equal(address.AbsoluteUri, _urlAddresses[2]));

WebApplicationTests.cs (165)

WebHostTests.cs (2)

26Assert.Equal("http://localhost:5001", builder.GetSetting(WebHostDefaults.ServerUrlsKey)); 74Assert.Equal("https", context.Request.Scheme);

AddWebSocketsTests.cs (1)

30Assert.Equal("someString", socketOptions.AllowedOrigins[0]);

HandshakeTests.cs (3)

17Assert.Equal(expectedResponse, response); 54Assert.Equal(expectedResponse, response); 72Assert.Equal(expectedResponse, response);

SendReceiveTests.cs (2)

25Assert.Equal(message, Encoding.UTF8.GetString(receiveBuffer, 0, result.Count)); 42Assert.Equal(message, Encoding.UTF8.GetString(receiveBuffer, 0, result.Count));

WebSocketCompressionMiddlewareTests.cs (2)

41Assert.Equal("permessage-deflate; server_no_context_takeover", response.Headers.GetValues(HeaderNames.SecWebSocketExtensions).Aggregate((l, r) => $"{l}; {r}")); 103Assert.Equal(expectedResponse, response.Headers.GetValues(HeaderNames.SecWebSocketExtensions).Aggregate((l, r) => $"{l}; {r}"));

WebSocketMiddlewareTests.cs (9)

40Assert.Equal("alpha, bravo, charlie", context.Request.Headers["Sec-WebSocket-Protocol"]); 358Assert.Equal(closeDescription, result.CloseStatusDescription); 392Assert.Equal(closeDescription, result.CloseStatusDescription); 414Assert.Equal(closeDescription, result.CloseStatusDescription); 444Assert.Equal(closeDescription, result.CloseStatusDescription); 478Assert.Equal(closeDescription, result.CloseStatusDescription); 490Assert.Equal(closeDescription, result.CloseStatusDescription); 748Assert.Equal("Upgrade, keep-alive", context.Request.Headers.Connection.ToString()); 749Assert.Equal("websocket, example", context.Request.Headers.Upgrade.ToString());

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

FormReaderTests.cs (24)

20Assert.Equal("bar", formCollection[""].ToString()); 32Assert.Equal("bar", formCollection[""].ToString()); 33Assert.Equal("2", formCollection["baz"].ToString()); 45Assert.Equal("", formCollection["foo"].ToString()); 57Assert.Equal("", formCollection["foo"].ToString()); 58Assert.Equal("2", formCollection["baz"].ToString()); 70Assert.Equal("1", formCollection["foo"].ToString()); 71Assert.Equal("2", formCollection["bar"].ToString()); 72Assert.Equal("3", formCollection["baz"].ToString()); 85Assert.Equal("Form value count limit 3 exceeded.", exception.Message); 97Assert.Equal("Form value count limit 3 exceeded.", exception.Message); 109Assert.Equal("1", formCollection["foo"].ToString()); 110Assert.Equal("2", formCollection["bar"].ToString()); 111Assert.Equal("3,4", formCollection["baz"].ToString()); 124Assert.Equal("Form key or value length limit 10 exceeded.", exception.Message); 136Assert.Equal("1", formCollection["foo"].ToString()); 137Assert.Equal("1234567890", formCollection["bar"].ToString()); 138Assert.Equal("3,4", formCollection["baz"].ToString()); 151Assert.Equal("Form key or value length limit 10 exceeded.", exception.Message); 165Assert.Equal("foo", pair.Key); 166Assert.Equal("", pair.Value); 170Assert.Equal("baz", pair.Key); 171Assert.Equal("2", pair.Value); 202Assert.Equal(expectedValue, form[key]);

HttpRequestStreamReaderTest.cs (10)

65Assert.Equal(expected, actual); 158Assert.Equal(valueString.Substring(0, valueString.IndexOf('\r')), data); 161Assert.Equal(valueString.Substring(valueString.IndexOf('\r') + 1, 3), data); 164Assert.Equal(valueString.Substring(valueString.IndexOf('\n') + 1, 2), data); 167Assert.Equal((valueString.Substring(valueString.LastIndexOf('\n') + 1)), data); 184Assert.Equal(valueString.Substring(1, valueString.IndexOf('\r') - 1), data); 204Assert.Equal(string.Empty, data); 226Assert.Equal("123456789", data); 229Assert.Equal("foo", data); 263Assert.Equal(string.Empty, empty);

HttpResponseStreamWriterTest.cs (1)

727Assert.Equal(content, actualContent);

MultipartReaderTests.cs (35)

QueryHelpersTests.cs (14)

EditorConfig_Tests.cs (37)

CommandLineSwitches_Tests.cs (35)

Construction\ConstructionEditing_Tests.cs (1)

2357Assert.Equal("m1", metadatum.EvaluatedValue);

Construction\ElementLocationPublic_Tests.cs (6)

35Assert.Equal(project.FullPath, target.Location.File); 36Assert.Equal(project.FullPath, target.OutputsLocation.File); 52Assert.Equal(project.FullPath, target.Location.File); 53Assert.Equal(project.FullPath, target.OutputsLocation.File); 57Assert.Equal(project.FullPath, target.Location.File); 58Assert.Equal(project.FullPath, target.OutputsLocation.File);

Construction\ProjectChooseElement_Tests.cs (4)

226Assert.Equal("c1", whens[0].Condition); 227Assert.Equal("c2", whens[1].Condition); 280Assert.Equal("v1", project.GetPropertyValue("p")); 284Assert.Equal(String.Empty, project.GetPropertyValue("p"));

Construction\ProjectExtensionsElement_Tests.cs (8)

38Assert.Equal(@"<a />", extensions.Content); 88Assert.Equal(@"a<b />c", extensions.Content); 125Assert.Equal(String.Empty, content); 128Assert.Equal("y", extensions["b"]); 151Assert.Equal("y", content); 154Assert.Equal(String.Empty, content); 177Assert.Equal("z", extensions["c"]); 200Assert.Equal("y2", extensions["b"]);

Construction\ProjectImportElement_Tests.cs (8)

104Assert.Equal("i1.proj", imports[0].Project); 105Assert.Equal("i2.proj", imports[1].Project); 106Assert.Equal("c", imports[1].Condition); 127Assert.Equal("i1b.proj", import.Project); 183Assert.Equal("v1", project.GetPropertyValue("p")); 187Assert.Equal("v2", project.GetPropertyValue("p")); 222Assert.Equal("v1", project.GetPropertyValue("p")); 226Assert.Equal(String.Empty, project.GetPropertyValue("p"));

Construction\ProjectImportGroupElement_Tests.cs (11)

273Assert.Equal("i1.proj", imports[0].Project); 274Assert.Equal("i2.proj", imports[1].Project); 275Assert.Equal("c", imports[1].Condition); 305Assert.Equal("second", importGroups[1].Label); 308Assert.Equal("i1.proj", imports[0].Project); 309Assert.Equal("i2.proj", imports[1].Project); 310Assert.Equal("c", imports[1].Condition); 311Assert.Equal("i3.proj", imports[2].Project); 336Assert.Equal("i1b.proj", import.Project); 378Assert.Equal("c", importGroup.Condition); 395Assert.Equal("c", importGroup.Label);

Construction\ProjectItemDefinitionElement_Tests.cs (11)

63Assert.Equal("i", definition.ItemType); 65Assert.Equal("m1", Helpers.GetFirst(definition.Metadata).Name); 66Assert.Equal("v1", Helpers.GetFirst(definition.Metadata).Value); 115Assert.Equal("m1", metadata[0].Name); 116Assert.Equal("v1", metadata[0].Value); 117Assert.Equal("m2", metadata[1].Name); 118Assert.Equal("v2", metadata[1].Value); 119Assert.Equal("c", metadata[1].Condition); 120Assert.Equal("m1", metadata[2].Name); 121Assert.Equal("v3", metadata[2].Value); 212Assert.Equal("c", itemDefinition.Condition);

Construction\ProjectItemDefinitionGroupElement_Tests.cs (3)

92Assert.Equal("c", itemDefinitionGroups[0].Condition); 108Assert.Equal("c", itemDefinitionGroup.Condition); 125Assert.Equal("c", itemDefinitionGroup.Label);

Construction\ProjectItemElement_Tests.cs (36)

363Assert.Equal("i1", items[0].ItemType); 364Assert.Equal("i", items[0].Include); 368Assert.Equal("m1", metadata1[0].Name); 369Assert.Equal("v1", metadata1[0].Value); 372Assert.Equal("i2", items[1].ItemType); 373Assert.Equal("i", items[1].Include); 374Assert.Equal("j", items[1].Exclude); 376Assert.Equal("m2", metadata2[0].Name); 377Assert.Equal("v2", metadata2[0].Value); 417Assert.Equal("m1", metadata[0].Name); 418Assert.Equal("v1", metadata[0].Value); 419Assert.Equal("m2", metadata[1].Name); 420Assert.Equal("v2", metadata[1].Value); 421Assert.Equal("c", metadata[1].Condition); 422Assert.Equal("m1", metadata[2].Name); 423Assert.Equal("v3", metadata[2].Value); 599Assert.Equal("i", item.Remove); 612Assert.Equal("i", item.Update); 639Assert.Equal("i1", item.Include); 640Assert.Equal("i2", item.Exclude); 655Assert.Equal("ib", item.Include); 670Assert.Equal(String.Empty, item.Include); 685Assert.Equal(String.Empty, item.Include); 700Assert.Equal("ib", item.Exclude); 715Assert.Equal(String.Empty, item.Exclude); 730Assert.Equal(String.Empty, item.Exclude); 777Assert.Equal("ib", item.Remove); 792Assert.Equal(String.Empty, item.Remove); 807Assert.Equal(String.Empty, item.Remove); 871Assert.Equal("ib", item.Update); 886Assert.Equal(String.Empty, item.Update); 901Assert.Equal(String.Empty, item.Update); 948Assert.Equal("c", item.Condition); 980Assert.Equal("i2", Helpers.GetFirst(project.Items).EvaluatedInclude); 1015Assert.Equal("i2", item.Remove); 1035Assert.Equal("i2", item.Update);

Construction\ProjectItemGroupElement_tests.cs (4)

71Assert.Equal("i1", items[0].Include); 72Assert.Equal("i2", items[1].Include); 88Assert.Equal("c", itemGroup.Condition); 105Assert.Equal("c", itemGroup.Label);

Construction\ProjectMetadataElement_Tests.cs (43)

Construction\ProjectOnErrorElement_Tests.cs (9)

28Assert.Equal("t", onError.ExecuteTargetsAttribute); 29Assert.Equal("c", onError.Condition); 57Assert.Equal("1", onError1.ExecuteTargetsAttribute); 58Assert.Equal("2", onError2.ExecuteTargetsAttribute); 84Assert.Equal(String.Empty, onError.ExecuteTargetsAttribute); 110Assert.Equal(String.Empty, onError.ExecuteTargetsAttribute); 223Assert.Equal("t2", onError.ExecuteTargetsAttribute); 266Assert.Equal("c", onError.Condition); 284Assert.Equal("et2", onError.ExecuteTargetsAttribute);

Construction\ProjectOutputElement_Tests.cs (9)

30Assert.Equal("p", output.TaskParameter); 31Assert.Equal(String.Empty, output.PropertyName); 32Assert.Equal("i1", output.ItemType); 45Assert.Equal("p", output.TaskParameter); 46Assert.Equal("p1", output.PropertyName); 47Assert.Equal(String.Empty, output.ItemType); 216Assert.Equal("c", output.Condition); 230Assert.Equal("p1b", output.PropertyName); 257Assert.Equal("p1b", output.ItemType);

Construction\ProjectPropertyElement_Tests.cs (11)

28Assert.Equal("p", property.Name); 29Assert.Equal("v", property.Value); 30Assert.Equal("c", property.Condition); 52Assert.Equal("p", property.Name); 53Assert.Equal(@"A<B>C<D /></B>E", property.Value); 163Assert.Equal("vb", property.Value); 179Assert.Equal("v1", property.Value); 192Assert.Equal("p2", property.Name); 206Assert.Equal("p", property.Name); 233Assert.Equal(String.Empty, property.Value); 261Assert.Equal("c", property.Condition);

Construction\ProjectPropertyGroupElement_Tests.cs (4)

69Assert.Equal("p1", properties[0].Name); 70Assert.Equal("p2", properties[1].Name); 86Assert.Equal("c", propertyGroup.Condition); 103Assert.Equal("c", propertyGroup.Label);

Construction\ProjectRootElement_Tests.cs (31)

109Assert.Equal(string.Empty, project.DefaultTargets); 110Assert.Equal(string.Empty, project.InitialTargets); 111Assert.Equal(ObjectModelHelpers.MSBuildDefaultToolsVersion, project.ToolsVersion); 124Assert.Equal("dt", project.DefaultTargets); 137Assert.Equal("it", project.InitialTargets); 150Assert.Equal("tv", project.ToolsVersion); 163Assert.Equal(project.FullPath, Path.Combine(Directory.GetCurrentDirectory(), "X")); 384Assert.Equal("MSB4041", ex.ErrorCode); 512Assert.Equal(string.Empty, root1.DefaultTargets); 513Assert.Equal(string.Empty, root2.DefaultTargets); 645Assert.Equal(path, project.FullPath); 646Assert.Equal(directory, project.DirectoryPath); 677Assert.Equal(path, project.FullPath); 678Assert.Equal(directory, project.DirectoryPath); 834Assert.Equal("q", properties[1].Name); 835Assert.Equal("r1", properties[2].Value); 836Assert.Equal("t1", properties[5].Value); 892Assert.Equal("j", items[1].ItemType); 893Assert.Equal("k1", items[2].Include); 894Assert.Equal("k4", items[5].Include); 1696(initial, reload, actualFile) => { Assert.Equal(String.Empty, actualFile); }); 1705(initial, reload, actualFile) => { Assert.Equal(initial, actualFile); }); 1714(initial, reload, actualFile) => { Assert.Equal(reload, actualFile); }); 1723(initial, reload, actualFile) => { Assert.Equal(reload, actualFile); }); 1775Assert.Equal(NativeMethodsShared.GetCurrentDirectory(), rootElement.DirectoryPath); 1894Assert.Equal(xml, projectElement.RawXml); 1905Assert.Equal(pre.RawXml, pre2.RawXml); 1910Assert.Equal(pre.RawXml, pre3.RawXml); 1932Assert.Equal(expected, actual); // "The encoding was not emitted as an XML declaration." 1941Assert.Equal(encoding.EncodingName, project.Encoding.EncodingName); 1955Assert.Equal(encoding.WebName, project.Encoding.WebName);

Construction\ProjectTargetElement_Tests.cs (19)

75Assert.Equal("i", target.Inputs); 76Assert.Equal("o", target.Outputs); 77Assert.Equal("d", target.DependsOnTargets); 78Assert.Equal("c", target.Condition); 94Assert.Equal("ib", target.Inputs); 95Assert.Equal("ob", target.Outputs); 96Assert.Equal("db", target.DependsOnTargets); 97Assert.Equal("cb", target.Condition); 157Assert.Equal(String.Empty, target.Condition); 209Assert.Equal("t1", task1.Name); 210Assert.Equal("t2", task2.Name); 225Assert.Equal("t2", target.Name); 241Assert.Equal("in", target.Inputs); 257Assert.Equal("out", target.Outputs); 273Assert.Equal("dot", target.DependsOnTargets); 289Assert.Equal("c", target.Condition); 305Assert.Equal("true", target.KeepDuplicateOutputs); 322Assert.Equal("@(a)", target.Returns); 329Assert.Equal(String.Empty, target.Returns);

Construction\ProjectTaskElement_Tests.cs (12)

36Assert.Equal("t1", task.Name); 39Assert.Equal(String.Empty, task.ContinueOnError); 58Assert.Equal("coe", task.ContinueOnError); 77Assert.Equal("c", task.Condition); 143Assert.Equal("v1", parameters["p1"]); 144Assert.Equal("v2", parameters["p2"]); 146Assert.Equal("v1", task.GetParameter("p1")); 147Assert.Equal(String.Empty, task.GetParameter("xxxx")); 162Assert.Equal("v1b", parameters["p1"]); 230Assert.Equal("v2", parameters["p2"]); 278Assert.Equal("true", task.ContinueOnError); 293Assert.Equal("c", task.Condition);

Construction\ProjectUsingTaskElement_Tests.cs (18)

192Assert.Equal("t1", usingTask.TaskName); 193Assert.Equal("af", usingTask.AssemblyFile); 194Assert.Equal(String.Empty, usingTask.AssemblyName); 195Assert.Equal(String.Empty, usingTask.Condition); 206Assert.Equal("t2", usingTask.TaskName); 207Assert.Equal(String.Empty, usingTask.AssemblyFile); 208Assert.Equal("an", usingTask.AssemblyName); 209Assert.Equal("c", usingTask.Condition); 220Assert.Equal("t2", usingTask.TaskName); 221Assert.Equal(String.Empty, usingTask.AssemblyFile); 222Assert.Equal("an", usingTask.AssemblyName); 223Assert.Equal("c", usingTask.Condition); 224Assert.Equal("AssemblyFactory", usingTask.TaskFactory); 253Assert.Equal("afb", usingTask.AssemblyFile); 267Assert.Equal("anb", usingTask.AssemblyName); 308Assert.Equal("tt", usingTask.TaskName); 323Assert.Equal("c", usingTask.Condition); 338Assert.Equal("AssemblyFactory", usingTask.TaskFactory);

Construction\SolutionFile_Tests.cs (69)

Construction\UsingTaskBodyElement_Tests.cs (4)

29Assert.Equal("Contents", body.TaskBody); 81Assert.Equal("MoreContents", body.TaskBody); 95Assert.Equal(String.Empty, body.TaskBody); 122Assert.Equal(bool.TrueString, body.Evaluate);

Construction\UsingTaskParameterElement_Tests.cs (17)

54Assert.Equal("MyParameter", parameter.Name); 55Assert.Equal("System.String", parameter.ParameterType); 56Assert.Equal("true", parameter.Output); 57Assert.Equal("false", parameter.Required); 68Assert.Equal("MyParameter", parameter.Name); 69Assert.Equal(typeof(String).FullName, parameter.ParameterType); 70Assert.Equal(bool.FalseString, parameter.Output); 71Assert.Equal(bool.FalseString, parameter.Required); 106Assert.Equal("newType", parameter.ParameterType); 120Assert.Equal("output", parameter.Output); 134Assert.Equal("required", parameter.Required); 148Assert.Equal(typeof(String).FullName, parameter.ParameterType); 162Assert.Equal(bool.FalseString, parameter.Output); 176Assert.Equal(bool.FalseString, parameter.Required); 190Assert.Equal(typeof(String).FullName, parameter.ParameterType); 204Assert.Equal(bool.FalseString, parameter.Output); 218Assert.Equal(bool.FalseString, parameter.Required);

Definition\DefinitionEditing_Tests.cs (64)

Definition\EditingElementsReferencedByOrReferences_Tests.cs (10)

52Assert.Equal("Y", items.First().EvaluatedInclude); // "Wrong evaluated include after changing type" 138Assert.Equal("A;B;C", item1.GetMetadataValue("M")); // "Invalid metadata at start" 141Assert.Equal("A;D", item2.GetMetadataValue("M")); // "Invalid metadata at start" 211Assert.Equal("A;B", item1.GetMetadataValue("M")); // "Invalid metadata after first removal" 213Assert.Equal("A;D", item2.GetMetadataValue("M")); // "Invalid metadata after first removal" 265Assert.Equal("A;B", item1.GetMetadataValue("M")); // "Invalid metadata after second removal" 267Assert.Equal("A", item2.GetMetadataValue("M")); // "Invalid metadata after second removal" 287Assert.Equal("m", item.GetMetadataValue("N")); // "Wrong metadata value at startup" 305Assert.Equal("%(I.M)", metadata.UnevaluatedValue); // "Unevaluated value is wrong" 306Assert.Equal(String.Empty, metadata.EvaluatedValue); // "Evaluated value is wrong"

Definition\ProjectCollection_Tests.cs (25)

Definition\ProjectItem_Tests.cs (174)

Definition\ProjectItemDefinition_Tests.cs (13)

70Assert.Equal("v", Helpers.GetFirst(project.GetItems("i")).GetMetadataValue("m")); 109Assert.Equal("m", metadataList[0].Name); 110Assert.Equal("m0", metadataList[0].EvaluatedValue); 249Assert.Equal("b", item.GetMetadataValue("m")); 276Assert.Equal("b.ext", item.GetMetadataValue("m")); 303Assert.Equal("b.l1", item.GetMetadataValue("m")); 334Assert.Equal("b.n1", item.GetMetadataValue("m")); 363Assert.Equal("%25(filename)", Project.GetMetadataValueEscaped(item, "m")); 364Assert.Equal("%(filename)", item.GetMetadataValue("m")); 392Assert.Equal(".bar", item.GetMetadataValue("m")); 420Assert.Equal(".foo", item.EvaluatedInclude); 460Assert.Equal("n1", item1.GetMetadataValue("n")); 463Assert.Equal("", item2.GetMetadataValue("n"));

Definition\ProjectMetadata_Tests.cs (31)

Definition\ProjectProperty_Tests.cs (19)

Definition\ProtectImports_Tests.cs (10)

154Assert.Equal(NewValue, project.GetPropertyValue(PropertyName)); 260Assert.Equal(NewValue, item.EvaluatedInclude); // "Item in project didn't change name." 274Assert.Equal(NewValue, item.EvaluatedInclude); // "Item in project didn't change name." 366Assert.Equal(NewValue, item.GetMetadataValue(ProjectMetadataName)); // "Metadata not saved correctly in project." 381Assert.Equal(NewValue, item.GetMetadataValue(newName)); // "Metadata not saved correctly in project." 397Assert.Equal(newValue, metadata.EvaluatedValue); 459Assert.Equal(NewValue, item.GetMetadataValue(OverridableMetadataName)); // "Metadata not set correctly in project." 473Assert.Equal(NewValue, metadata.EvaluatedValue); 529Assert.Equal(_importFilename, item.Xml.ContainingProject.FullPath); // "Item was not found in the imported project." 620Assert.Equal(_importFilename, property.Xml.ContainingProject.FullPath); // "Property was not found in the imported project."

Instance\ProjectInstance_Tests.cs (34)

54Assert.Equal("v1", p.GetPropertyValue("p1")); 55Assert.Equal("v2X", p.GetPropertyValue("p2")); 68Assert.Equal("i", items[0].ItemType); 69Assert.Equal("i0", items[0].EvaluatedInclude); 70Assert.Equal(String.Empty, items[0].GetMetadataValue("m")); 72Assert.Equal("i1", items[1].EvaluatedInclude); 73Assert.Equal("m1", items[1].GetMetadataValue("m")); 74Assert.Equal("m1", items[1].GetMetadata("m").EvaluatedValue); 75Assert.Equal("v1", items[2].EvaluatedInclude); 88Assert.Equal("i", returned.ItemType); 89Assert.Equal("i1", returned.EvaluatedInclude); 94Assert.Equal("i1", item.EvaluatedInclude); 109Assert.Equal("i", returned.ItemType); 110Assert.Equal("i;1", returned.EvaluatedInclude); 115Assert.Equal("i;1", item.EvaluatedInclude); 140Assert.Equal("i1", item.EvaluatedInclude); 143Assert.Equal("m1", item.GetMetadataValue("m")); 144Assert.Equal("n1", item.GetMetadataValue("n")); 145Assert.Equal("o@", item.GetMetadataValue("o")); 209Assert.Equal("p2", instance.GetPropertyValue("p")); 214Assert.Equal("", instance.GetPropertyValue("p")); 242Assert.Equal("v1b", first.GetPropertyValue("p1")); 243Assert.Equal("v1", second.GetPropertyValue("p1")); 266Assert.Equal("i1", Helpers.MakeList(project.GetItems("j"))[0].EvaluatedInclude); 267Assert.Equal("m1", Helpers.MakeList(project.GetItems("j"))[0].GetMetadataValue("m")); 268Assert.Equal("n;;", Helpers.MakeList(project.GetItems("j"))[0].GetMetadataValue("n")); 310Assert.Equal(file1, Helpers.MakeList(projectInstance.GetItems("i"))[0].EvaluatedInclude); 311Assert.Equal(file2, Helpers.MakeList(projectInstance.GetItems("i"))[1].EvaluatedInclude); 431Assert.Equal(projB.FullPath, projBInstanceItem.GetMetadataValue(CapturedMetadataName)); 432Assert.Equal(projA.FullPath, projAInstanceItem.GetMetadataValue(CapturedMetadataName)); 473Assert.Equal(projB.FullPath, projBInstanceItem.GetMetadataValue(CapturedMetadataName)); 474Assert.Equal(projA.FullPath, projAInstanceItem.GetMetadataValue(CapturedMetadataName)); 515Assert.Equal(projA.FullPath, projAInstanceItem.GetMetadataValue(CapturedMetadataName)); 516Assert.Equal(projB.FullPath, projBInstanceItem.GetMetadataValue(CapturedMetadataName));

Instance\ProjectItemInstance_Tests.cs (80)

Instance\ProjectMetadataInstance_Tests.cs (2)

25Assert.Equal("m", metadata.Name); 26Assert.Equal("m1", metadata.EvaluatedValue);

Instance\ProjectOnErrorInstance_Tests.cs (2)

28Assert.Equal("et", onError.ExecuteTargets); 29Assert.Equal("c", onError.Condition);

Instance\ProjectPropertyInstance_Tests.cs (5)

26Assert.Equal("p", property.Name); 27Assert.Equal("v1", property.EvaluatedValue); 38Assert.Equal("v2", property.EvaluatedValue); 49Assert.Equal("v!2", property.EvaluatedValue); 60Assert.Equal(String.Empty, property.EvaluatedValue);

Instance\ProjectTargetInstance_Tests.cs (15)

29Assert.Equal("t", target.Name); 30Assert.Equal("c", target.Condition); 31Assert.Equal("i", target.Inputs); 32Assert.Equal("o", target.Outputs); 33Assert.Equal("d", target.DependsOnTargets); 34Assert.Equal("b", target.BeforeTargets); 35Assert.Equal("a", target.AfterTargets); 36Assert.Equal("k", target.KeepDuplicateOutputs); 37Assert.Equal("r", target.Returns); 38Assert.Equal("t1", ((ProjectTaskInstance)target.Children[0]).Name); 42Assert.Equal("t1", tasks[0].Name); 61Assert.Equal("i2", target.Inputs); 81Assert.Equal("i2", target.Inputs); 101Assert.Equal("i2", target.Inputs); 124Assert.Equal(project.FullPath, target.FullPath);

Instance\ProjectTaskInstance_Tests.cs (5)

28Assert.Equal("t1", task.Name); 29Assert.Equal("c", task.Condition); 30Assert.Equal("coe", task.ContinueOnError); 34Assert.Equal("a1", parameters["a"]); 35Assert.Equal("b1", parameters["b"]);

Instance\ProjectTaskOutputItemInstance_Tests.cs (3)

28Assert.Equal("p", output.TaskParameter); 29Assert.Equal("c", output.Condition); 30Assert.Equal("i", output.ItemType);

Instance\ProjectTaskOutputPropertyInstance_Tests.cs (3)

28Assert.Equal("p", output.TaskParameter); 29Assert.Equal("c", output.Condition); 30Assert.Equal("p1", output.PropertyName);

ObjectModelRemoting\Helpers\ViewValidation.construction.cs (62)

ObjectModelRemoting\Helpers\ViewValidation.cs (6)

73Assert.Equal(current, getter(this.View)); 80Assert.Equal(newValue1, getter(this.View)); 81Assert.Equal(newValue1, getter(this.Real)); 86Assert.Equal(newValue, getter(this.View)); 87Assert.Equal(newValue, getter(this.Real)); 292Assert.Equal(md.Value, getMetadata(md.Key));

ObjectModelRemoting\Helpers\ViewValidation.evaluation.cs (29)

ObjectModelRemoting\LinkedConstructionModify_Tests.cs (3)

272Assert.Equal(paramValue.Ver(i), newTask.View.Parameters[paramName.Ver(i)]); 281Assert.Equal(paramValue.Ver(i), newTask.View.Parameters[paramName.Ver(i)]); 612Assert.Equal("source", itemDef.View.ItemType);

ObjectModelRemoting\LinkedConstructionReadOnly_Tests.cs (4)

102Assert.Equal(realXml["a"], viewXml["a"]); 103Assert.Equal(realXml["b"], viewXml["b"]); 104Assert.Equal("x", viewXml["a"]); 105Assert.Equal("y", viewXml["b"]);

ObjectModelRemoting\LinkedEvaluationModify_Tests.cs (26)

ObjectModelRemoting\LinkedSpecialCasesScenarios.cs (1)

136Assert.Equal("Group1", existingItemGroup.Label);

AssemblyNameEx_Tests.cs (7)

355Assert.Equal("A", extension.Name); 361Assert.Equal("A", extension.Name); 367Assert.Equal("A", extension.Name); 373Assert.Equal("A", extension.Name); 379Assert.Equal("A", extension.Name); 391Assert.Equal("A", extension.Name); 399Assert.Equal("A", extension.Name);

BackEnd\BatchingEngine_Tests.cs (9)

78Assert.Equal("a.doc;b.doc;c.doc;d.doc;e.doc", bucket.Expander.ExpandIntoStringAndUnescape("@(doc)", ExpanderOptions.ExpandItems, MockElementLocation.Instance)); 79Assert.Equal("unittests.foo", bucket.Expander.ExpandIntoStringAndUnescape("$(bogus)$(UNITTESTS)", ExpanderOptions.ExpandPropertiesAndMetadata, MockElementLocation.Instance)); 82Assert.Equal("a.foo", buckets[0].Expander.ExpandIntoStringAndUnescape("@(File)", ExpanderOptions.ExpandItems, MockElementLocation.Instance)); 83Assert.Equal(".foo", buckets[0].Expander.ExpandIntoStringAndUnescape("@(File->'%(Extension)')", ExpanderOptions.ExpandItems, MockElementLocation.Instance)); 84Assert.Equal("obj\\a.ext", buckets[0].Expander.ExpandIntoStringAndUnescape("$(obj)\\%(Filename).ext", ExpanderOptions.ExpandPropertiesAndMetadata, MockElementLocation.Instance)); 87Assert.Equal(String.Empty, buckets[0].Expander.ExpandIntoStringAndUnescape("%(Extension)", ExpanderOptions.ExpandAll, MockElementLocation.Instance)); 105Assert.Equal("MSB4012", ex.ErrorCode); 113Assert.Equal("a.foo", items[0].EvaluatedInclude); 420Assert.Equal("high", log.Warnings[0].Code);

BackEnd\BinaryTranslator_Tests.cs (4)

439Assert.Equal(value["foo"], deserializedValue["foo"]); 440Assert.Equal(value["alpha"], deserializedValue["alpha"]); 441Assert.Equal(value["FOO"], deserializedValue["FOO"]); 803Assert.Equal(value, deserializedValue);

BackEnd\BuildManager_Tests.cs (20)

BackEnd\BuildRequest_Tests.cs (2)

77Assert.Equal("a", request2.Targets[0]); 136Assert.Equal(request.Targets[i], deserializedRequest.Targets[i]);

BackEnd\BuildRequestConfiguration_Tests.cs (14)

159Assert.Equal(config1.ProjectFullPath, Path.GetFullPath("file")); 167Assert.Equal("toolsVersion", config1.ToolsVersion); 371Assert.Equal("3", instance.GlobalProperties["ThreeIn"]); 372Assert.Equal("bazfile", instance.GlobalProperties["BazIn"]); 373Assert.Equal("1", instance.PropertiesToBuildWith["One"].EvaluatedValue); 374Assert.Equal("2", instance.PropertiesToBuildWith["Two"].EvaluatedValue); 375Assert.Equal("3", instance.PropertiesToBuildWith["Three"].EvaluatedValue); 381Assert.Equal("bazfile", instance.ItemsToBuildWith["Baz"].First().EvaluatedInclude); 399Assert.Equal("3", instance.GlobalProperties["ThreeIn"]); 400Assert.Equal("bazfile", instance.GlobalProperties["BazIn"]); 401Assert.Equal("1", instance.PropertiesToBuildWith["One"].EvaluatedValue); 402Assert.Equal("2", instance.PropertiesToBuildWith["Two"].EvaluatedValue); 403Assert.Equal("3", instance.PropertiesToBuildWith["Three"].EvaluatedValue); 407Assert.Equal("bazfile", instance.ItemsToBuildWith["Baz"].First().EvaluatedInclude);

BackEnd\BuildRequestEngine_Tests.cs (4)

420Assert.Equal("requiredTarget1", _newRequest_Request.BuildRequests[0].Targets[0]); 473Assert.Equal(Path.GetFullPath("OtherFile"), _newConfiguration_Config.ProjectFullPath); 474Assert.Equal("TestToolsVersion", _newConfiguration_Config.ToolsVersion); 487Assert.Equal("requiredTarget1", _newRequest_Request.BuildRequests[0].Targets[0]);

BackEnd\BuildResult_Tests.cs (1)

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

BackEnd\CentralForwardingLogger_Tests.cs (1)

34Assert.Equal("MyParameters", centralLogger.Parameters); // "Expected parameters equal MyParameters"

BackEnd\ConfigurationMetadata_Tests.cs (4)

65Assert.Equal(data.ProjectFullPath, metadata.ProjectFullPath); 66Assert.Equal(data.ExplicitlySpecifiedToolsVersion, metadata.ToolsVersion); 78Assert.Equal(project.FullPath, metadata.ProjectFullPath); 79Assert.Equal(project.ToolsVersion, metadata.ToolsVersion);

BackEnd\FullyQualifiedBuildRequest_Tests.cs (1)

53Assert.Equal("foo", request.Targets[0]);

BackEnd\IntrinsicTask_Tests.cs (112)

BackEnd\LoggingService_Tests.cs (28)

BackEnd\LoggingServicesLogMethod_Tests.cs (3)

477Assert.Equal(targetsFile, error.File); 478Assert.Equal(projectFile, error.ProjectFile); 1299Assert.Equal(expectedEventArgs.EventName, actualEventArgs.EventName);

BackEnd\Lookup_Tests.cs (114)

BackEnd\MSBuild_Tests.cs (5)

1810Assert.Equal("|a", targetOutputs["Build"].Items[0].ItemSpec); 1811Assert.Equal("A|b", targetOutputs["Build"].Items[1].ItemSpec); 1812Assert.Equal("B|c", targetOutputs["Build"].Items[2].ItemSpec); 1813Assert.Equal("C|d", targetOutputs["Build"].Items[3].ItemSpec); 1814Assert.Equal("D|", targetOutputs["Build"].Items[4].ItemSpec);

BackEnd\NodePackets_Tests.cs (1)

205Assert.Equal(@"Task Parameter:

BackEnd\ResultsCache_Tests.cs (4)

333Assert.Equal("Value1", cachedResponseWithSubsetFlag1.Results.ProjectStateAfterBuild.GetPropertyValue("property1")); 334Assert.Equal("Value2", cachedResponseWithSubsetFlag1.Results.ProjectStateAfterBuild.GetPropertyValue("property2")); 338Assert.Equal("Value1", cachedResponseWithSubsetFlag2.Results.ProjectStateAfterBuild.GetPropertyValue("property1")); 339Assert.Equal("", cachedResponseWithSubsetFlag2.Results.ProjectStateAfterBuild.GetPropertyValue("property2"));

BackEnd\TargetBuilder_Tests.cs (1)

1552Assert.Equal(task.Name, tasks[currentTask]);

BackEnd\TargetEntry_Tests.cs (29)

BackEnd\TargetResult_Tests.cs (1)

43Assert.Equal(item.ItemSpec, result.Items[0].ItemSpec);

BackEnd\TaskExecutionHost_Tests.cs (6)

1303Assert.Equal(value, _bucket.Lookup.GetItems("output").First().EvaluatedInclude); 1329Assert.Equal(values[i], _bucket.Lookup.GetItems("output").ElementAt(i).EvaluatedInclude); 1357Assert.Equal(value, _bucket.Lookup.GetProperty("output").EvaluatedValue); 1381Assert.Equal(value, actualItem.ItemSpec); 1409Assert.Equal(value, actualItems[0].ItemSpec); 1444Assert.Equal(expectedItems[i], actualItems[i].ItemSpec);

BackEnd\TaskHost_Tests.cs (12)

137Assert.Equal("Your code failed.", customBuildError.Message); 138Assert.Equal("CodeViolation", customBuildError.CustomData); 162Assert.Equal("Your code failed.", customBuildWarning.Message); 163Assert.Equal("CodeViolation", customBuildWarning.CustomData); 186Assert.Equal("I am a message", customMessage.Message); 187Assert.Equal("CodeViolation", customMessage.CustomMessage); 327Assert.Equal("testCustomBuildEvent", _customLogger.LastCustom.Message); 385Assert.Equal("testCustomBuildEvent", _customLogger.LastCustom.Message); 401Assert.Equal("ext message", _customLogger.LastCustom.Message); 414Assert.Equal("ext err message", _customLogger.LastError.Message); 427Assert.Equal("ext warn message", _customLogger.LastWarning.Message); 440Assert.Equal("ext message", _customLogger.LastMessage.Message);

BackEnd\TaskHostConfiguration_Tests.cs (7)

371Assert.Equal(config.TaskName, deserializedConfig.TaskName); 468Assert.Equal(config.TaskName, deserializedConfig.TaskName); 519Assert.Equal(config.TaskName, deserializedConfig.TaskName); 568Assert.Equal(config.TaskName, deserializedConfig.TaskName); 616Assert.Equal(config.TaskName, deserializedConfig.TaskName); 671Assert.Equal(config.TaskName, deserializedConfig.TaskName); 771Assert.Equal(x.ItemSpec, y.ItemSpec);

BackEnd\TaskRegistry_Tests.cs (6)

1147Assert.Equal(expandedTaskFactory, registeredTaskRecords[0].TaskFactoryAttributeName); 1326Assert.Equal(parameterInfo.Name, defaultParameter.Name); 1333Assert.Equal(parameterInfo.Name, filledOutAttributesParameter.Name); 1703Assert.Equal(parameterInfo.Name, filledOutAttributesParameter.Name); 2019Assert.Equal(expectedRuntime, record.TaskFactoryParameters[XMakeAttributes.runtime]); 2024Assert.Equal(expectedArchitecture, record.TaskFactoryParameters[XMakeAttributes.architecture]);

BuildEventArgsSerialization_Tests.cs (1)

1232Assert.Equal(expected, actual);

Collections\MultiDictionary_Tests.cs (4)

109Assert.Equal("x1", values[0]); 110Assert.Equal("x2", values[1]); 115Assert.Equal("y1", values[0]); 146Assert.Equal("x2", values[0]);

Collections\OMcollections_tests.cs (2)

48Assert.Equal("v1", properties["p1"].EvaluatedValue); 49Assert.Equal("v3", properties["p2"].EvaluatedValue);

Construction\ElementLocation_Tests.cs (11)

42Assert.Equal("file", location.File); 55Assert.Equal("file", location.File); 68Assert.Equal("file", location.File); 169Assert.Equal(location.File, deserializedLocation.File); 187Assert.Equal(location.File, deserializedLocation.File); 200Assert.Equal("file", location.File); 235Assert.Equal(location.File, String.Empty); 245Assert.Equal("file", location.File); 258Assert.Equal("file", location.File); 271Assert.Equal("file", location.File); 289Assert.Equal(location.File, deserializedLocation.File);

Construction\ProjectRootElement_Tests.cs (6)

81Assert.Equal("Project", children[0].Name); 83Assert.Equal("Initial Comment", children[0].ChildNodes[0].Value); 84Assert.Equal("Ending Comment", children[0].ChildNodes[1].Value); 113Assert.Equal("Project", children[0].Name); 115Assert.Equal(string.Empty, children[0].ChildNodes[0].Value); 116Assert.Equal(string.Empty, children[0].ChildNodes[1].Value);

Construction\SolutionProjectGenerator_Tests.cs (51)

312Assert.Equal(text, warning.Message); 313Assert.Equal(code, warning.Code); 314Assert.Equal(keyword, warning.HelpKeyword); 321Assert.Equal(text, error.Message); 322Assert.Equal(code, error.Code); 323Assert.Equal(keyword, error.HelpKeyword); 362Assert.Equal("3.5", instances[0].ToolsVersion); 397Assert.Equal("3.5", instances[0].ToolsVersion); 426Assert.Equal(ObjectModelHelpers.MSBuildDefaultToolsVersion, instances[0].ToolsVersion); 430Assert.Equal(t.DefaultSubToolsetVersion, instances[0].SubToolsetVersion); 434Assert.Equal(t.DefaultSubToolsetVersion, instances[0].GetPropertyValue("VisualStudioVersion")); 438Assert.Equal(String.Empty, instances[0].GetPropertyValue("VisualStudioVersion")); 468Assert.Equal(ObjectModelHelpers.MSBuildDefaultToolsVersion, instances[0].ToolsVersion); 473Assert.Equal("11.0", instances[0].SubToolsetVersion); 474Assert.Equal("11.0", instances[0].GetPropertyValue("VisualStudioVersion")); 503Assert.Equal(ObjectModelHelpers.MSBuildDefaultToolsVersion, instances[0].ToolsVersion); 504Assert.Equal("ABC", instances[0].SubToolsetVersion); 505Assert.Equal("ABC", instances[0].GetPropertyValue("VisualStudioVersion")); 701Assert.Equal(ObjectModelHelpers.MSBuildDefaultToolsVersion, instances[0].ToolsVersion); 702Assert.Equal("11.0", instances[0].SubToolsetVersion); 703Assert.Equal("11.0", instances[0].GetPropertyValue("VisualStudioVersion")); 1247Assert.Equal("False", skipNonexistentProjects); 1251Assert.Equal("Build", skipNonexistentProjects); 1255Assert.Equal("Debug", item.GetMetadata("Configuration")); 1256Assert.Equal("Mixed Platforms", item.GetMetadata("Platform")); 1261Assert.Equal("Release", item.GetMetadata("Configuration")); 1262Assert.Equal("Any CPU", item.GetMetadata("Platform")); 1329Assert.Equal(toolsVersionParameter, instances[0].GetPropertyValue("ProjectToolsVersion")); 1502Assert.Equal("Clean", cleanTarget.Tasks.Where( 1506Assert.Equal("Rebuild", rebuildTarget.Tasks.Where( 1510Assert.Equal("Publish", publishTarget.Tasks.Where( 1515Assert.Equal("@(ProjectReference)", buildTarget.Tasks.Where( 1519Assert.Equal("@(ProjectReference->Reverse())", cleanTarget.Tasks.Where( 1523Assert.Equal("@(ProjectReference)", rebuildTarget.Tasks.Where( 1527Assert.Equal("@(ProjectReference)", publishTarget.Tasks.Where( 1566Assert.Equal("Debug", instances[0].GetPropertyValue("Configuration")); 1569Assert.Equal("Mixed Platforms", instances[0].GetPropertyValue("Platform")); 1596Assert.Equal("Release", instances[0].GetPropertyValue("Configuration")); 1599Assert.Equal("Any CPU", instances[0].GetPropertyValue("Platform")); 1621Assert.Equal("Debug", msbuildProject.GetPropertyValue("AspNetConfiguration")); 1625Assert.Equal("Release", msbuildProject.GetPropertyValue("AspNetConfiguration")); 1648Assert.Equal("v4.0", msbuildProject.GetPropertyValue("TargetFrameworkVersion")); 1658Assert.Equal("v3.5", msbuildProject.GetPropertyValue("TargetFrameworkVersion")); 1662Assert.Equal("v2.0", msbuildProject.GetPropertyValue("TargetFrameworkVersion")); 1668Assert.Equal("userdefined", msbuildProject.GetPropertyValue("TargetFrameworkVersion")); 1687Assert.Equal("2.0", msbuildProject.ToolsVersion); 1794Assert.Equal("Debug|Mixed Platforms", SolutionProjectGenerator.PredictActiveSolutionConfigurationName(solution, globalProperties)); 1797Assert.Equal("Release|Mixed Platforms", SolutionProjectGenerator.PredictActiveSolutionConfigurationName(solution, globalProperties)); 1800Assert.Equal("Release|Win32", SolutionProjectGenerator.PredictActiveSolutionConfigurationName(solution, globalProperties)); 2469Assert.Equal("MyTask", task.Name); 2631Assert.Equal(enable ? expectedPropertyValue : string.Empty, projectInstance.GetPropertyValue("PropertyA"));

CopyOnWriteDictionary_Tests.cs (7)

119Assert.Equal("1", dictionary["test"]); 123Assert.Equal("1", clone["test"]); 135Assert.Equal("1", dictionary["test"]); 139Assert.Equal("1", clone["TEST"]); 176Assert.Equal("1", dictionary["test"]); 192Assert.Equal("1", dictionary["test"]); 193Assert.Equal("2", clone["test"]);

Definition\ItemDefinitionGroup_Tests.cs (43)

Definition\Project_Internal_Tests.cs (7)

47Assert.Equal("x", collection.DefaultToolsVersion); 58Assert.Equal("x", project.ToolsVersion); 137Assert.Equal("2.0", project.ToolsVersion); 141Assert.Equal("2.0", project.ToolsVersion); 188Assert.Equal("2.0", project.GetPropertyValue("msbuildtoolsversion")); 191Assert.Equal("2.0", project.GetPropertyValue("msbuildtoolsversion")); 195Assert.Equal(

Definition\ProjectItem_Tests.cs (1)

37Assert.Equal(String.Empty, item2.GetMetadataValue("n"));

Definition\Toolset_Tests.cs (30)

Definition\ToolsetConfigurationReader_Tests.cs (28)

Definition\ToolsVersion_Tests.cs (2)

281Assert.Equal(foundFiles[i], sortedTasksExpectedPaths[i]); 287Assert.Equal(foundoverrideFiles[i], sortedOverrideExpectedPaths[i]);

EscapingInProjects_Tests.cs (30)

EscapingUtilities_Tests.cs (23)

Evaluation\Evaluator_Tests.cs (95)

Evaluation\Expander_Tests.cs (153)

Evaluation\ExpressionShredder_Tests.cs (109)

Evaluation\ItemEvaluation_Tests.cs (7)

555Assert.Equal("0;6;7;8;9", String.Join(";", items.Select(i => i.EvaluatedInclude))); 598Assert.Equal("true", project.GetPropertyValue("FromImport")); 599Assert.Equal("**/foo/**/*.cs", project.GetConcatenatedItemsOfType("i")); 600Assert.Equal("**/yyy/**/*.cs", project.GetConcatenatedItemsOfType("i3")); 609Assert.Equal(expectedItems, project.GetConcatenatedItemsOfType("i2")); 620Assert.Equal("**/foo/**/*.cs", project.GetConcatenatedItemsOfType("ItemReference")); 623Assert.Equal(string.Empty, project.GetConcatenatedItemsOfType("RecursiveDir"));

Evaluation\ProjectSdkImplicitImport_Tests.cs (7)

144Assert.Equal(_sdkPropsPath, initialResolvedImport.ImportedProject.FullPath); 148Assert.Equal(_sdkTargetsPath, finalResolvedImport.ImportedProject.FullPath); 308Assert.Equal("MSB4229", exception.ErrorCode); 399Assert.Equal("MSB4238", e.ErrorCode); 424Assert.Equal("MSB4229", exception.ErrorCode); 827Assert.Equal(expectedContainingProjectPath, property.Xml.ContainingProject.FullPath); 831Assert.Equal(expectedValue, property.EvaluatedValue);

Evaluation\SimpleVersion_Tests.cs (1)

297Assert.Equal(expected, version.ToString());

EventArgsFormatting_Tests.cs (12)

28Assert.Equal( 39Assert.Equal( 48Assert.Equal( 57Assert.Equal( 66Assert.Equal( 75Assert.Equal( 84Assert.Equal( 93Assert.Equal( 103Assert.Equal( 117Assert.Equal("source.cs(42): CS error 312: message\r Hello", errorString); 118Assert.Equal("source.cs(42): CS warning 312: message\r Hello", warningString); 127Assert.Equal(

FileLogger_Tests.cs (1)

477Assert.Equal(expectedLines[i].Trim(), actualLines[i].Trim());

FileMatcher_Tests.cs (19)

834Assert.Equal(@"D:\LongDirectoryName\LongSubDirectory\LongFileName.txt", longPath); 850Assert.Equal(@"D:\LongDirectoryName\LongSubDirectory\LongFileName.txt", longPath); 866Assert.Equal(@"\\server\share\LongDirectoryName\LongSubDirectory\LongFileName.txt", longPath); 882Assert.Equal(@"\\server\share\LongDirectoryName\LongSubDirectory\LongFileName.txt", longPath); 898Assert.Equal(@"LongDirectoryName\LongSubDirectory\LongFileName.txt", longPath); 914Assert.Equal(@"LongDirectoryName\LongSubDirectory\", longPath); 930Assert.Equal(@"LongDirectoryName\\LongSubDirectory\\", longPath); 946Assert.Equal(@"c:\apple\banana\tomato\pomegranate\orange\", longPath); 963Assert.Equal(@"c:\apple\banana\tomato\pomegranate\orange\chocol~1\vanila~1", longPath); 1448Assert.Equal("1.file", strings[0]); 1452Assert.Equal(strings[0], NativeMethodsShared.IsWindows ? "directory\\1.file" : "directory/1.file"); 1456Assert.Equal("1.file", strings[0]); 1460Assert.Equal(strings[0], NativeMethodsShared.IsWindows ? "c:\\1.file" : "/1.file"); 1464Assert.Equal(strings[0], NativeMethodsShared.IsWindows ? "c:\\directorymorechars\\1.file" : "/directorymorechars/1.file"); 1470Assert.Equal("1.file", strings[0]); 1474Assert.Equal("directory\\1.file", strings[0]); 1478Assert.Equal("1.file", strings[0]); 1482Assert.Equal("\\Machine\\1.file", strings[0]); 1486Assert.Equal("\\Machine\\directorymorechars\\1.file", strings[0]);

FileUtilities_Tests.cs (93)

Globbing\MSBuildGlob_Tests.cs (19)

43Assert.Equal(expectedRoot, glob.TestOnlyGlobRoot); 51Assert.Equal(Directory.GetCurrentDirectory().WithTrailingSlash(), glob.TestOnlyGlobRoot); 67Assert.Equal(expectedRoot, glob.TestOnlyGlobRoot); 98Assert.Equal(expectedFixedDirectory, glob.FixedDirectoryPart); 120Assert.Equal(fileSpec, glob.TestOnlyFileSpec); 122Assert.Equal(globRoot.WithTrailingSlash(), glob.TestOnlyGlobRoot); 125Assert.Equal(expectedFixedDirectory, glob.FixedDirectoryPart); 126Assert.Equal("**/", glob.WildcardDirectoryPart); 127Assert.Equal("*.cs", glob.FilenamePart); 139Assert.Equal(illegalFileSpec, glob.TestOnlyFileSpec); 141Assert.Equal(globRoot.WithTrailingSlash(), glob.TestOnlyGlobRoot); 143Assert.Equal(string.Empty, glob.FixedDirectoryPart); 144Assert.Equal(string.Empty, glob.WildcardDirectoryPart); 145Assert.Equal(string.Empty, glob.FilenamePart); 168Assert.Equal(string.Empty, glob.WildcardDirectoryPart); 169Assert.Equal("%42", glob.FilenamePart); 358Assert.Equal(FileUtilities.GetFullPathNoThrow(rootedFixedDirectoryPart), result.FixedDirectoryPartMatchGroup); 359Assert.Equal(NormalizeSlashes(wildcardDirectoryPart), result.WildcardDirectoryPartMatchGroup); 360Assert.Equal(NormalizeSlashes(filenamePart), result.FilenamePartMatchGroup);

Instance\ProjectMetadataInstance_Internal_Tests.cs (4)

31Assert.Equal("m", clone.Name); 32Assert.Equal("m1", clone.EvaluatedValue); 47Assert.Equal(metadata.Name, deserializedMetadata.Name); 48Assert.Equal(metadata.EvaluatedValue, deserializedMetadata.EvaluatedValue);

Instance\ProjectPropertyInstance_Internal_Tests.cs (9)

31Assert.Equal("p", clone.Name); 32Assert.Equal("v1", clone.EvaluatedValue); 47Assert.Equal(property.Name, deserializedProperty.Name); 48Assert.Equal(property.EvaluatedValue, deserializedProperty.EvaluatedValue); 64Assert.Equal(property.Name, deserializedProperty.Name); 65Assert.Equal(property.EvaluatedValue, deserializedProperty.EvaluatedValue); 83Assert.Equal(property.Name, deserializedProperty.Name); 84Assert.Equal(property.EvaluatedValue, deserializedProperty.EvaluatedValue); 86Assert.Equal("Microsoft.Build.Execution.ProjectPropertyInstance+ProjectPropertyInstanceImmutable", property.GetType().ToString());

Instance\TaskItem_Tests.cs (3)

61Assert.Equal(item.ItemSpec, deserializedItem.ItemSpec); 63Assert.Equal(item.GetMetadata("a"), deserializedItem.GetMetadata("a")); 64Assert.Equal(item.GetMetadata(FileUtilities.ItemSpecModifiers.DefiningProjectFullPath), deserializedItem.GetMetadata(FileUtilities.ItemSpecModifiers.DefiningProjectFullPath));

InvalidProjectFileException_Tests.cs (1)

81Assert.Equal(file, e.ProjectFile); // https://github.com/dotnet/msbuild/issues/1286

LogFormatter_Tests.cs (5)

26Assert.Equal("00:02:05.45", result); 41Assert.Equal("00:00:00", result); 50Assert.Equal(testTime.ToString("HH:mm:ss.fff", CultureInfo.CurrentCulture), result); 54Assert.Equal(testTime.ToString("HH:mm:ss.fff", CultureInfo.CurrentCulture), result); 58Assert.Equal(testTime.ToString("HH:mm:ss.fff", CultureInfo.CurrentCulture), result);

Parser_Tests.cs (6)

221Assert.Equal("@(item->foo('ab'))", tree.GetUnexpandedValue(null)); 580Assert.Equal("bar", projectItem.EvaluatedInclude); 586Assert.Equal("m1", metadatam.EvaluatedValue); 591Assert.Equal("m2", metadatam.EvaluatedValue); 595Assert.Equal("n1", metadatan.EvaluatedValue); 596Assert.Equal("n2", metadatan.Predecessor.EvaluatedValue);

ResourceUtilities_Tests.cs (14)

Scanner_Tests.cs (13)

TaskParameter_Tests.cs (48)

TestComparers\ProjectInstanceModelTestComparers.cs (50)

TestComparers\TaskRegistryComparers.cs (15)

48Assert.Equal(x.RegisteredName, y.RegisteredName); 50Assert.Equal(x.TaskFactoryAttributeName, y.TaskFactoryAttributeName); 58Assert.Equal(xp.Key, yp.Key); 59Assert.Equal(xp.Value, yp.Value); 77Assert.Equal(x.InlineTaskXmlBody, y.InlineTaskXmlBody); 85Assert.Equal(xp.Key, yp.Key); 102Assert.Equal(x.Name, y.Name); 105Assert.Equal(x.PropertyType.FullName, y.PropertyType.FullName); 126Assert.Equal(x.ToolsVersion, y.ToolsVersion); 127Assert.Equal(x.ToolsPath, y.ToolsPath); 128Assert.Equal(x.DefaultOverrideToolsVersion, y.DefaultOverrideToolsVersion); 129Assert.Equal(x.OverrideTasksPath, y.OverrideTasksPath); 136Assert.Equal(xp.Key, yp.Key); 137Assert.Equal(xp.Value.Name, yp.Value.Name); 138Assert.Equal(xp.Value.EvaluatedValue, yp.Value.EvaluatedValue);

Utilities_Tests.cs (19)

38Assert.Equal("<<x />", xmlContents); 47Assert.Equal("<x />", xmlContents); 56Assert.Equal("<x />", xmlContents); 118Assert.Equal("<<x />", xmlContents); 127Assert.Equal("<x />", xmlContents); 136Assert.Equal("<x />", xmlContents); 186Assert.Equal("<invalid<xml&&<", xmlContents); 199Assert.Equal("This is not a real <CDATA />, just trying to fool the reader.", xmlContents); 210Assert.Equal("whatever", xmlContents); 221Assert.Equal("This is not a real CDATA, just trying to fool the reader.", xmlContents); 232Assert.Equal("<RootOfPropValue><![CDATA[foo]]></RootOfPropValue>", xmlContents); 243Assert.Equal("foo", xmlContents); 257Assert.Equal("This is some text contain a node <xml a=\"<\" />, & an escaped character.", xmlContents); 268Assert.Equal("This is some text & an escaped character.", xmlContents); 280Assert.Equal("foo; biz; & boz", xmlContents); 288Assert.Equal("xyz", xmlContents); 296Assert.Equal("", xmlContents); 304Assert.Equal("-->", xmlContents); 322Assert.Equal("\"66\", \"44\"", result);

WarningsAsMessagesAndErrors_Tests.cs (5)

227Assert.Equal(ExpectedEventMessage, actualEvent.Message); 228Assert.Equal(ExpectedEventCode, actualEvent.Code); 239Assert.Equal(ExpectedEventMessage, actualEvent.Message); 240Assert.Equal(ExpectedEventCode, actualEvent.Code); 251Assert.Equal(ExpectedEventCode, actualEvent.Code);

XmakeAttributes_Tests.cs (4)

152Assert.Equal(currentArchitecture, mergedArchitecture); 155Assert.Equal(XMakeAttributes.MSBuildArchitectureValues.x64, mergedArchitecture); 158Assert.Equal(XMakeAttributes.MSBuildArchitectureValues.x86, mergedArchitecture); 161Assert.Equal(currentArchitecture, mergedArchitecture);

XmlUtilities_Tests.cs (1)

61Assert.Equal(expected, actual);

CopyRefAssemblyTests.cs (2)

77Assert.Equal("test", File.ReadAllText(dest)); 104Assert.Equal("test", File.ReadAllText(dest.Path));

CscTests.cs (66)

CsiTests.cs (8)

GenerateMSBuildEditorConfigTests.cs (14)

IntegrationTests.cs (7)

103Assert.Equal("", result.Output); 104Assert.Equal("", result.Errors); 115Assert.Equal(expectedOutput, runningResult.Output); 416Assert.Equal("", result.Output); 417Assert.Equal("", result.Errors); 421Assert.Equal("Hello\r\nthere\r\nWorld\r\n", runningResult.Output); 784Assert.Equal("", result.Errors);

MapSourceRootTests.cs (33)

TargetTests.cs (62)

TestUtilities\TaskTestUtil.cs (1)

25Assert.Equal(line, rsp);

VbcTests.cs (60)

AssemblyDependency\ResolveAssemblyReferenceTestFixture.cs (4)

3051Assert.Equal(loadModeResolvedFiles[i].ItemSpec, t.ResolvedFiles[i].ItemSpec); 3052Assert.Equal(loadModeResolvedFiles[i].GetMetadata("CopyLocal"), t.ResolvedFiles[i].GetMetadata("CopyLocal")); 3053Assert.Equal(loadModeResolvedFiles[i].GetMetadata("ResolvedFrom"), t.ResolvedFiles[i].GetMetadata("ResolvedFrom")); 3095Assert.Equal(cache, t.FilesWritten[0].ItemSpec);

AssemblyNameEx_Tests.cs (7)

355Assert.Equal("A", extension.Name); 361Assert.Equal("A", extension.Name); 367Assert.Equal("A", extension.Name); 373Assert.Equal("A", extension.Name); 379Assert.Equal("A", extension.Name); 391Assert.Equal("A", extension.Name); 399Assert.Equal("A", extension.Name);

AssignCulture_Tests.cs (41)

AssignLinkMetadata_Tests.cs (4)

77Assert.Equal(item.ItemSpec, t.OutputItems[0].ItemSpec); 81Assert.Equal(Path.Combine("SubFolder", "a.cs"), t.OutputItems[0].GetMetadata("Link")); 104Assert.Equal(item2.ItemSpec, t.OutputItems[0].ItemSpec); 108Assert.Equal(Path.Combine("SubFolder", "a.cs"), t.OutputItems[0].GetMetadata("Link"));

CodeTaskFactoryTests.cs (1)

1228Assert.Equal("MSB4801", error.Code);

CommandLineBuilderExtension_Tests.cs (2)

46Assert.Equal(@"/myswitch:MyResource.bmp,Kenny,Private", c.ToString()); 91Assert.Equal(

ConvertToAbsolutePath_Tests.cs (1)

106Assert.Equal(testFile.FullName, t.AbsolutePaths[0].ItemSpec);

Copy_Tests.cs (55)

CreateCSharpManifestResourceName_Tests.cs (28)

44Assert.Equal("MyStuff.Namespace.Class", result); 92Assert.Equal(className, result); 126Assert.Equal("d\u00C4a.Class", result); 146Assert.Equal("Namespace.Class", result); 166Assert.Equal("MyStuff.Namespace.Class", result); 186Assert.Equal("MyStuff.Namespace.Class.en-GB", result); 207Assert.Equal("MyStuff.Namespace.Class.en-GB", result); 227Assert.Equal("MyStuff.Namespace.Class.fr-fr", result); 248Assert.Equal("RootNamespace.SubFolder.MyForm.en-GB", result); 289Assert.Equal("RootNamespace.XmlEditor.rgs", result); 309Assert.Equal("RootNamespace.SubFolder.SplashScreen.bmp", result); 329Assert.Equal(FileUtilities.FixFilePath(@"fr\RootNamespace.SubFolder.SplashScreen.bmp"), result); 349Assert.Equal(@"RootNamespace.SubFolder.SplashScreen.bmp", result); 375Assert.Equal(@"CustomToolTest.SR1", resourceNames[0].ItemSpec); 625Assert.Equal(result, expected); 699Assert.Equal("ClassLibrary1.MyForm", result); 726Assert.Equal("RootNamespace.MyForm.en-GB", result); 808Assert.Equal(@"strings.resx", resourceFiles[0].ItemSpec); 809Assert.Equal(@"ResourceRoot.strings", resourceFiles[0].GetMetadata("ManifestResourceName")); 834Assert.Equal(@"pic.bmp", resourceFiles[0].ItemSpec); 835Assert.Equal(@"ResourceRoot.pic.bmp", resourceFiles[0].GetMetadata("LogicalName")); 860Assert.Equal(@"pic.bmp", resourceFiles[0].ItemSpec); 861Assert.Equal(@"foo", resourceFiles[0].GetMetadata("LogicalName")); 885Assert.Equal(@"strings.resx", resourceFiles[0].ItemSpec); 886Assert.Equal(String.Empty, resourceFiles[0].GetMetadata("LogicalName")); 906Assert.Equal(@"RootNamespace.SubFolder.MyResource.fr.resources", result); 926Assert.Equal(@"RootNamespace.MyResource.fr.resources", result); 946Assert.Equal(@"RootNamespace.MyResource.resources", result);

CreateItem_Tests.cs (5)

83Assert.Equal("MyFile.txt", t.Include[0].ItemSpec); 101Assert.Equal(t.Include[0].ItemSpec, t.Include[0].ItemSpec); 236Assert.Equal("SomeValue", t.Include[0].GetMetadata("MyMetaData")); 259Assert.Equal("SomePreserveMeValue", t.Include[0].GetMetadata("MyMetaData")); 284Assert.Equal("SomeOverwriteValue", t.Include[0].GetMetadata("MyMetaData"));

Culture_Tests.cs (4)

22Assert.Equal("fr", info.culture); 23Assert.Equal("MyResource.resx", info.cultureNeutralFilename); 36Assert.Equal("MyResource.resx", info.cultureNeutralFilename); 52Assert.Equal("MyResource.notalocale.resx", info.cultureNeutralFilename);

Delete_Tests.cs (2)

36Assert.Equal("en-GB", t.DeletedFiles[0].GetMetadata("Locale")); 39Assert.Equal("MyFiles.nonexistent", t.DeletedFiles[0].ItemSpec);

DirectoryBuildProjectImportTestBase.cs (4)

88Assert.Equal(String.Empty, project.GetPropertyValue(DirectoryBuildProjectPathPropertyName)); 122Assert.Equal(String.Empty, project.GetPropertyValue(DirectoryBuildProjectPathPropertyName)); 150Assert.Equal(customFilePath, project.GetPropertyValue(DirectoryBuildProjectPathPropertyName)); 177Assert.Equal(Path.Combine(ObjectModelHelpers.TempProjectDir, DirectoryBuildProjectFile), project.GetPropertyValue(DirectoryBuildProjectPathPropertyName));

EscapingUtilities_Tests.cs (23)

Exec_Tests.cs (5)

289Assert.Equal(working, exec.WorkingDirectory); 292Assert.Equal(system, exec.GetWorkingDirectoryAccessor()); 598Assert.Equal(expectedEncoding, exec.StdOutEncoding); 599Assert.Equal(expectedEncoding, exec.StdErrEncoding); 824Assert.Equal("foo", exec.WorkingDirectory);

FileStateTests.cs (4)

85Assert.Equal(info.FullName, state.Name); 214Assert.Equal(info.FullName, state.Name); 219Assert.Equal(originalName, state.Name); 221Assert.Equal(originalName, state.Name); // Name is from the constructor, didn't change

FindAppConfigFile_Tests.cs (9)

25Assert.Equal("app.config", f.AppConfigFile.ItemSpec); 26Assert.Equal("targetpath", f.AppConfigFile.GetMetadata("TargetPath")); 38Assert.Equal("app.config", f.AppConfigFile.ItemSpec); 39Assert.Equal("targetpath", f.AppConfigFile.GetMetadata("TargetPath")); 51Assert.Equal(FileUtilities.FixFilePath("foo\\app.config"), f.AppConfigFile.ItemSpec); 52Assert.Equal("targetpath", f.AppConfigFile.GetMetadata("TargetPath")); 77Assert.Equal(FileUtilities.FixFilePath(@"foo\\app.config"), f.AppConfigFile.ItemSpec); 94Assert.Equal("app.config", f.AppConfigFile.ItemSpec); 95Assert.Equal(item2.GetMetadata("id"), f.AppConfigFile.GetMetadata("id"));

FindInList_Tests.cs (8)

25Assert.Equal("A.CS", f.ItemFound.ItemSpec); 37Assert.Equal("a.cs", f.ItemFound.ItemSpec); 64Assert.Equal("a.cs", f.ItemFound.ItemSpec); 65Assert.Equal(item1.GetMetadata("id"), f.ItemFound.GetMetadata("id")); 84Assert.Equal("a.cs", f.ItemFound.ItemSpec); 85Assert.Equal(item2.GetMetadata("id"), f.ItemFound.GetMetadata("id")); 120Assert.Equal(FileUtilities.FixFilePath(@"c:\foo\a.cs"), f.ItemFound.ItemSpec); 135Assert.Equal(FileUtilities.FixFilePath(@"foo\a.cs"), f.ItemFound.ItemSpec);

FindInvalidProjectReferences_Tests.cs (2)

58Assert.Equal("proj3.proj", t.InvalidReferences[0].ItemSpec); 59Assert.Equal("proj4.proj", t.InvalidReferences[1].ItemSpec);

FindUnderPath_Tests.cs (6)

35Assert.Equal(FileUtilities.FixFilePath(@"C:\MyProject\File1.txt"), t.InPath[0].ItemSpec); 36Assert.Equal(FileUtilities.FixFilePath(@"C:\SomeoneElsesProject\File2.txt"), t.OutOfPath[0].ItemSpec); 111Assert.Equal(testFile.FullName, t.InPath[0].ItemSpec); 112Assert.Equal(NativeMethodsShared.IsWindows ? @"C:\SomeoneElsesProject\File2.txt" : "/SomeoneElsesProject/File2.txt", 133Assert.Equal(testFile.Name, t.InPath[0].ItemSpec); 134Assert.Equal(NativeMethodsShared.IsWindows ? @"C:\SomeoneElsesProject\File2.txt" : "/SomeoneElsesProject/File2.txt",

GetInstalledSDKLocations_Tests.cs (18)

296Assert.Equal("1.0", sdksAndVersions["MyAssembly, Version=1.0"]); 297Assert.Equal("1.0", sdksAndVersions["MyAssembly, Version=2.0"]); 298Assert.Equal("2.0", sdksAndVersions["MyAssembly, Version=3.0"]); 299Assert.Equal("1.0", sdksAndVersions["MyAssembly, Version=4.0"]); 300Assert.Equal("1.0", sdksAndVersions["MyAssembly, Version=5.0"]); 301Assert.Equal("2.0", sdksAndVersions["MyAssembly, Version=6.0"]); 343Assert.Equal( 349Assert.Equal( 355Assert.Equal( 362Assert.Equal( 368Assert.Equal( 374Assert.Equal( 417Assert.Equal( 423Assert.Equal( 429Assert.Equal( 436Assert.Equal( 442Assert.Equal( 448Assert.Equal(

GetSDKReference_Tests.cs (35)

Hash_Tests.cs (7)

26Assert.Equal(expectedHash, actualHash); 33Assert.Equal(expectedHash, actualHash2); 65Assert.Equal(expectedHash, actualHash); 82Assert.Equal(expectedHash, actualHash); 143Assert.Equal(uppercaseHash, lowercaseHash); 144Assert.Equal(uppercaseHash, mixedcaseHash); 145Assert.Equal(mixedcaseHash, lowercaseHash);

MakeDir_Tests.cs (9)

Move_Tests.cs (28)

MSBuild_Tests.cs (5)

1348Assert.Equal("|a", msbuildTask.TargetOutputs[0].ItemSpec); 1349Assert.Equal("A|b", msbuildTask.TargetOutputs[1].ItemSpec); 1350Assert.Equal("B|c", msbuildTask.TargetOutputs[2].ItemSpec); 1351Assert.Equal("C|d", msbuildTask.TargetOutputs[3].ItemSpec); 1352Assert.Equal("D|", msbuildTask.TargetOutputs[4].ItemSpec);

NativeMethodsShared_Tests.cs (1)

152Assert.Equal(currentDirectory, Directory.GetCurrentDirectory());

PropertyParser_Tests.cs (16)

ReadLinesFromFile_Tests.cs (12)

47Assert.Equal("Line1", r.Lines[0].ItemSpec); 56Assert.Equal("Line1", r.Lines[0].ItemSpec); 57Assert.Equal("Line2", r.Lines[1].ItemSpec); 58Assert.Equal("Line3", r.Lines[2].ItemSpec); 94Assert.Equal("Line1_%3b_", r.Lines[0].ItemSpec); 103Assert.Equal("Line1_%3b_", r.Lines[0].ItemSpec); 104Assert.Equal("Line2", r.Lines[1].ItemSpec); 105Assert.Equal("Line3", r.Lines[2].ItemSpec); 139Assert.Equal("My special character is \u00C3", r.Lines[0].ItemSpec); 199Assert.Equal("Line1", r.Lines[0].ItemSpec); 200Assert.Equal("Line2", r.Lines[1].ItemSpec); 201Assert.Equal("Line3", r.Lines[2].ItemSpec);

RemoveDuplicates_Tests.cs (11)

ResolveCodeAnalysisRuleSet_Tests.cs (4)

90Assert.Equal(expected: codeAnalysisRuleSet, actual: resolvedRuleSet); 136Assert.Equal(expected: codeAnalysisRuleSet, actual: resolvedRuleSet); 187Assert.Equal(expected: ruleSetFullPath, actual: resolvedRuleSet); 265Assert.Equal(expected: codeAnalysisRuleSet, actual: resolvedRuleSet);

ResolveNonMSBuildProjectOutput_Tests.cs (3)

67Assert.Equal(missingAttr, expectedMissingAttribute); 119Assert.Equal(resolvedPath.ItemSpec, expectedPath); 232Assert.Equal("true", ((ITaskItem)resolvedOutputs[Path.Combine("obj", "managed.dll")]).GetMetadata("ManagedAssembly"));

ResolveSDKReference_Tests.cs (92)

ResourceHandling\GenerateResource_Tests.cs (97)

ResourceUtilities_Tests.cs (14)

StreamMappedString_Tests.cs (5)

107Assert.Equal("bcd", s.Substring(1, 3)); 116Assert.Equal("bcd", s.Substring(1, 3)); 129Assert.Equal("abcxdef", s.Substring(0, 7)); 140Assert.Equal(String.Empty, s.Substring(1, 30)); 153Assert.Equal("abc", s.Substring(0, 3));

WriteCodeFragment_Tests.cs (9)

WriteLinesToFile_Tests.cs (1)

70Assert.Equal("\uBDEA", r.Lines[0].ItemSpec);

XmlPeek_Tests.cs (9)

81Assert.Equal(p.Result[i].ItemSpec, results[i]); 110Assert.Equal(p.Result[i].ItemSpec, results[i]); 127Assert.Equal("<Namespace Prefix=\"s\" Uri=\"http://nsurl\" />", p.Namespaces); 139Assert.Equal(p.Result[i].ItemSpec, results[i]); 161Assert.Equal(p.Result[i].ItemSpec, results[i]); 181Assert.Equal(p.Result[i].ItemSpec, results[i]); 198Assert.Equal(xmlInputPath, p.XmlInputPath.ItemSpec); 199Assert.Equal(_xmlFileNoNsNoDtd, p.XmlContent); 202Assert.Equal("//variable/@Name", p.Query);

XslTransformation_Tests.cs (5)

306Assert.Equal(_xmlDocument, t.XmlContent); 340Assert.Equal(_xslDocument, t.XslContent); 374Assert.Equal(String.Empty, engine.Log); // "The log should be empty" 459Assert.Equal("<Parameter " + res + "/>", t.Parameters); 891Assert.Equal(expectedOutput, fileContents);

ObjectModelHelpers.cs (6)

112Assert.Equal(itemInclude.ToUpperInvariant(), item.EvaluatedInclude.ToUpperInvariant()); 427Assert.Equal(expectedMetadataValue, actualMetadataValue); 828Assert.Equal(newExpectedProjectContents, newActualProjectContents); // "Project XML does not match expected XML. See 'Standard Out' tab for details." 1292Assert.Equal(xPair.Key, yPair.Key); 1293Assert.Equal(xPair.Value, yPair.Value); 1576Assert.Equal(newExpectedProjectContents, newActualProjectContents); // "Project XML does not match expected XML. See 'Standard Out' tab for details."

EscapingUtilities_Tests.cs (23)

NativeMethodsShared_Tests.cs (1)

152Assert.Equal(currentDirectory, Directory.GetCurrentDirectory());

ResourceUtilities_Tests.cs (14)

src\Analyzers\CSharp\Tests\NamingStyles\NamingStylesTests.cs (6)

1426Assert.Equal("c", symbolRenamedOperation._symbol.Name); 1427Assert.Equal("C", symbolRenamedOperation._newName); 1451Assert.Equal("test", symbolRenamedOperation._symbol.Name); 1452Assert.Equal("ITest", symbolRenamedOperation._newName); 1481Assert.Equal("arg", symbolRenamedOperation._symbol.Name); 1482Assert.Equal("TArg", symbolRenamedOperation._newName);

CommandLineDiagnosticFormatterTests.cs (10)

CommandLineTests.cs (206)

SarifErrorLoggerTests.cs (10)

52Assert.Equal("", outWriter.ToString().Trim()); 59Assert.Equal(expectedOutput, actualOutput); 91Assert.Equal(expectedOutput, actualOutput); 126Assert.Equal(expectedOutput, actualOutput); 160Assert.Equal(expectedOutput, actualOutput); 196Assert.Equal(expectedOutput, actualOutput); 231Assert.Equal(expectedOutput, actualOutput); 266Assert.Equal(expectedOutput, actualOutput); 301Assert.Equal(expectedOutput, actualOutput); 333Assert.Equal(expectedOutput, actualOutput);

SarifV2ErrorLoggerTests.cs (9)

501Assert.Equal(expectedOutput, actualOutput); 582Assert.Equal(expectedOutput, actualOutput); 650Assert.Equal(expectedOutput, actualOutput); 704Assert.Equal("CS5001", (string)results0["ruleId"]); 707Assert.Equal("CS0169", (string)results1["ruleId"]); 713Assert.Equal($"file:///{mappedDir.Path.Replace(@"\", "/")}/otherfile.cs", (string)resultFile["uri"]); 730Assert.Equal("CS5001", (string)results0["ruleId"]); 733Assert.Equal("CS0169", (string)results1["ruleId"]); 739Assert.Equal(expected: $"file:///{mappedDir.Path.Replace(@"\", "/")}/otherfile.cs", (string)physicalLocation["artifactLocation"]["uri"]);

TouchedFileLoggingTests.cs (7)

54Assert.Equal("", outWriter.ToString().Trim()); 100Assert.Equal("", outWriter.ToString().Trim()); 134Assert.Equal(string.Empty, outWriter.ToString().Trim()); 176Assert.Equal(string.Empty, writer.ToString().Trim()); 178Assert.Equal(string.Format(@" 235Assert.Equal(string.Join("\r\n", expected), 239Assert.Equal(string.Join("\r\n", expected),

CodeActions\MoveType\MoveTypeTests.MoveScope.cs (1)

939Assert.Equal(expectedCode, formattedText.ToString());

CodeActions\PreviewTests.cs (1)

121Assert.Equal(ChangedDocumentText, text);

CodeActions\PullMemberUp\CSharpPullMemberUpTests.cs (1)

49Assert.Equal(actions.First().Title, FeaturesResources.Pull_members_up_to_base_type);

CodeActions\SyncNamespace\CSharpSyncNamespaceTestsBase.cs (2)

199Assert.Equal(oldRefText, newRefText); 206Assert.Equal(expectedSourceReference, actualRefText);

CommentSelection\CSharpCommentSelectionTests.cs (1)

143Assert.Equal(expected, doc.GetTextBuffer().CurrentSnapshot.GetText());

Completion\ArgumentProviders\ArgumentProviderOrderTests.cs (4)

88Assert.Equal(orderedCSharpArgumentProviders.Last().Metadata.Name, Assert.Single(orderedCSharpArgumentProviders[i].Metadata.BeforeTyped)); 92Assert.Equal(orderedCSharpArgumentProviders[i - 1].Metadata.Name, after); 105Assert.Equal("FirstBuiltInArgumentProvider", firstArgumentProvider.Metadata.Name); 116Assert.Equal("LastBuiltInArgumentProvider", lastArgumentProvider.Metadata.Name);

Completion\CompletionProviders\CompletionProviderOrderTests.cs (4)

120Assert.Equal(orderedCSharpCompletionProviders.Last().Metadata.Name, Assert.Single(orderedCSharpCompletionProviders[i].Metadata.BeforeTyped)); 124Assert.Equal(orderedCSharpCompletionProviders[i - 1].Metadata.Name, after); 137Assert.Equal("FirstBuiltInCompletionProvider", firstCompletionProvider.Metadata.Name); 148Assert.Equal("LastBuiltInCompletionProvider", lastCompletionProvider.Metadata.Name);

Completion\CompletionProviders\ConversionCompletionProviderTests.cs (13)

56c => Assert.Equal("SomeText0", c.DisplayText), 57c => Assert.Equal("SomeText1", c.DisplayText), 58c => Assert.Equal("SomeText2", c.DisplayText), 59c => Assert.Equal("SomeText3", c.DisplayText), 60c => Assert.Equal("\uD884\uDF4AStartWith_3134A_Identifier", c.DisplayText), 61c => Assert.Equal("\uffdcStartWith_FFDC_Identifier", c.DisplayText), 65Assert.Equal("float", c.DisplayText); 66Assert.Equal("\uFFFD001_float", c.SortText); 67Assert.Equal("float", c.FilterText); 251i => Assert.Equal(displayText1, i.DisplayText), 252i => Assert.Equal(displayText2, i.DisplayText)); 279i => Assert.Equal("float", i.DisplayText), 280i => Assert.Equal("int", i.DisplayText));

Completion\CompletionProviders\DeclarationNameCompletionProviderTests_NameDeclarationInfoTests.cs (1)

778Assert.Equal(typeName, result.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat));

Completion\CompletionProviders\OperatorCompletionProviderTests.cs (25)

Completion\CompletionProviders\OverrideCompletionProviderTests.cs (5)

2485Assert.Equal(actualExpectedCode, actualCodeAfterCommit); 2738Assert.Equal(actualExpectedCode, actualCodeAfterCommit); 2793Assert.Equal(actualExpectedCode, actualCodeAfterCommit); 3268Assert.Equal(after, actualCodeAfterCommit); 3361Assert.Equal("<Clone>$", cloneMemberName);

EditorConfigSettings\Updater\SettingsUpdaterTests.cs (5)

69Assert.Equal(updatedEditorConfig, result?.ToString()); 78Assert.Equal(updatedEditorConfig, result?.ToString()); 415Assert.Equal(ExpectedInitialEditorConfig, fileText); 423Assert.Equal(ExpectedEditorConfigAfterAllSeveritiesChanged, fileText); 433Assert.Equal(ExpectedEditorConfigAfterSymbolSpecChange, fileText);

EncapsulateField\EncapsulateFieldTestState.cs (1)

71Assert.Equal(expected, _testDocument.GetTextBuffer().CurrentSnapshot.GetText().ToString());

ExtractInterface\ExtractInterfaceTests.cs (5)

511Assert.Equal(""" 551Assert.Equal(""" 592Assert.Equal(""" 903Assert.Equal(expectedInterfaceCode, interfaceCode); 1060Assert.Equal("""

ExtractMethod\ExtractMethodBase.cs (1)

62Assert.Equal(expected, subjectBuffer.CurrentSnapshot.GetText());

ExtractMethod\MiscTests.cs (2)

67Assert.Equal(expected, rootWithTriviaRestored.ToFullString()); 116Assert.Equal(expected, rootWithTriviaRestored.ToFullString());

FixInterpolatedVerbatimString\FixInterpolatedVerbatimStringCommandHandlerTests.cs (4)

66Assert.Equal(expectedOutput, view.TextBuffer.CurrentSnapshot.GetText()); 73Assert.Equal(quoteCharSnapshotText, view.TextBuffer.CurrentSnapshot.GetText()); 87Assert.Equal(quoteCharSnapshotText, view.TextBuffer.CurrentSnapshot.GetText()); 94Assert.Equal(originalSnapshotText, view.TextBuffer.CurrentSnapshot.GetText());

Formatting\CodeCleanupTests.cs (2)

828Assert.Equal(expected, actual.ToString()); 931Assert.Equal(expected, actual.ToString());

Formatting\FormattingEngineTests.cs (1)

444Assert.Equal(expected, node.ToFullString());

Formatting\Indentation\SmartTokenFormatterFormatRangeTests.cs (2)

3386Assert.Equal(expected, newSnapshot.GetText()); 3445Assert.Equal(expected, actual);

Formatting\Indentation\SmartTokenFormatterFormatTokenTests.cs (1)

616Assert.Equal(expected, actual);

InlineDiagnostics\InlineDiagnosticsTaggerProviderTests.cs (2)

26Assert.Equal(PredefinedErrorTypeNames.SyntaxError, firstSpan.Tag.ErrorType); 34Assert.Equal(PredefinedErrorTypeNames.SyntaxError, firstSpan.Tag.ErrorType);

Interactive\NavigateTo\InteractiveNavigateToTests.cs (5)

473Assert.Equal("Name", itemDisplay.Name); 474Assert.Equal(string.Format(FeaturesResources.in_0_project_1, "DogBed", "Test"), itemDisplay.AdditionalInformation); 480Assert.Equal("Name", itemDisplay.Name); 481Assert.Equal(string.Format(FeaturesResources.in_0_project_1, "Goo", "Test"), itemDisplay.AdditionalInformation); 621Assert.Equal(value, descriptionItem.Details.Single().Text);

NavigateTo\NavigateToTests.cs (5)

674Assert.Equal("Name", itemDisplay.Name); 675Assert.Equal(string.Format(FeaturesResources.in_0_project_1, "DogBed", "Test"), itemDisplay.AdditionalInformation); 681Assert.Equal("Name", itemDisplay.Name); 682Assert.Equal(string.Format(FeaturesResources.in_0_project_1, "Goo", "Test"), itemDisplay.AdditionalInformation); 1011Assert.Equal(value, descriptionItem.Details.Single().Text);

PdbSourceDocument\ImplementationAssemblyLookupServiceTests.cs (12)

QuickInfo\DiagnosticAnalyzerQuickInfoSourceTests.cs (1)

184Assert.Equal(expectedDescription, description.Text);

QuickInfo\SyntacticQuickInfoSourceTests.cs (1)

575Assert.Equal(expectedContent, actualText);

SplitStringLiteral\SplitStringLiteralCommandHandlerTests.cs (2)

99Assert.Equal(expectedOutput, textBuffer.CurrentSnapshot.AsText().ToString()); 109Assert.Equal(originalSnapshot.GetText(), currentSnapshot.GetText());

StringCopyPaste\StringCopyPasteCommandHandlerTests.cs (3)

71Assert.Equal(massaged, TextView.TextSnapshot.GetText()); 150Assert.Equal(expected, finalText); 174Assert.Equal(expected, finalText);

StringIndentation\StringIndentationTests.cs (1)

37Assert.Equal(contents, actual);

SymbolKey\SymbolKeyErrorTypeTests.cs (1)

397Assert.Equal(symbol.ToDisplayString(), resolution.Symbol!.ToDisplayString());

SymbolKey\SymbolKeyTests.cs (1)

172Assert.Equal("global::ConditionalWeakTableTest<TKey!, TValue!>.CreateValueCallback!", parameterType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat.WithMiscellaneousOptions(SymbolDisplayMiscellaneousOptions.IncludeNotNullableReferenceTypeModifier)));

TypeInferrer\TypeInferrerTests.cs (1)

44Assert.Equal(expectedType, typeSyntax.ToString());

Workspaces\WorkspaceTests_EditorFeatures.cs (18)

245Assert.Equal(type.Identifier.ValueText, typeName); 515Assert.Equal("public class X { }", docZText.ToString()); 729Assert.Equal(startText, (await workspace.CurrentSolution.GetDocument(document.Id).GetTextAsync()).ToString()); 736Assert.Equal(startText, (await workspace.CurrentSolution.GetDocument(document.Id).GetTextAsync()).ToString()); 739Assert.Equal(startText, buffer.CurrentSnapshot.GetText()); 744Assert.Equal(newText, buffer.CurrentSnapshot.GetText()); 1064Assert.Equal("some text", (await additionalDocument.GetTextAsync()).ToString()); 1088Assert.Equal("root = true", (await analyzerConfigDocument.GetTextAsync()).ToString()); 1119Assert.Equal(newText, buffer.CurrentSnapshot.GetText()); 1152Assert.Equal(newText, buffer.CurrentSnapshot.GetText()); 1255Assert.Equal("original.config", workspace.CurrentSolution.GetProject(project1.Id).AdditionalDocuments.Single().Name); 1291Assert.Equal("original.config", workspace.CurrentSolution.GetProject(project1.Id).AnalyzerConfigDocuments.Single().Name); 1321Assert.Equal("original.config", workspace.CurrentSolution.GetProject(project1.Id).AdditionalDocuments.Single().Name); 1349Assert.Equal("original.config", workspace.CurrentSolution.GetProject(project1.Id).AnalyzerConfigDocuments.Single().Name); 1430Assert.Equal(originalText, (await eventArgs[0].OldSolution.GetDocument(originalDocumentId).GetTextAsync().ConfigureAwait(false)).ToString()); 1431Assert.Equal(originalText, (await eventArgs[1].OldSolution.GetDocument(originalDocumentId).GetTextAsync().ConfigureAwait(false)).ToString()); 1433Assert.Equal(updatedText, (await eventArgs[0].NewSolution.GetDocument(originalDocumentId).GetTextAsync().ConfigureAwait(false)).ToString()); 1434Assert.Equal(updatedText, (await eventArgs[1].NewSolution.GetDocument(originalDocumentId).GetTextAsync().ConfigureAwait(false)).ToString());

EmbeddedLanguages\Json\CSharpJsonParserTests_NstTests.cs (1)

21Assert.Equal(expected.Replace("\"", "\"\""), actualTree);

EmbeddedLanguages\RegularExpressions\CSharpRegexParserTests.cs (1)

63Assert.Equal(expected.Replace("\"", DoubleQuoteEscaping), actual);

Recommendations\RecommenderTests.cs (1)

99Assert.Equal(KeywordText, result!.Keyword);

BreakingChanges.cs (2)

199Assert.Equal(text, tree.GetCompilationUnitRoot().ToFullString()); 218Assert.Equal(text, tree.GetCompilationUnitRoot().ToFullString());

CodeGen\CodeGenCapturing.cs (3)

180Assert.Equal("field_0", expr); 189Assert.Equal("field_0 + field_1 + field_2", expr); 198Assert.Equal("field_2 + captureVar_0 + captureVar_1", expr);

CodeGen\CodeGenCheckedTests.cs (3)

2916Assert.Equal("x", xNode.ToString()); 2923Assert.Equal("checked(x)", checkedNode.ToString()); 2948Assert.Equal("x", xNode.ToString());

CodeGen\CodeGenDeconstructTests.cs (111)

CodeGen\CodeGenDynamicTests.cs (4)

605Assert.Equal("System.Runtime.CompilerServices.CallSite<System.Action<System.Runtime.CompilerServices.CallSite, object, int, int, int>>", 613Assert.Equal("<>p__0", field.Name); 617Assert.Equal("<>p__0", field.Name); 655Assert.Equal("System.Runtime.CompilerServices.DynamicAttribute", attributes[0].AttributeClass.ToDisplayString());

CodeGen\CodeGenFunctionPointersTests.cs (11)

2608Assert.Equal(intermediate.Display, module.ReferencedAssemblies[1].Name); 5405Assert.Equal("System.Runtime.CompilerServices.NullableAttribute({0, 1, 1, 1})", getAttribute("F1")); 5406Assert.Equal("System.Runtime.CompilerServices.NullableAttribute({0, 1, 2, 1})", getAttribute("F2")); 5407Assert.Equal("System.Runtime.CompilerServices.NullableAttribute({0, 1, 1, 2})", getAttribute("F3")); 5408Assert.Equal("System.Runtime.CompilerServices.NullableAttribute({0, 2, 1, 1})", getAttribute("F4")); 5409Assert.Equal("System.Runtime.CompilerServices.NullableAttribute({0, 2, 2, 2})", getAttribute("F5")); 5410Assert.Equal("System.Runtime.CompilerServices.NullableAttribute({0, 0, 1, 0, 0, 0, 1, 0, 2})", getAttribute("F6")); 5474Assert.Equal(expectedAttribute, field.GetAttributes().Single().ToString()); 5560Assert.Equal(expectedAttribute, f.GetAttributes().Single().ToString()); 5609Assert.Equal("System.Runtime.CompilerServices.DynamicAttribute({false, false, false, false, false, true, false, true})", param.GetAttributes().Single().ToString()); 7417Assert.Equal("a => a", lambda.ToString());

CodeGen\CodeGenInterpolatedString.cs (4)

39Assert.Equal("@$\"", token1.Text); 40Assert.Equal("@$\"", token1.ValueText); 43Assert.Equal("$@\"", token2.Text); 44Assert.Equal("$@\"", token2.ValueText);

CodeGen\CodeGenLocalFunctionTests.cs (4)

5774Assert.Equal("something.dll", importData.ModuleName); 5775Assert.Equal("local1", importData.EntryPointName); 5846Assert.Equal("something.dll", importData.ModuleName); 5847Assert.Equal("a", importData.EntryPointName);

CodeGen\CodeGenRefLocalTests.cs (1)

4079Assert.Equal("C", alias.Target.ToDisplayString());

CodeGen\CodeGenScriptTests.cs (3)

499Assert.Equal("System.Threading.Tasks.Task<object>", ((MethodSymbol)methodData.Method).ReturnType.ToDisplayString()); 559Assert.Equal("System.Threading.Tasks.Task<object>", ((MethodSymbol)methodData.Method).ReturnType.ToDisplayString()); 587Assert.Equal("System.Threading.Tasks.Task<object>", ((MethodSymbol)methodData.Method).ReturnType.ToDisplayString());

CodeGen\CodeGenTupleEqualityTests.cs (68)

363Assert.Equal("(x, x)", tupleX.ToString()); 368Assert.Equal("x", lastX.ToString()); 382Assert.Equal("(y, y)", tupleY.ToString()); 386Assert.Equal("y", lastY.ToString()); 717Assert.Equal("t", t.ToString()); 727Assert.Equal("(1L, 2)", tuple.ToString()); 794Assert.Equal("(s, null)", tuple1.ToString()); 807Assert.Equal("(null, s)", tuple2.ToString()); 858Assert.Equal("t1", t1.ToString()); 867Assert.Equal("(1L, 2)", tuple.ToString()); 875Assert.Equal("2", two.ToString()); 906Assert.Equal("t1", t1.ToString()); 915Assert.Equal("(1L, 2)", tuple.ToString()); 923Assert.Equal("2", two.ToString()); 955Assert.Equal("t1", t1.ToString()); 965Assert.Equal("(1L, t2)", tuple.ToString()); 971Assert.Equal("t2", t2.ToString()); 1002Assert.Equal("(null, null)", tuple.ToString()); 1010Assert.Equal("(1, (null, null))", lastTuple.ToString()); 1060Assert.Equal("default", literal.ToString()); 1094Assert.Equal("default", literal.ToString()); 1126Assert.Equal("default", literal.ToString()); 1157Assert.Equal("default", literal.ToString()); 1313Assert.Equal("(default, default)", lastTuple.ToString()); 1318Assert.Equal("default", lastDefault.ToString()); 1400Assert.Equal("null", nullLiteral.ToString()); 1404Assert.Equal("null", nullLiteral2.ToString()); 1413Assert.Equal("default", defaultLiteral.ToString()); 1469Assert.Equal("default", defaultLiteral.ToString()); 1498Assert.Equal("((null, null), t)", tuple.ToString()); 1507Assert.Equal("t", t.ToString()); 1518Assert.Equal("(null, null)", nestedTuple.ToString()); 1529Assert.Equal("null", nestedNull.ToString()); 1560Assert.Equal("null", literal.ToString()); 1569Assert.Equal("(null, null)", tuple.ToString()); 1595Assert.Equal("2", lastLiteral.ToString()); 1620Assert.Equal("((null, 2), null)", rightTuple.ToString()); 1626Assert.Equal("(null, 2)", nestedTuple.ToString()); 1632Assert.Equal("2", two.ToString()); 1676Assert.Equal("(null, null, null, null)", tuple1.ToString()); 1684Assert.Equal("(null, x => x, Main, (int i) => { int j = 0; return i + j; })", tuple2.ToString()); 1708Assert.Equal("i + j", addition.ToString()); 1777Assert.Equal("(s, s)", tuple1.ToString()); 1783Assert.Equal("(1, () => { })", tuple2.ToString()); 1919Assert.Equal("(d1, null)", tuple1.ToString()); 1925Assert.Equal("(null, d2)", tuple2.ToString()); 2576Assert.Equal("(0, 1)", intTuple.ToString()); 2584Assert.Equal("(this, this)", lastTuple.ToString()); 2644Assert.Equal("t1", t1.ToString()); 3281Assert.Equal("nt1", nt1.ToString()); 3287Assert.Equal("nt2", nt2.ToString()); 3687Assert.Equal("nt1", nt1.ToString()); 3693Assert.Equal("nt2", nt2.ToString()); 3811Assert.Equal("nt1", nt1.ToString()); 3817Assert.Equal("nt2", nt2.ToString()); 3914Assert.Equal("nt1", nt1.ToString()); 3920Assert.Equal("nt2", nt2.ToString()); 4039Assert.Equal("(1, 2)", tuple.ToString()); 4045Assert.Equal("nt", nt.ToString()); 4084Assert.Equal("(1, 2) == nt", comparison.ToString()); 4087Assert.Equal("(1, 2)", tuple.ToString()); 4093Assert.Equal("nt", nt.ToString()); 4185Assert.Equal("null", lastNull.ToString()); 4277Assert.Equal("t.Rest == t.Rest", comparison.ToString()); 5162Assert.Equal("((string, (byte, long))) (null, (1, 2L))", leftCast.ToString()); 5170Assert.Equal("(null, (1, 2L))", leftTuple.ToString()); 5178Assert.Equal("null", leftNull.ToString()); 5186Assert.Equal("(1, 2L)", leftNestedTuple.ToString());

CodeGen\CodeGenTupleTest.cs (154)

CodeGen\FixedSizeBufferTests.cs (2)

577Assert.Equal("x", f.Name); 579Assert.Equal("int*", f.TypeWithAnnotations.ToString());

CodeGen\GotoTest.cs (2)

1150Assert.Equal("L0", symbol.Name); 1163Assert.Equal("C", symbol.Name);

CodeGen\IndexAndRangeTests.cs (5)

40Assert.Equal(methodName, symbol.Name); 42Assert.Equal(containingTypeName, symbol.ContainingType.Name); 1003Assert.Equal("S", property.ContainingType.Name); 3862Assert.Equal("c", receivers[0].ToString()); 3865Assert.Equal("c", receivers[1].ToString());

CodeGen\ObjectAndCollectionInitializerTests.cs (2)

1108Assert.Equal("new A {[x++] = { } }", node.ToString()); 3590Assert.Equal("new C(pp) { X = {[Index] = {[0] = 2, [1] = 3} } }", node.ToString());

Emit\CompilationEmitTests.cs (32)

Emit\EmitMetadataTests.cs (6)

601Assert.Equal(WellKnownMemberNames.InstanceConstructorName, ctor.Name); 622Assert.Equal(WellKnownMemberNames.StaticConstructorName, cctor.Name); 1406Assert.Equal(WellKnownMemberNames.EnumBackingFieldName, field.Name); 2382Assert.Equal(".text", sections[0].Name); 2393Assert.Equal(".reloc", sections[1].Name); 2520Assert.Equal(".text", sections[0].Name);

Emit\GeneratedNamesTests.cs (1)

37Assert.Equal(name, GeneratedNames.MakeSynthesizedDelegateName(actualByRefs, actualReturnsVoid, actualGeneration));

Emit\InAttributeModifierTests.cs (1)

4569Assert.Equal(typeName, modifier.Modifier.ToDisplayString());

Emit\NoPiaEmbedTypes.cs (37)

Emit\ResourceTests.cs (13)

94Assert.Equal(expected, versionData); 112Assert.Equal(expected, mftData); 120Assert.Equal(" ", fileVer.LegalCopyright); 194Assert.Equal(expected, versionData); 202Assert.Equal("Microsoft Corporation", fileVer.CompanyName); 436Assert.Equal(resourceFileName, rInfo.FileName); 536Assert.Equal(c_mod1.SourceModule.Name, rInfo.FileName); 584Assert.Equal(c_mod2.SourceModule.Name, rInfo.FileName); 593Assert.Equal(c_mod2.SourceModule.Name, rInfo.FileName); 654Assert.Equal(c_mod3.SourceModule.Name, rInfo.FileName); 689Assert.Equal(c_mod1.SourceModule.Name, rInfo.FileName); 698Assert.Equal(c_mod3.SourceModule.Name, rInfo.FileName); 882Assert.Equal(expected, versionData);

CodeGen\CodeGenMethodGroupConversionCachingTests.cs (1)

6322Assert.Equal("G", typeParameter.Name);

CodeGen\IndexAndRangeTests.cs (18)

Emit\EditAndContinue\EditAndContinueTests.cs (3)

12509Assert.Equal("20-01-01-08", BitConverter.ToString(value0)); 12519Assert.Equal("07-02-0E-0C", BitConverter.ToString(value1)); 12524Assert.Equal("07-03-0E-0C-02", BitConverter.ToString(value2));

Emit\EditAndContinue\SymbolMatcherTests.cs (13)

513Assert.Equal("x1", mappedX1.Name); 583Assert.Equal("x1", mappedX1.Name); 963Assert.Equal("I<System.Int32,System.Boolean>.Item", ((PropertySymbol)mappedProperty.GetInternalSymbol()).MetadataName); 1137Assert.Equal("y1", mappedY1.Name); 1138Assert.Equal("y2", mappedY2.Name); 1495Assert.Equal("<>9__0_0", mappedField1.Name); 1496Assert.Equal("<>9__0_1", mappedField2.Name); 1497Assert.Equal("<>9__0_2", mappedField3.Name); 1545Assert.Equal("<>f__AnonymousDelegate0", field0.GetType(emitContext).ToString()); 1549Assert.Equal("<>9__0_0", field1.Name); 1693Assert.Equal("<>9__0_0", mappedField1.Name); 1694Assert.Equal("<>9__0_1", mappedField2.Name); 1695Assert.Equal("<>9__0_2", mappedField3.Name);

Emit\NumericIntPtrTests.cs (14)

6016Assert.Equal(AsNative(sourceType), typeInfo.Type.ToString()); 6017Assert.Equal(AsNative(destType), typeInfo.ConvertedType.ToString()); 10381Assert.Equal("nint", type.ToDisplayString(SymbolDisplayFormat.TestFormat)); 10382Assert.Equal("System.IntPtr", type.ToDisplayString(SymbolDisplayFormat.TestFormat.WithCompilerInternalOptions(SymbolDisplayCompilerInternalOptions.UseNativeIntegerUnderlyingType))); 10383Assert.Equal("nint", type.ToDisplayString(SymbolDisplayFormat.TestFormat.WithMiscellaneousOptions(SymbolDisplayMiscellaneousOptions.UseSpecialTypes))); 10390Assert.Equal("nuint", type.ToDisplayString(SymbolDisplayFormat.TestFormat)); 10391Assert.Equal("System.UIntPtr", type.ToDisplayString(SymbolDisplayFormat.TestFormat.WithCompilerInternalOptions(SymbolDisplayCompilerInternalOptions.UseNativeIntegerUnderlyingType))); 10392Assert.Equal("nuint", type.ToDisplayString(SymbolDisplayFormat.TestFormat.WithMiscellaneousOptions(SymbolDisplayMiscellaneousOptions.UseSpecialTypes))); 11174Assert.Equal(type, cref.ToString()); 11197Assert.Equal("nint", cref.ToString()); 11225Assert.Equal(fieldName, cref.ToString()); 11250Assert.Equal("@nint", cref.ToString()); 11295Assert.Equal("nint.Zero", cref.ToString()); 11825symbolValidator: module => Assert.Equal("", NativeIntegerAttributesVisitor.GetString((PEModuleSymbol)module)),

PDB\CSharpDeterministicBuildCompilationTests.cs (2)

46Assert.Equal(langVersion, pdbOptions["language-version"]); 47Assert.Equal(sourceFileCount.ToString(), pdbOptions["source-file-count"]);

PDB\PDBEmbeddedSourceTests.cs (1)

130Assert.Equal(source, embeddedSource.Text.ToString());

PDB\PDBTests.cs (1)

606Assert.Equal("Main", mdReader.GetString(methodDef.Name));

PDB\PortablePdbTests.cs (4)

203Assert.Equal("d.pdb", codeViewData.Path); 207Assert.Equal("SHA512", checksumData.AlgorithmName); 264Assert.Equal("d.pdb", codeViewData.Path); 268Assert.Equal("SHA384", checksumData.AlgorithmName);

Attributes\AttributeTests.cs (96)

Attributes\AttributeTests_Assembly.cs (40)

Attributes\AttributeTests_IsByRefLike.cs (6)

675Assert.Equal("System.ObsoleteAttribute", attribute.AttributeClass.ToDisplayString()); 760Assert.Equal("Windows.Foundation.Metadata.DeprecatedAttribute", attribute.AttributeClass.ToDisplayString()); 813Assert.Equal("Windows.Foundation.Metadata.DeprecatedAttribute", attributes[1].AttributeClass.ToDisplayString()); 816Assert.Equal("System.ObsoleteAttribute", attribute.AttributeClass.ToDisplayString()); 1098Assert.Equal(WellKnownTypes.GetMetadataName(WellKnownType.System_Runtime_CompilerServices_CompilerGeneratedAttribute), attributes[0].AttributeClass.ToDisplayString()); 1099Assert.Equal(AttributeDescription.CodeAnalysisEmbeddedAttribute.FullName, attributes[1].AttributeClass.ToDisplayString());

Attributes\AttributeTests_NativeInteger.cs (22)

Attributes\AttributeTests_Nullable.cs (3)

580Assert.Equal("NullableAttribute", attributeType.Name); 581Assert.Equal(assemblyName, attributeType.ContainingAssembly.Name); 4207Assert.Equal(expectedDisplay, type.ToDisplayString(_displayFormat));

Attributes\AttributeTests_ReadOnlyStruct.cs (2)

665Assert.Equal(WellKnownTypes.GetMetadataName(WellKnownType.System_Runtime_CompilerServices_CompilerGeneratedAttribute), attributes[0].AttributeClass.ToDisplayString()); 666Assert.Equal(AttributeDescription.CodeAnalysisEmbeddedAttribute.FullName, attributes[1].AttributeClass.ToDisplayString());

Attributes\AttributeTests_RefReadOnly.cs (2)

2557Assert.Equal(WellKnownTypes.GetMetadataName(WellKnownType.System_Runtime_CompilerServices_CompilerGeneratedAttribute), attributes[0].AttributeClass.ToDisplayString()); 2558Assert.Equal(AttributeDescription.CodeAnalysisEmbeddedAttribute.FullName, attributes[1].AttributeClass.ToDisplayString());

Attributes\AttributeTests_Synthesized.cs (13)

Attributes\AttributeTests_Tuples.cs (4)

256Assert.Equal(ToTestString(srcType.BaseType()), ToTestString(peType.BaseType())); 486Assert.Equal("Base1", field6Type.Name); 889Assert.Equal(name, argsReader.ReadSerializedString()); 986Assert.Equal(name, argsReader.ReadSerializedString());

Attributes\AttributeTests_WellKnownAttributes.cs (33)

Diagnostics\DiagnosticAnalyzerTests.cs (24)

Diagnostics\GetDiagnosticsTests.cs (3)

758Assert.Equal(RegisterSyntaxTreeCancellationAnalyzer.DiagnosticId, diagnostic.Id); 1447Assert.Equal(analyzerDiagnostic.ToString(), compilationDiagnostic.ToString()); 1550Assert.Equal("int x11 = 0;", localDecl.ToString());

FlowAnalysis\FlowTests.cs (3)

5846Assert.Equal("A(10, Prop = 40)", attributes[0].Item1.ToString()); 5847Assert.Equal("A(20, Prop = 50)", attributes[1].Item1.ToString()); 5848Assert.Equal("A(30, Prop = 60)", attributes[2].Item1.ToString());

FlowAnalysis\IterationJumpYieldStatementTests.cs (54)

FlowAnalysis\PatternMatchingTest5.cs (4)

36Assert.Equal("s", GetSymbolNamesJoined(dataFlowAnalysisResults.DataFlowsIn)); 39Assert.Equal("s", GetSymbolNamesJoined(dataFlowAnalysisResults.ReadInside)); 41Assert.Equal("o", GetSymbolNamesJoined(dataFlowAnalysisResults.ReadOutside)); 42Assert.Equal("o, s", GetSymbolNamesJoined(dataFlowAnalysisResults.WrittenOutside));

FlowAnalysis\PatternsVsRegions.cs (30)

FlowAnalysis\RegionAnalysisTests.cs (1564)

FlowAnalysis\StructTests.cs (3)

129Assert.Equal("s2", GetSymbolNamesJoined(dataFlowAnalysisResults.DataFlowsIn)); 130Assert.Equal("s4", GetSymbolNamesJoined(dataFlowAnalysisResults.DataFlowsOut)); 131Assert.Equal("s3, s4", GetSymbolNamesJoined(dataFlowAnalysisResults.AlwaysAssigned));

FlowAnalysis\TryLockUsingStatementTests.cs (198)

RefReadonlyParameterTests.cs (4)

1485Assert.Equal("Assembly2", modifier.ContainingAssembly.Name); 1497Assert.Equal("Assembly1", modifier.ContainingAssembly.Name); 6700Assert.Equal("I.M(in int)", m1.ExplicitInterfaceImplementations.Single().ToDisplayString()); 6707Assert.Equal("I.M(ref readonly int)", m2.ExplicitInterfaceImplementations.Single().ToDisplayString());

RefStructInterfacesTests.cs (2)

7985Assert.Equal("new S()", foreachSyntax.Expression.ToString()); 11067Assert.Equal("new S1()", foreachSyntax.Expression.ToString());

Semantics\CollectionExpressionTests.cs (40)

4793Assert.Equal("Program.AsCollection([1, 2, 3])", invocation.ToFullString()); 10287Assert.Equal("object[]", resultType); 10327Assert.Equal("List<int>", resultType); 14366Assert.Equal("(MyCollection<int>?)[1, 2, 3]", cast.ToFullString()); 14371Assert.Equal("[1, 2, 3]", value.ToFullString()); 14490Assert.Equal("(MyCollection<int>)/*<bind>*/[1, 2, 3]/*</bind>*/", cast.ToFullString()); 14495Assert.Equal("[1, 2, 3]/*</bind>*/", value.ToFullString()); 14573Assert.Equal("[2]", nestedCollection.ToFullString()); 14662Assert.Equal("[2]", nestedCollection.ToFullString()); 17096Assert.Equal("Create1", methodName); 19197Assert.Equal("Create", methodName); 19203Assert.Equal("Create", methodName); 19257Assert.Equal("Create", methodName); 19263Assert.Equal("Create", methodName); 19367Assert.Equal("Create", methodName); 19374Assert.Equal("Create", methodName); 28792Assert.Equal("[..values]", collection.ToString()); 29115Assert.Equal("[]", collection.ToString()); 29158Assert.Equal("[1, 2, 3]", collections[0].ToString()); 29163Assert.Equal("[]", collections[1].ToString()); 29205Assert.Equal("[1, 2, 3]", collection.ToString()); 32227Assert.Equal("[element]", collection.ToFullString()); 32233Assert.Equal("element", element.ToFullString()); 32324Assert.Equal("element1", element1.ToFullString()); 32330Assert.Equal("element2", element2.ToFullString()); 32366Assert.Equal("(string?)element1", element1.ToFullString()); 32372Assert.Equal("element2", element2.ToFullString()); 32411Assert.Equal("element1", element1.ToFullString()); 32417Assert.Equal("element2", element2.ToFullString()); 37387Assert.Equal("object.Object()", info.Symbol.ToDisplayString()); 37422Assert.Equal("object.Object()", info.Symbol.ToDisplayString()); 37459Assert.Equal("object.Object()", info.Symbol.ToDisplayString()); 37496Assert.Equal("object.Object()", info.Symbol.ToDisplayString()); 37533Assert.Equal("object.Object()", info.Symbol.ToDisplayString()); 37570Assert.Equal("object.Object()", info.Symbol.ToDisplayString()); 37613Assert.Equal("object.Object()", info.Symbol.ToDisplayString()); 41431Assert.Equal("y", expr.ToString()); 41486Assert.Equal("y", expr.ToString()); 41533Assert.Equal("y", expr.ToString()); 41585Assert.Equal("y", expr.ToString());

Semantics\ExperimentalAttributeTests.cs (36)

Semantics\InlineArrayTests.cs (17)

Semantics\LockTests.cs (1)

185Assert.Equal("l", localSymbol.Name);

Semantics\OutVarTests.cs (44)

Semantics\ParamsCollectionTests.cs (4)

121Assert.Equal("Test()", nodes[0].ToString()); 134Assert.Equal("Test(1)", nodes[1].ToString()); 150Assert.Equal("Test(2, 3)", nodes[2].ToString()); 9029Assert.Equal("System.Diagnostics.CodeAnalysis.UnscopedRefAttribute", p1.GetAttributes().Single().ToString());

Semantics\PatternMatchingTestBase.cs (5)

82Assert.Equal(designation.Identifier.ValueText, symbol.Name); 143Assert.Equal(designation.Identifier.ValueText, symbol.Name); 169Assert.Equal(declarator.Identifier.ValueText, symbol.Name); 183Assert.Equal(designation.Identifier.ValueText, symbol.Name); 245Assert.Equal(designation.Identifier.ValueText, symbol.Name);

Semantics\PatternMatchingTests.cs (5)

3579Assert.Equal("o.Equals is()", node.ToString()); 4294Assert.Equal("int _", declaration1.ToString()); 4302Assert.Equal("var _", declaration2.ToString()); 4308Assert.Equal("int _", declaration3.ToString()); 4315Assert.Equal("var _", declaration4.ToString());

Semantics\PatternMatchingTests_ListPatterns.cs (20)

3331Assert.Equal(name, local.Name); 3338Assert.Equal(name, local.Name); 3643Assert.Equal(syntax, designation.ToString()); 3647Assert.Equal(declaredType, ((ILocalSymbol)symbol).Type.ToDisplayString()); 3652Assert.Equal(type, typeInfo.Type.ToDisplayString()); 3653Assert.Equal(type, typeInfo.ConvertedType.ToDisplayString()); 3688Assert.Equal(syntax, clause.Parent.Parent.ToString()); 3691Assert.Equal(type, typeInfo.Type.ToDisplayString()); 3692Assert.Equal(type, typeInfo.ConvertedType.ToDisplayString()); 3723Assert.Equal("item", itemDesignation.ToString()); 3738Assert.Equal("slice", sliceDesignation.ToString()); 4096Assert.Equal(name, local.Name); 4183Assert.Equal(name, local.Name); 4260Assert.Equal(name, local.Name); 4375Assert.Equal(name, local.Name); 4413Assert.Equal(syntax, designation.ToString()); 4417Assert.Equal(declaredType, ((ILocalSymbol)symbol).Type.ToDisplayString()); 4422Assert.Equal(type, typeInfo.Type.ToDisplayString()); 4423Assert.Equal(type, typeInfo.ConvertedType.ToDisplayString()); 4567Assert.Equal(name, local.Name);

Semantics\PatternMatchingTests2.cs (19)

725Assert.Equal("int", ((ILocalSymbol)symbol).Type.ToDisplayString()); 731Assert.Equal("int", typeInfo.Type.ToDisplayString()); 2021Assert.Equal("return obj is global::Class1 @class && this.i == @class.i;", returnStatement.ToString()); 2023Assert.Equal("return obj is Class1 @class && this.i == @class.i;", modifiedReturnStatement.ToString()); 2062Assert.Equal("return obj is global::Class1 @class;", returnStatement.ToString()); 2064Assert.Equal("return obj is Class1 @class;", modifiedReturnStatement.ToString()); 2164Assert.Equal(ex.Source, pat.ToString()); 2254Assert.Equal("T2 (var t3, t4: T4 t4) { V5 : T6 t5 }", patterns[0].ToString()); 2259Assert.Equal("var t3", patterns[1].ToString()); 2264Assert.Equal("T4 t4", patterns[2].ToString()); 2269Assert.Equal("T6 t5", patterns[3].ToString()); 2298Assert.Equal("Point(3, 4.0)", patterns[0].ToString()); 2303Assert.Equal("3", patterns[1].ToString()); 2308Assert.Equal("4.0", patterns[2].ToString()); 2344Assert.Equal("Point(3, 4.0) { Missing: Xyzzy }", patterns[0].ToString()); 2349Assert.Equal("3", patterns[1].ToString()); 2355Assert.Equal("4.0", patterns[2].ToString()); 2361Assert.Equal("Xyzzy", patterns[3].ToString()); 2368Assert.Equal("Q7 t", patterns[4].ToString());

Semantics\PatternMatchingTests3.cs (53)

Semantics\PatternMatchingTests4.cs (1)

4829Assert.Equal("x", x.ToString());

Semantics\PrimaryConstructorTests.cs (87)

Semantics\RecordTests.cs (86)

ConvertToRecord\ConvertToRecordCodeRefactoringTests.cs (1)

95Assert.Equal(codeAction.EquivalenceKey, action.EquivalenceKey);

EditAndContinue\SyntaxUtilitiesTests.cs (2)

107Assert.Equal("0", leftNode.ToString()); 157Assert.Equal("3", leftNode.ToString());

src\Analyzers\CSharp\Tests\NamingStyles\NamingStylesTests.cs (6)

1426Assert.Equal("c", symbolRenamedOperation._symbol.Name); 1427Assert.Equal("C", symbolRenamedOperation._newName); 1451Assert.Equal("test", symbolRenamedOperation._symbol.Name); 1452Assert.Equal("ITest", symbolRenamedOperation._newName); 1481Assert.Equal("arg", symbolRenamedOperation._symbol.Name); 1482Assert.Equal("TArg", symbolRenamedOperation._newName);

IOperation\IOperationTests.cs (5)

464Assert.Equal("(x, y, z) = (1, 2, 3)", assignments[0].ToString()); 470Assert.Equal("(x, y, z) = new C()", assignments[1].ToString()); 476Assert.Equal("var (a, b) = (1, 2)", assignments[2].ToString()); 559Assert.Equal("a.b", expr.ToString()); 564Assert.Equal("b", fieldOperation.Field.Name);

IOperation\IOperationTests_ILocalFunctionStatement.cs (2)

1800Assert.Equal("d1", localFunctionD1.Name); 1810Assert.Equal("d2", localFunctionD2.Name);

IOperation\IOperationTests_IVariableDeclaration.cs (3)

929Assert.Equal(@"10", literalExpr.ToString()); 936Assert.Equal(@"M2()", invocExpr.ToString()); 944Assert.Equal("M2", invocInfo.Symbol.MetadataName);

ObjectFormatterTests.cs (5)

29Assert.Equal("ArrayList(4) { 1, 2, true, \"goo\" }", str); 56Assert.Equal("Queue(3) { 1, 2, 3 }", str); 68Assert.Equal("Stack(3) { 3, 2, 1 }", str); 80Assert.Equal("SortedList(3) { { 1, 5 }, { 2, 6 }, { 3, 4 } }", str); 86Assert.Equal("SortedList(1) { { int[1] { 3 }, int[1] { 4 } } }", str);

CommandLineRunnerTests.cs (7)

257Assert.Equal( 269Assert.Equal( 286Assert.Equal( 298Assert.Equal( 313Assert.Equal( 594Assert.Equal(expectedOutput, PathUtilities.GetDirectoryName(path, isUnixLike: false)); 829Assert.Equal(

InteractiveSessionTests.cs (11)

166Assert.Equal("True False True", script.EvaluateAsync().Result.ToString()); 287Assert.Equal("bar", dllImport.EntryPoint); 288Assert.Equal("goo", dllImport.Value); 657Assert.Equal("HostObjectToString impl", state3.ReturnValue); 672Assert.Equal("System.Object", state2.ReturnValue); 1564Assert.Equal("2", s1.ReturnValue); 1931Assert.Equal("Bang!", state1.Exception.Message); 1958Assert.Equal("Bang!", state2.Exception.Message); 1986Assert.Equal("Bang!", state3.Exception.Message); 2006Assert.Equal("Bang 1!", state1.Exception.Message); 2014Assert.Equal("Bang 2!", state2.Exception.Message);

ObjectFormatterTests.cs (66)

PrintOptionsTests.cs (24)

ScriptTests.cs (5)

37Assert.Equal("1 + 2", script.Code); 50Assert.Equal("1 + 2", script.Code); 64Assert.Equal(state.Script.Code, compilation.SyntaxTrees.First().GetText().ToString()); 1098Assert.Equal(textFromStream, text); 1119Assert.Equal(filename, firstFrame.GetFileName());

Semantics\ArglistTests.cs (1)

965Assert.Equal("TypedReference", info.Symbol.Name);

Semantics\AwaitExpressionTests.cs (1)

85Assert.Equal("await x", awaitExpression.ToString());

Semantics\BindingAsyncTasklikeMoreTests.cs (6)

438Assert.Equal("C.MyTask", method.ReturnTypeWithAnnotations.ToDisplayString()); 442Assert.Equal("C.MyTask<int>", method.ReturnTypeWithAnnotations.ToDisplayString()); 519Assert.Equal("MyTask", method.ReturnTypeWithAnnotations.ToDisplayString()); 523Assert.Equal("MyTask<int>", method.ReturnTypeWithAnnotations.ToDisplayString()); 598Assert.Equal("MyTask", method.ReturnTypeWithAnnotations.ToDisplayString()); 602Assert.Equal("MyTask<T>", method.ReturnTypeWithAnnotations.ToDisplayString());

Semantics\BindingAwaitTests.cs (6)

Semantics\BindingTests.cs (19)

2728Assert.Equal("A.B<string>.M0", identifierNameM0.Parent.ToString()); 2740Assert.Equal("A.B<string>.M1", identifierNameM1.Parent.ToString()); 2786Assert.Equal("(MyDelegate<int>)MyMethod", identifiers[0].Parent.ToString()); 2789Assert.Equal("(MyDelegate<long>)MyMethod", identifiers[1].Parent.ToString()); 2792Assert.Equal("(MyDelegate<float>)MyMethod", identifiers[2].Parent.ToString()); 2795Assert.Equal("(MyDelegate<double>)MyMethod", identifiers[3].Parent.ToString()); 2839Assert.Equal("b.M0", identifierNameM0.Parent.ToString()); 2851Assert.Equal("b.M1", identifierNameM1.Parent.ToString()); 3038Assert.Equal("app.Use", node1.ToString()); 3053Assert.Equal("ctx.Authentication.AuthenticateAsync", node.ToString()); 3118Assert.Equal("app.Use", node1.ToString()); 3133Assert.Equal("ctx.Authentication.AuthenticateAsync", node.ToString()); 3191Assert.Equal("app.Use", node1.ToString()); 3207Assert.Equal("ctx.Authentication.AuthenticateAsync", node.ToString()); 3276Assert.Equal("app.Use", node1.ToString()); 3292Assert.Equal("ctx.Authentication.AuthenticateAsync", node.ToString()); 3381Assert.Equal("MathMin(0, 1)", node1.ToString()); 3733Assert.Equal("x.E1.E", node1.ToString()); 3737Assert.Equal("x.E1", node2.ToString());

Semantics\ColorColorTests.cs (15)

1258Assert.Equal(WellKnownMemberNames.DelegateInvokeName, parentInfo.Symbol.Name); // Succeeded even though the receiver has an error. 1818Assert.Equal("Lifetime", memberAccess.Expression.ToString()); 1819Assert.Equal("Lifetime.Persistent", memberAccess.ToString()); 1883Assert.Equal("E.A", node1.ToString()); 1884Assert.Equal("E", node1.Expression.ToString()); 1894Assert.Equal("= E", node2.Parent.ToString()); 1940Assert.Equal("E.A", node1.ToString()); 1941Assert.Equal("E", node1.Expression.ToString()); 1951Assert.Equal("= E", node2.Parent.ToString()); 1997Assert.Equal("E.A", node1.ToString()); 1998Assert.Equal("E", node1.Expression.ToString()); 2008Assert.Equal("= E", node2.Parent.ToString()); 2047Assert.Equal("E.A", node1.ToString()); 2048Assert.Equal("E", node1.Expression.ToString()); 2057Assert.Equal("= E", node2.Parent.ToString());

Semantics\ConditionalOperatorTests.cs (7)

1349Assert.Equal(".test", memberBinding.ToString()); 1350Assert.Equal("receiver?.test", access.ToString()); 1404Assert.Equal(".test", memberBinding.ToString()); 1405Assert.Equal(".test()", invocation.ToString()); 1406Assert.Equal("receiver?.test()", access.ToString()); 1450Assert.Equal(".test", memberBinding.ToString()); 1451Assert.Equal("receiver?.test", access.ToString());

Semantics\ConstantTests.cs (55)

Semantics\DeconstructionTests.cs (45)

Semantics\ExpressionBodiedMemberTests.cs (24)

Semantics\ForEachTests.cs (1)

3248Assert.Equal("C", boundNode.Expression.Type.ToDisplayString());

Semantics\FunctionPointerTests.cs (1)

3965Assert.Equal("delegate*<__arglist, void>", parameterDecls[1].ToString());

Semantics\GenericConstraintsTests.cs (1)

2879Assert.Equal("M<int>()", value.ToFullString());

Semantics\GlobalUsingDirectiveTests.cs (38)

Semantics\ImplicitObjectCreationTests.cs (13)

243Assert.Equal(constant, model.GetConstantValue(@new).Value?.ToString()); 1714Assert.Equal(expression, invocation.ToString()); 1981Assert.Equal("new(x)", def.ToString()); 2039Assert.Equal("new()", @new.ToString()); 2046Assert.Equal("new object()", newObject.ToString()); 2074Assert.Equal("new()", @new.ToString()); 2081Assert.Equal("new object()", newObject.ToString()); 2220Assert.Equal("new()", def.ToString()); 2568Assert.Equal("new()", def.ToString()); 3218Assert.Equal("(o, new())", first.Parent.Parent.ToString()); 3222Assert.Equal("(new(), o)", second.Parent.Parent.ToString()); 3226Assert.Equal("(c, new())", third.Parent.Parent.ToString()); 3230Assert.Equal("(new(), c)", fourth.Parent.Parent.ToString());

Semantics\IndexAndRangeTests.cs (2)

919Assert.Equal("^", expression.OperatorToken.ToFullString()); 940Assert.Equal("^", expression.OperatorToken.ToFullString());

Semantics\InitOnlyMemberTests.cs (5)

3161Assert.Equal("_p", symbolSpeculation.Symbol.Name); 3166Assert.Equal("Int32", typeSpeculation.Type.Name); 3198Assert.Equal("P1", node.ToString()); 4764Assert.Equal("corlibWithIsExternalInit", comp.GetTypeByMetadataName("System.Runtime.CompilerServices.IsExternalInit").ContainingAssembly.Name); 4773Assert.Equal(expectedAssemblyName, comp.GetTypeByMetadataName("System.Runtime.CompilerServices.IsExternalInit").ContainingAssembly.Name);

Semantics\InteractiveSemanticModelTests.cs (2)

266Assert.Equal("c", semanticInfo.Symbol.Name); 352Assert.Equal(expected, method);

Semantics\InterceptorsTests.cs (4)

6870Assert.Equal("path/to/Program.cs(7,9)", locationSpecifier!.GetDisplayLocation()); 6888Assert.Equal("path/to/Program.cs(8,9)", otherLocation.GetDisplayLocation()); 7193Assert.Equal("", tree.FilePath); 7199Assert.Equal("(7,9)", locationSpecifier.GetDisplayLocation());

Semantics\InterpolationTests.cs (1)

4803Assert.Equal(expression, syntax.ToString());

Semantics\IteratorTests.cs (3)

580Assert.Equal("yield return;", node.ToString()); 611Assert.Equal("new KeyValuePair<TKey, TValue>(kvp.Key, kvp.Value)", node.ToString()); 649Assert.Equal("new KeyValuePair<TKey, TValue>(kvp, kvp.Value)", node.ToString());

Semantics\LambdaDiscardParametersTests.cs (1)

115Assert.Equal("_", symbol1.Name);

Semantics\LambdaTests.cs (49)

Semantics\LocalFunctionTests.cs (11)

354Assert.Equal("X", x.Identifier.Text); 396Assert.Equal("A", a.Identifier.Text); 410Assert.Equal("A", a.Identifier.Text); 501Assert.Equal("A", ((SimpleNameSyntax)attribute.Name).Identifier.ValueText); 549Assert.Equal("A", ((SimpleNameSyntax)attribute.Name).Identifier.ValueText); 813Assert.Equal("A", ((SimpleNameSyntax)attribute.Name).Identifier.ValueText); 1064Assert.Equal("A", attrConstructor.ContainingType.Name); 4727Assert.Equal("int n = N", parameter.ToString()); 8743Assert.Equal("nameof(parameter)", invocation.ToString()); 10182Assert.Equal("P", property.Name); 10183Assert.Equal("MyAttribute", property.ContainingType.Name);

Semantics\LockTests.cs (2)

47Assert.Equal("o", localSymbol.Name); 578Assert.Equal(@"System.Collections.Generic.IEnumerable<char>", model.GetTypeInfo(lockStatements[0].Expression).Type.ToDisplayString());

Semantics\LookupTests.cs (8)

682Assert.Equal("base", baseExprNode.ToString()); 692Assert.Equal("A", baseExprType.Name); 698Assert.Equal("Goo", names.Single()); 1566Assert.Equal("object.F()", method.ToDisplayString()); 1569Assert.Equal("E.F(object)", reducedFrom.ToDisplayString()); 1600Assert.Equal("E.F(object)", method.ToDisplayString()); 1604Assert.Equal("object.F()", method.ToDisplayString()); 1607Assert.Equal("E.F(object)", reducedFrom.ToDisplayString());

Semantics\MethodBodyModelTests.cs (1)

797Assert.Equal(string.Empty, string.Join(Environment.NewLine, comp.GetDiagnostics()));

Semantics\MethodTypeInferenceTests.cs (4)

1122Assert.Equal("Book", bookType.Name); 1163Assert.Equal("Author", authorType.Name); 1203Assert.Equal("Book", bookResultType.Name); 1207Assert.Equal("Author", authorResultType.Name);

Semantics\NamedAndOptionalTests.cs (1)

820Assert.Equal("ss", symInfo.Symbol.Name);

Semantics\NameOfTests.cs (9)

Semantics\NativeIntegerTests.cs (13)

116Assert.Equal("Sub I.F1(x As System.IntPtr, y As System.IntPtr)", VisualBasic.SymbolDisplay.ToDisplayString(method.GetPublicSymbol(), SymbolDisplayFormat.TestFormat)); 121Assert.Equal("Sub I.F2(x As System.UIntPtr, y As System.UIntPtr)", VisualBasic.SymbolDisplay.ToDisplayString(method.GetPublicSymbol(), SymbolDisplayFormat.TestFormat)); 227Assert.Equal(signed ? "IntPtr" : "UIntPtr", type.Name); 242Assert.Equal(signed ? "IntPtr" : "UIntPtr", type.Name); 547Assert.Equal(member.Name, underlyingMember.Name); 9506Assert.Equal(sourceType, typeInfo.Type.ToString()); 9507Assert.Equal(destType, typeInfo.ConvertedType.ToString()); 15318Assert.Equal(type, cref.ToString()); 15339Assert.Equal("System.IntPtr", cref.ToString()); 15362Assert.Equal("nint", cref.ToString()); 15390Assert.Equal(fieldName, cref.ToString()); 15413Assert.Equal("nint", cref.ToString()); 15443Assert.Equal("nint", cref.ToString());

Semantics\NonTrailingNamedArgumentsTests.cs (20)

Semantics\NullableContextTests.cs (11)

Semantics\NullableConversionTests.cs (1)

806Assert.Equal("double.NaN", operand.ToFullString());

Semantics\NullableReferenceTypesTests.cs (395)

Semantics\ObjectAndCollectionInitializerTests.cs (5)

3684Assert.Equal("List", listAssignment.Left.ToString()); 3734Assert.Equal("List", listAssignment.Left.ToString()); 3778Assert.Equal("[0]", listAssignment.Left.ToString()); 4011Assert.Equal("List<string>", name.ToString()); 4161Assert.Equal("I", typeInfo.ConvertedType.ToDisplayString());

Semantics\OperatorTests.cs (11)

2986Assert.Equal("!1", negOne.ToString()); 2992Assert.Equal("b++", boolPlusPlus.ToString()); 2998Assert.Equal("error++", errorPlusPlus.ToString()); 7057Assert.Equal("i2", syntax.Identifier.ValueText); 7212Assert.Equal("i2", syntax.Identifier.ValueText); 7655Assert.Equal(symbol1.Name, symbol1.MetadataName); 7659Assert.Equal("", symbol1.GetDocumentationCommentXml()); 8420Assert.Equal(expectedSymbol, actualSymbol); 8429Assert.Equal(symbol1.Name, symbol1.MetadataName); 8454Assert.Equal("", symbol1.GetDocumentationCommentXml()); 11338Assert.Equal("!invalidExpression", negNode.ToString());

Semantics\OverloadResolutionPerfTests.cs (1)

983Assert.Equal("o.F( ", expr.ToString());

Semantics\OverloadResolutionTests.cs (1)

7838Assert.Equal("(30,19): error CS0121: The call is ambiguous between the following methods or properties: 'A.B.X.Test(int)' and 'A.C.X.Test(int)'", DiagnosticFormatter.Instance.Format(comp.GetDiagnostics()[0], EnsureEnglishUICulture.PreferredOrNull));

Semantics\QueryTests.cs (48)

Semantics\RawInterpolationTests_Handler.cs (1)

3133Assert.Equal(expression, syntax.ToString());

Semantics\RecordStructTests.cs (17)

403Assert.Equal("record struct Point", point.ToDisplayString(SymbolDisplayFormat.TestFormat.AddKindOptions(SymbolDisplayKindOptions.IncludeTypeKeyword))); 410Assert.Equal("struct Point", point.ToDisplayString(SymbolDisplayFormat.TestFormat.AddKindOptions(SymbolDisplayKindOptions.IncludeTypeKeyword))); 2595Assert.Equal("= X + 1", x.Parent!.Parent!.ToString()); 2606Assert.Equal("C", recordDeclaration.Identifier.ValueText); 2630Assert.Equal("= X + 1", x.Parent!.Parent!.ToString()); 2664Assert.Equal("= X + 1", x.Parent!.Parent!.ToString()); 2699Assert.Equal("() => X + 1", x.Parent!.Parent!.ToString()); 3244Assert.Equal(identifier, x.Identifier.ValueText); 3286Assert.Equal("I1", cref.ToString()); 3334Assert.Equal("I2", cref.ToString()); 3385Assert.Equal("I2", cref.ToString()); 6517Assert.Equal("= 0", context.OperationBlocks[0].Syntax.ToString()); 6520Assert.Equal("Attr1(100)", context.OperationBlocks[1].Syntax.ToString()); 10761Assert.Equal("Error1(0, 1)", baseWithargs.ToString()); 10765Assert.Equal("Error1(0)", speculativeBase.ToString()); 10771Assert.Equal("Error2()", baseWithoutargs.ToString()); 10776Assert.Equal("Error3", baseWithoutParens.ToString());

Semantics\RefEscapingTests.cs (28)

Semantics\RefFieldTests.cs (15)

11562Assert.Equal(expectedDisplayString, parameter.ToDisplayString(displayFormatWithScoped)); 11577Assert.Equal(expectedDisplayString, parameter.ToDisplayString(displayFormatWithScoped)); 15284Assert.Equal(expectedDisplayString, local.ToDisplayString(displayFormatWithScoped)); 15293Assert.Equal(expectedDisplayString, local.ToDisplayString(displayFormatWithScoped)); 16120Assert.Equal("M2(r => r)", invocations[0].ToString()); 16123Assert.Equal("M2((scoped R r) => r)", invocations[1].ToString()); 16161Assert.Equal("delegate { }", anonymousMethod.ToString()); 16200Assert.Equal("delegate { }", anonymousMethod.ToString()); 16296Assert.Equal("(r1, t1) => F((r2, t2) => r2, t1)", lambdas[0].ToString()); 16297Assert.Equal("r1", lambdas[0].ParameterList.Parameters[0].Identifier.ToString()); 16300Assert.Equal("t1", lambdas[0].ParameterList.Parameters[1].Identifier.ToString()); 16303Assert.Equal("(r2, t2) => r2", lambdas[1].ToString()); 16304Assert.Equal("r2", lambdas[1].ParameterList.Parameters[0].Identifier.ToString()); 16307Assert.Equal("t2", lambdas[1].ParameterList.Parameters[1].Identifier.ToString()); 16344Assert.Equal("o2 => throw null!", lambda.ToString());

Semantics\ScriptSemanticsTests.cs (14)

Semantics\SemanticAnalyzerTests.cs (1)

1399Assert.Equal("capacity", call.ArgumentNamesOpt[0]);

Semantics\SemanticErrorTests.cs (3)

7490Assert.Equal("i[1,2]", node.ToString()); 13329Assert.Equal("i.R[1]", node.ToString()); 24229Assert.Equal("base?.ToString()", node.ToString());

Semantics\StackAllocInitializerTests.cs (17)

1051Assert.Equal("obj1", obj1.Identifier.Text); 1055Assert.Equal("Test", obj1Value.ConvertedType.Name); 1059Assert.Equal("obj2", obj2.Identifier.Text); 1067Assert.Equal("obj3", obj3.Identifier.Text); 1070Assert.Equal("Span", obj3Value.Type.Name); 1071Assert.Equal("Span", obj3Value.ConvertedType.Name); 1075Assert.Equal("obj4", obj4.Identifier.Text); 1083Assert.Equal("obj5", obj5.Identifier.Text); 1153Assert.Equal("obj1", obj1.Identifier.Text); 1157Assert.Equal("Span", obj1Value.Type.Name); 1158Assert.Equal("Span", obj1Value.ConvertedType.Name); 1162Assert.Equal("obj2", obj2.Identifier.Text); 1170Assert.Equal("obj3", obj3.Identifier.Text); 1173Assert.Equal("Span", obj3Value.Type.Name); 1174Assert.Equal("Span", obj3Value.ConvertedType.Name); 1178Assert.Equal("obj4", obj4.Identifier.Text); 1186Assert.Equal("obj5", obj5.Identifier.Text);

Semantics\StackAllocSpanExpressionsTests.cs (17)

57Assert.Equal("obj1", obj1.Identifier.Text); 61Assert.Equal("Test", obj1Value.ConvertedType.Name); 65Assert.Equal("obj2", obj2.Identifier.Text); 73Assert.Equal("obj3", obj3.Identifier.Text); 76Assert.Equal("Span", obj3Value.Type.Name); 77Assert.Equal("Span", obj3Value.ConvertedType.Name); 81Assert.Equal("obj4", obj4.Identifier.Text); 89Assert.Equal("obj5", obj5.Identifier.Text); 131Assert.Equal("obj1", obj1.Identifier.Text); 135Assert.Equal("Span", obj1Value.Type.Name); 136Assert.Equal("Span", obj1Value.ConvertedType.Name); 140Assert.Equal("obj2", obj2.Identifier.Text); 148Assert.Equal("obj3", obj3.Identifier.Text); 151Assert.Equal("Span", obj3Value.Type.Name); 152Assert.Equal("Span", obj3Value.ConvertedType.Name); 156Assert.Equal("obj4", obj4.Identifier.Text); 164Assert.Equal("obj5", obj5.Identifier.Text);

Semantics\SuppressAccessibilityChecksTests.cs (14)

57Assert.Equal("A", semanticModel.GetTypeInfo(invocation).Type.Name); 58Assert.Equal("M", semanticModel.GetSymbolInfo(invocation).Symbol.Name); 62Assert.Equal("A", semanticModel.GetTypeInfo(invocation).Type.Name); 64Assert.Equal("M", semanticModel.GetSymbolInfo(invocation).CandidateSymbols.Single().Name); 76Assert.Equal("Int32", 79Assert.Equal("_num", 98Assert.Equal("A", creationExpression.Type.Name); 129Assert.Equal("_p", symbolInfo.Symbol.Name); 171Assert.Equal("A", semanticModel.GetTypeInfo(invocation).Type.Name); 172Assert.Equal("M", semanticModel.GetSymbolInfo(invocation).Symbol.Name); 177Assert.Equal("Int32", semanticModel.GetSpeculativeTypeInfo(position, speculativeInvocation, SpeculativeBindingOption.BindAsExpression).Type.Name); 178Assert.Equal("InternalExtension", semanticModel.GetSpeculativeSymbolInfo(position, speculativeInvocation, SpeculativeBindingOption.BindAsExpression).Symbol.Name); 236Assert.Equal("_p", symbolSpeculation.Symbol.Name); 241Assert.Equal("Int32", typeSpeculation.Type.Name);

Semantics\TargetTypedDefaultTests.cs (36)

Semantics\TopLevelStatementsTests.cs (61)

Semantics\TryCatchTests.cs (3)

47Assert.Equal("e", localSymbol.Name); 48Assert.Equal("System.IO.IOException", localSymbol.Type.ToDisplayString()); 51Assert.Equal("string.operator !=(string, string)", filterExprInfo.Symbol.ToDisplayString());

Semantics\UnsafeTests.cs (11)

5215Assert.Equal(expected, actual); 7277Assert.Equal("p", declaredSymbol.Name); 7325Assert.Equal("&()", syntax.ToString()); //NOTE: not actually lambda 7363Assert.Equal("&(()=>5)", syntax.ToString()); 7861Assert.Equal("p", receiverSymbol.Name); 7928Assert.Equal("s", receiverSymbol.Name); 8172Assert.Equal("p", receiverSymbol.Name); 8184Assert.Equal("i", indexSymbol.Name); 8239Assert.Equal("f", receiverSymbol.Name); 8297Assert.Equal("f", receiverSymbol.Name); 11340Assert.Equal("count", countSymbol.Name);

Semantics\UsingStatementTests.cs (2)

66Assert.Equal("i", declaredLocal.Name); 1871Assert.Equal(variables[i++].ToString(), symbol.ToDisplayString());

SourceGeneration\GeneratorDriverTests.cs (43)

SourceGeneration\StateTableTests.cs (14)

382Assert.Equal("Batch", step.Name); 445Assert.Equal("Batch", step.Name); 492Assert.Equal("Batch", step.Name); 559Assert.Equal("Batch", step.Name); 641Assert.Equal("Transform", step.Name); 676Assert.Equal("Transform", step.Name); 714Assert.Equal("Transform", step.Name); 753Assert.Equal("Transform", step.Name); 880Assert.Equal("TestStep", step.Name); 886Assert.Equal("TestStep", step.Name); 892Assert.Equal("TestStep", step.Name); 898Assert.Equal("TestStep", step.Name); 904Assert.Equal("TestStep", step.Name); 910Assert.Equal("TestStep", step.Name);

SourceGeneration\SyntaxAwareGeneratorTests.cs (12)

390Assert.Equal("Test Exception", results.Results[0].Exception?.Message); 432Assert.Equal("Test Exception", results.Results[0].Exception?.Message); 522Assert.Equal("Test Exception", results.Results[0].Exception?.Message); 1274Assert.Equal("fieldD", Assert.Single(fieldsCalledFor)); 1416Assert.Equal("fieldA", syntaxFieldsCalledFor[0]); 1417Assert.Equal("fieldB", syntaxFieldsCalledFor[1]); 1418Assert.Equal("fieldC", syntaxFieldsCalledFor[2]); 1479Assert.Equal("fieldC", Assert.Single(syntaxFieldsCalledFor)); 1865Assert.Equal("Test Exception", results.Results[0].Exception?.Message); 1906Assert.Equal("Test Exception", results.Results[0].Exception?.Message); 1952Assert.Equal("Test Exception", results.Results[0].Exception?.Message); 2056Assert.Equal("Simulated cancellation from external source", results.Results[0].Exception!.Message);

Utilities\ValueSetTests.cs (59)

37Assert.Equal($"[{i1}..{int.MaxValue}]", values.ToString()); 47Assert.Equal($"[{i1}..{int.MaxValue}]", values.ToString()); 66Assert.Equal((i1 == int.MaxValue) ? "" : $"[{i1 + 1}..{int.MaxValue}]", values.ToString()); 76Assert.Equal($"[{i1 + 1}..{int.MaxValue}]", values.ToString()); 95Assert.Equal($"[{int.MinValue}..{i1}]", values.ToString()); 105Assert.Equal($"[{int.MinValue}..{i1}]", values.ToString()); 124Assert.Equal((i1 == int.MinValue) ? "" : $"[{int.MinValue}..{i1 - 1}]", values.ToString()); 134Assert.Equal($"[{int.MinValue}..{i1 - 1}]", values.ToString()); 153Assert.Equal($"[{i1}..{i1}]", values.ToString()); 163Assert.Equal($"[{i1}..{i1}]", values.ToString()); 176Assert.Equal($"[{i1}..{i2}]", values1.ToString()); 192Assert.Equal($"", values1.ToString()); 208Assert.Equal($"[{int.MinValue}..{i1}],[{i2}..{int.MaxValue}]", values1.ToString()); 223Assert.Equal($"[{int.MinValue}..{int.MaxValue}]", values1.ToString()); 239Assert.Equal($"[{int.MinValue}..{i1}],[{i2}..{int.MaxValue}]", values1.ToString()); 242Assert.Equal($"[{i1 + 1}..{i2 - 1}]", values2.ToString()); 255Assert.Equal($"[{i1}..{i2}]", values.ToString()); 296Assert.Equal(FormattableString.Invariant($"[{d1:G17}..{d2:G17}]"), values.ToString()); 308Assert.Equal("['A'..'Z'],['a'..'z']", letters.ToString()); 314Assert.Equal("[-Inf..-Inf]", ForDouble.Related(LessThan, double.MinValue).ToString()); 316Assert.Equal(FormattableString.Invariant($"[-Inf..{-double.Epsilon:G17}]"), lt.ToString()); 318Assert.Equal(FormattableString.Invariant($"[{double.Epsilon:G17}..Inf]"), gt.ToString()); 320Assert.Equal("[0..0]", eq.ToString()); 322Assert.Equal("NaN", none.ToString()); 329Assert.Equal("[-Inf..-Inf]", ForFloat.Related(LessThan, float.MinValue).ToString()); 331Assert.Equal(FormattableString.Invariant($"[-Inf..{-float.Epsilon:G9}]"), lt.ToString()); 333Assert.Equal(FormattableString.Invariant($"[{float.Epsilon:G9}..Inf]"), gt.ToString()); 335Assert.Equal("[0..0]", eq.ToString()); 337Assert.Equal("NaN", none.ToString()); 344Assert.Equal("NaN", ForDouble.Related(Equal, double.NaN).ToString()); 345Assert.Equal("NaN", ForFloat.Related(Equal, float.NaN).ToString()); 348Assert.Equal("[Inf..Inf]", ForDouble.Related(Equal, double.PositiveInfinity).ToString()); 349Assert.Equal("[Inf..Inf]", ForFloat.Related(Equal, float.PositiveInfinity).ToString()); 350Assert.Equal("[-Inf..-Inf]", ForDouble.Related(Equal, double.NegativeInfinity).ToString()); 351Assert.Equal("[-Inf..-Inf]", ForFloat.Related(Equal, float.NegativeInfinity).ToString()); 409Assert.Equal("[11..99]", s.ToString()); 435Assert.Equal("NaN,[3.1400000000000001..31.399999999999999]", s3.ToString()); 444Assert.Equal($"[{long.MinValue}..1]", s1.ToString()); 463Assert.Equal($"[-4..1]", s2.ToString()); 479Assert.Equal("[10..100]", ForSByte.Related(GreaterThanOrEqual, 10).Intersect(ForSByte.Related(LessThanOrEqual, 100)).ToString()); 480Assert.Equal("[10..100]", ForShort.Related(GreaterThanOrEqual, 10).Intersect(ForShort.Related(LessThanOrEqual, 100)).ToString()); 481Assert.Equal("[10..100]", ForUInt.Related(GreaterThanOrEqual, 10).Intersect(ForUInt.Related(LessThanOrEqual, 100)).ToString()); 482Assert.Equal("[10..100]", ForULong.Related(GreaterThanOrEqual, 10).Intersect(ForULong.Related(LessThanOrEqual, 100)).ToString()); 483Assert.Equal("[10..100]", ForUShort.Related(GreaterThanOrEqual, 10).Intersect(ForUShort.Related(LessThanOrEqual, 100)).ToString()); 484Assert.Equal("[10..100]", ForFloat.Related(GreaterThanOrEqual, 10).Intersect(ForFloat.Related(LessThanOrEqual, 100)).ToString()); 485Assert.Equal("[-100..-10]", ForFloat.Related(GreaterThanOrEqual, -100).Intersect(ForFloat.Related(LessThanOrEqual, -10)).ToString()); 486Assert.Equal("[-10..10]", ForFloat.Related(GreaterThanOrEqual, -10).Intersect(ForFloat.Related(LessThanOrEqual, 10)).ToString()); 514Assert.Equal("[-79228162514264337593543950335..-0.0000000000000000000000000001]", ForDecimal.Related(LessThan, 0.0m).ToString()); 515Assert.Equal("[-79228162514264337593543950335..0.0000000000000000000000000000]", ForDecimal.Related(LessThanOrEqual, 0.0m).ToString()); 516Assert.Equal("[0.0000000000000000000000000001..79228162514264337593543950335]", ForDecimal.Related(GreaterThan, 0.0m).ToString()); 517Assert.Equal("[0.0000000000000000000000000000..79228162514264337593543950335]", ForDecimal.Related(GreaterThanOrEqual, 0.0m).ToString()); 523Assert.Equal("Small,[-2147483648..9]", ForNint.Related(LessThan, 10).ToString()); 524Assert.Equal("Small,[-2147483648..10]", ForNint.Related(LessThanOrEqual, 10).ToString()); 525Assert.Equal("[11..2147483647],Large", ForNint.Related(GreaterThan, 10).ToString()); 526Assert.Equal("[10..2147483647],Large", ForNint.Related(GreaterThanOrEqual, 10).ToString()); 532Assert.Equal("[0..9]", ForNuint.Related(LessThan, 10).ToString()); 533Assert.Equal("[0..10]", ForNuint.Related(LessThanOrEqual, 10).ToString()); 534Assert.Equal("[11..4294967295],Large", ForNuint.Related(GreaterThan, 10).ToString()); 535Assert.Equal("[10..4294967295],Large", ForNuint.Related(GreaterThanOrEqual, 10).ToString());

Compilation\CompilationAPITests.cs (12)

885Assert.Equal("C#", bind.Language); 1694Assert.Equal("?", compilation.Assembly.Name); 1695Assert.Equal("?", compilation.Assembly.Identity.Name); 1702Assert.Equal("?", compilation.Assembly.Name); 1703Assert.Equal("?", compilation.Assembly.Identity.Name); 1709Assert.Equal("ModuleAssemblyName", compilation.AssemblyName); 1710Assert.Equal("ModuleAssemblyName", compilation.Assembly.Name); 1711Assert.Equal("ModuleAssemblyName", compilation.Assembly.Identity.Name); 1904Assert.Equal("alias", comp.References.Last().Properties.Aliases.Single()); 2612Assert.Equal("<anonymous type: int m1>", type.ToDisplayString()); 2635Assert.Equal("<anonymous type: int m1, int m2>", type.ToDisplayString()); 2648Assert.Equal("<anonymous type: int m1, bool m2>", type.ToDisplayString());

Compilation\CSharpCompilationOptionsTests.cs (1)

299Assert.Equal("Script", new CSharpCompilationOptions(OutputKind.ConsoleApplication, scriptClassName: null).ScriptClassName);

Compilation\GetSemanticInfoTests.cs (64)

Compilation\GetUnusedImportDirectivesTests.cs (2)

198Assert.Equal("Console", info.Symbol.Name); 200Assert.Equal("System", info.Symbol.ContainingSymbol.Name);

Compilation\IndexedProperties_BindingTests.cs (1)

144Assert.Equal(name, sym.Symbol.Name);

Compilation\ReferenceManagerTests.cs (12)

915Assert.Equal(p2, dr1.FilePath); 916Assert.Equal(p3, dr2.FilePath); 917Assert.Equal(p3, dr3.FilePath); 2063Assert.Equal("B, Version=1.0.0.0, Culture=neutral, PublicKeyToken=ce65828c82a341f2", libBv1.Assembly.Identity.GetDisplayName()); 2064Assert.Equal("B, Version=2.0.0.0, Culture=neutral, PublicKeyToken=ce65828c82a341f2", libBv2.Assembly.Identity.GetDisplayName()); 2171Assert.Equal("System.Numerics.Vectors, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", vectors40.Assembly.Identity.GetDisplayName()); 2178Assert.Equal("System.Numerics.Vectors, Version=4.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", vectors41.Assembly.Identity.GetDisplayName()); 2539Assert.Equal("B", ((AssemblySymbol)c.GetAssemblyOrModuleSymbol(bRef)).Name); 2612Assert.Equal("B", ((AssemblySymbol)c.GetAssemblyOrModuleSymbol(b3RefY)).Name); 2782Assert.Equal("D", ((AssemblySymbol)c.GetAssemblyOrModuleSymbol(dRef)).Name); 2814Assert.Equal("B", ((AssemblySymbol)c.GetAssemblyOrModuleSymbol(bRef)).Name); 2815Assert.Equal("D", ((AssemblySymbol)c.GetAssemblyOrModuleSymbol(dRef)).Name);

Compilation\SemanticModelAPITests.cs (89)

Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (127)

Compilation\SemanticModelGetSemanticInfoTests.cs (62)

Compilation\SemanticModelGetSemanticInfoTests_LateBound.cs (6)

40Assert.Equal("C", semanticInfo.Type.Name); 64Assert.Equal("C", semanticInfo.Type.Name); 85Assert.Equal("C", semanticInfo.Type.Name); 111Assert.Equal("C", semanticInfo.Type.Name); 716Assert.Equal("dynamic.operator " + op + "(dynamic, dynamic)", semanticInfo.Symbol.ToString()); 829Assert.Equal("dynamic.operator " + op.Substring(0, op.Length - 1) + "(dynamic, dynamic)", semanticInfo.Symbol.ToString());

Compilation\SymbolVisitorTests.cs (6)

573Assert.Equal(expectedOutput, resultOutput); 624Assert.Equal(expectedOutput, resultOutput); 676Assert.Equal(expectedOutput, resultOutput); 721Assert.Equal(expectedOutput, resultOutput); 765Assert.Equal(expectedOutput, resultOutput); 810Assert.Equal(expectedOutput, resultOutput);

DeclarationTests.cs (7)

65Assert.Equal(string.Empty, decl1.Name); 66Assert.Equal(string.Empty, decl2.Name); 95Assert.Equal("C", ct1.Name); 96Assert.Equal("C", ct2.Name); 104Assert.Equal("C", c1.Name); 132Assert.Equal(string.Empty, mr.Name); 165Assert.Equal(string.Empty, mr.Name);

DocumentationComments\CrefTests.cs (9)

2140Assert.Equal("A", actualSymbol.Name); 5719Assert.Equal(WellKnownMemberNames.AdditionOperatorName, symbol.Name); 6047Assert.Equal("T", typeParameterSyntax.ToString()); 6071Assert.Equal("GetValueOrDefault", methodNameSyntax.ToString()); 6220Assert.Equal("A", alias.Name); 6253Assert.Equal("A", alias.Name); 6675Assert.Equal("U", name.ToString()); 6926Assert.Equal("T:System.ValueTuple`2", cref); 6950Assert.Equal("F:System.ValueTuple`2.Item1", cref);

DocumentationComments\DocumentationCommentCompilerTests.cs (140)

DocumentationComments\DocumentationModeTests.cs (2)

358Assert.Equal(expectedText, actualText); 392Assert.Equal(expectedText, actualText);

DocumentationComments\PartialTypeDocumentationCommentTests.cs (1)

57Assert.Equal(

DocumentationComments\TypeDocumentationCommentTests.cs (2)

53Assert.Equal("T:Color", _compilation.GlobalNamespace.GetTypeMembers("Color").Single().GetDocumentationCommentId()); 71Assert.Equal("T:Acme.Widget", _widgetClass.GetDocumentationCommentId());

SymbolDisplay\ObjectDisplayTests.cs (131)

SymbolDisplay\SymbolDisplayTests.cs (32)

Symbols\AccessorOverriddenOrHiddenMembersTests.cs (9)

1008Assert.Equal("d.Dispose()", invocationSyntax.ToString()); 1011Assert.Equal("d.Dispose", memberAccessSyntax.ToString()); 1014Assert.Equal("d", identifierSyntax.ToString()); 1015Assert.Equal("d", identifierSyntax.Identifier.Text); 1019Assert.Equal("Dispose", memberNameSyntax.ToString()); 1020Assert.Equal("Dispose", memberNameSyntax.Identifier.Text); 1029Assert.Equal("d", localD.Name); 1030Assert.Equal("Disposable", localD.Type.Name); 1034Assert.Equal("Dispose", methodDispose.Name);

Symbols\AnonymousTypesSemanticsTests.cs (13)

Symbols\AnonymousTypesSymbolTests.cs (8)

1020Assert.Equal(typeViewName, type.ToDisplayString()); 1021Assert.Equal("object", type.BaseType().ToDisplayString()); 1045Assert.Equal(genericParameters[i], typeParameter.ToDisplayString()); 1108Assert.Equal("get_" + name, getter.Name); 1125Assert.Equal(signature, method.ToDisplayString()); 1134Assert.Equal(retType, method.ReturnTypeWithAnnotations.ToDisplayString()); 1154Assert.Equal(attr.CtorName, actual[index].AttributeConstructor.ToDisplayString()); 1159Assert.Equal(

Symbols\AssemblyAndNamespaceTests.cs (7)

36Assert.Equal(String.Empty, sym.GlobalNamespace.Name); 60Assert.Equal("Test.dll", sym.Name); 62Assert.Equal("Test.dll", sym.ToDisplayString()); 63Assert.Equal(String.Empty, sym.GlobalNamespace.Name); 71Assert.Equal("Test", sym.ContainingAssembly.Name); 72Assert.Equal("Test", sym.ContainingSymbol.Name); 83Assert.Equal("Module: Test.dll", ext.ToString());

Symbols\CheckedUserDefinedOperatorsTests.cs (20)

Symbols\CompilationCreationTests.cs (3)

2414Assert.Equal(typeC301.ToDisplayString(SymbolDisplayFormat.QualifiedNameArityFormat), 2418Assert.Equal(typeC6.ToDisplayString(SymbolDisplayFormat.QualifiedNameArityFormat), 2514Assert.Equal("C3.dll", module3.Name);

Symbols\CovariantReturnTests.cs (2)

2633Assert.Equal("System.Linq.Expressions.Expression(Of System.Func(Of Derived, String))", typeInfo.ConvertedType.ToDisplayString()); 2637Assert.Equal("System.Linq.Expressions.Expression(Of System.Func(Of Derived, System.Func(Of String)))", typeInfo.ConvertedType.ToDisplayString());

Symbols\DefaultInterfaceImplementationTests.cs (8)

Symbols\DestructorTests.cs (1)

414Assert.Equal(WellKnownMemberNames.DestructorName, finalizeSyntax.ToString());

Symbols\ExtensionMethodTests.cs (9)

3152Assert.Equal("obj.InstanceMethod", firstInvocationExpression.ToString()); 3155Assert.Equal("InstanceMethod", firstInvocationSymbol.Name); 3158Assert.Equal("obj.ExtensionMethod", secondInvocationExpression.ToString()); 3161Assert.Equal("ExtensionMethod", secondInvocationSymbol.Name); 3779Assert.Equal("other.GetEnumerableDisposable1<T, TEnumerator>", member.ToString()); 3867Assert.Equal("Instance.SetMember", instance.Parent.ToString()); 3914Assert.Equal("Instance.SetMember", instance.Parent.ToString()); 3959Assert.Equal("Instance.SetMember", instance.Parent.ToString()); 4009Assert.Equal("Instance.SetMember", instance.Parent.ToString());

Symbols\FunctionPointerTypeSymbolTests.cs (6)

1264Assert.Equal("delegate*<C.D>", functionPointerTypeSyntax.ToString()); 1520Assert.Equal("delegate*<ref readonly int>", f1.ToDisplayString()); 1522Assert.Equal("delegate*<ref int>", f2.ToDisplayString()); 1822Assert.Equal("ptr = &M1", decls[0].ToString()); 1831Assert.Equal("ptr2 = &M1", decls[1].ToString()); 1868Assert.Equal("ptr = &M1", variableDeclaratorSyntax.ToString());

Symbols\GenericConstraintTests.cs (52)

Symbols\ImplicitClassTests.cs (2)

119Assert.Equal("A", model.GetDeclaredSymbol(namespaceDecl).Name); 120Assert.Equal("Goo", model.GetDeclaredSymbol(methodDecl).Name);

Symbols\IndexerTests.cs (3)

2137Assert.Equal("A", peIndexer.MetadataName); 2847Assert.Equal(WellKnownMemberNames.Indexer, idxSymbol2.Symbol.Name); 2848Assert.Equal("Item", idxSymbol2.Symbol.MetadataName);

Symbols\Metadata\MetadataMemberTests.cs (3)

264Assert.Equal("pwzFilePath", p1.Name); 284Assert.Equal("ppbSignatureBlob", p5.Name); 361Assert.Equal("value", p2.Name);

Symbols\Metadata\PE\LoadingAttributes.cs (22)

497Assert.Equal("object[]", t.ToDisplayString()); 504Assert.Equal("object[]", t.ToDisplayString()); 510Assert.Equal("int[]", t.ToDisplayString()); 567Assert.Equal(expected, actual.ToString()); 572Assert.Equal(expected.Key, actual.Key.ToString()); 573Assert.Equal(expected.Value, actual.Value.Value.ToString()); 625Assert.Equal("System.Runtime.InteropServices.ClassInterfaceType", a.CommonConstructorArguments[0].Type.ToDisplayString()); 707Assert.Equal("object", ((Symbol)attrSym.CommonConstructorArguments[0].ValueInternal).ToString()); 1004Assert.Equal("sbyte[]", attrSym.CommonConstructorArguments[0].Type.ToDisplayString()); 1008Assert.Equal("System.Collections.Generic.IList<>", (attrSym.CommonNamedArguments[0].Value.Value as INamedTypeSymbol).ToString()); 1069Assert.Equal("char[]", a.CommonConstructorArguments[0].Type.ToDisplayString()); 1074Assert.Equal("string[]", a.CommonConstructorArguments[1].Type.ToDisplayString()); 1079Assert.Equal("ushort[]", na0[1].Type.ToDisplayString()); 1081Assert.Equal("ushort", elem[1].Type.ToDisplayString()); 1094Assert.Equal("ulong[]", a.CommonNamedArguments[0].Value.Type.ToDisplayString()); 1162Assert.Equal("AttributeUse.IFoo<System.Int16, System.UInt16>", (attrSym.CommonConstructorArguments[0].Value as INamedTypeSymbol).ToDisplayString(SymbolDisplayFormat.TestFormat)); 1211Assert.Equal("System.Linq.Expressions.Expression.BinaryExpressionProxy", ((ITypeSymbol)attr1.CommonConstructorArguments[0].Value).ToDisplayString(SymbolDisplayFormat.TestFormat)); 1216Assert.Equal("System.Linq.Expressions.Expression.TypeBinaryExpressionProxy", ((ITypeSymbol)attr1.CommonConstructorArguments[0].Value).ToDisplayString(SymbolDisplayFormat.TestFormat)); 1310Assert.Equal("System.Runtime.CompilerServices.DecimalConstantAttribute(0, 128, 0, 0, 7)", peModule.GetCustomAttributesForToken(field.Handle).Single().ToString()); 1314Assert.Equal("System.Runtime.CompilerServices.DecimalConstantAttribute(0, 128, 0, 0, 7)", peModule.GetCustomAttributesForToken(parameter.Handle).Single().ToString()); 1514Assert.Equal(expected, c.GetTypeByMetadataName("Test").GetAttributes().Single().ToString()); 1518Assert.Equal(expected, m.GlobalNamespace.GetTypeMember("Test").GetAttributes().Single().ToString());

Symbols\Metadata\PE\LoadingFields.cs (6)

45Assert.Equal("F1", f1.Name); 64Assert.Equal("F2", f2.Name); 73Assert.Equal("F3", f3.Name); 81Assert.Equal("F4", f4.Name); 89Assert.Equal("F5", f5.Name); 97Assert.Equal("F6", f6.Name);

Symbols\Metadata\PE\LoadingNamespacesAndTypes.cs (8)

30Assert.Equal(baseLine.ToString(), dumpXML.ToString()); 34Assert.Equal(baseLine.ToString(), dumpXML.ToString()); 44Assert.Equal(baseLine.ToString(), dumpXML.ToString()); 48Assert.Equal(baseLine.ToString(), dumpXML.ToString()); 276Assert.Equal("Dictionary", dictionary.Name); 285Assert.Equal("ValueCollection", ((NamedTypeSymbol)valueCollection[0]).Name); 374Assert.Equal("With Spaces", assembly.Name); 375Assert.Equal("With Spaces", assembly.MetadataName);

Symbols\Metadata\PE\MissingTypeReferences.cs (13)

Symbols\Metadata\PE\NoPia.cs (4)

161Assert.Equal("f9c2d51d-4f44-45f0-9eda-c9d599b58257", missing.Scope); 203Assert.Equal("27e3e649-994b-4f58-b3c6-f8089a5f2c01", missing.Guid); 531Assert.Equal("27e3e649-994b-4f58-b3c6-f8089a5f2c01", missing.Guid); 547Assert.Equal("f9c2d51d-4f44-45f0-9eda-c9d599b58257", missing.Scope);

Symbols\Metadata\PE\NoPiaLocalHideAndTypeSubstitutionTests.cs (2)

146Assert.Equal("f9c2d51d-4f44-45f0-9eda-c9d599b58257", missing.Scope); 241Assert.Equal("f9c2d51d-4f44-45f0-9eda-c9d599b58257", missing.Scope);

Symbols\Metadata\PE\TypeForwarders.cs (6)

1563Assert.Equal("Original", result.Trim()); 1571Assert.Equal("Substituted", result.Trim()); 1804Assert.Equal(expectedType.Split('+').Last(), reader.GetString(exportedTypeRow.Name)); //Only the actual type name. 1805Assert.Equal("", reader.GetString(exportedTypeRow.Namespace)); //Empty - presumably there's enough info on the containing type. 1812Assert.Equal(expectedType, reader.GetString(exportedTypeRow.Name)); 1813Assert.Equal(expectedNamespace, reader.GetString(exportedTypeRow.Namespace));

Symbols\MockSymbolTests.cs (4)

73Assert.Equal("Elvis", mms1.NamespaceName); 74Assert.Equal("Lives", mms1.Name); 80Assert.Equal("Elvis.Is", mms2.NamespaceName); 81Assert.Equal("Cool", mms2.Name);

Symbols\PartialPropertiesTests.cs (4)

796Assert.Equal("something.dll", importData.ModuleName); 797Assert.Equal(accessor.MetadataName, importData.EntryPointName); // e.g. 'get_P' 850Assert.Equal("a", moduleName); 854Assert.Equal("b", moduleName);

Symbols\RelaxedShiftOperatorTests.cs (12)

104Assert.Equal("x " + op + " y", shift.ToString()); 105Assert.Equal("C1.operator " + op + "(C1, C2)", model.GetSymbolInfo(shift).Symbol.ToDisplayString()); 148Assert.Equal("x " + op + " y", shift.ToString()); 149Assert.Equal("C1.operator " + op + "(C1, C2)", model.GetSymbolInfo(shift).Symbol.ToDisplayString()); 192Assert.Equal("x " + op + " y", shift.ToString()); 193Assert.Equal("C1.operator " + op + "(C1, C2)", model.GetSymbolInfo(shift).Symbol.ToDisplayString()); 236Assert.Equal("x " + op + " y", shift.ToString()); 237Assert.Equal("C1.operator " + op + "(C1, C2)", model.GetSymbolInfo(shift).Symbol.ToDisplayString()); 280Assert.Equal("x " + op + " y", shift.ToString()); 281Assert.Equal("C1.operator " + op + "(C1, C2)", model.GetSymbolInfo(shift).Symbol.ToDisplayString()); 324Assert.Equal("x " + op + " y", shift.ToString()); 325Assert.Equal("C1.operator " + op + "(C1, C2)", model.GetSymbolInfo(shift).Symbol.ToDisplayString());

Symbols\RequiredMembersTests.cs (1)

95Assert.Equal(nameof(CompilerFeatureRequiredFeatures.RequiredMembers), unsupportedCompilerFeatureToken);

Symbols\Retargeting\NoPia.cs (7)

469Assert.Equal("f9c2d51d-4f44-45f0-9eda-c9d599b58257", missing.Scope); 509Assert.Equal("27e3e649-994b-4f58-b3c6-f8089a5f2c01", missing.Guid); 770Assert.Equal("f9c2d51d-4f44-45f0-9eda-c9d599b58257", missing.Scope); 810Assert.Equal("27e3e649-994b-4f58-b3c6-f8089a5f2c01", missing.Guid); 1074Assert.Equal("f9c2d51d-4f44-45f0-9eda-c9d599b58257", missing.Scope); 1114Assert.Equal("27e3e649-994b-4f58-b3c6-f8089a5f2c01", missing.Guid); 2676Assert.Equal("Pia.dll", test.ContainingModule.Name);

Symbols\Retargeting\RetargetCustomAttributes.cs (6)

308Assert.Equal("object[]", args[0].Type.ToDisplayString()); 312Assert.Equal("int[]", args[1].Type.ToDisplayString()); 318Assert.Equal("object[]", named["P"].Type.ToDisplayString()); 322Assert.Equal("int[]", named["F"].Type.ToDisplayString()); 351Assert.Equal("A[missing]", a.ToString()); 393Assert.Equal("A", a.ToString());

Symbols\Retargeting\RetargetCustomModifiers.cs (1)

176Assert.Equal("volatileFld", volatileFld.Name);

Symbols\Retargeting\RetargetingTests.cs (7)

740Assert.Equal(c1.Name, c1r.Name); 743Assert.Equal(c1.MetadataName, c1r.MetadataName); 1223Assert.Equal(a.Name, b.Name); 1231Assert.Equal(a.Name, b.Name); 1246Assert.Equal(a.Name, b.Name); 1254Assert.Equal(a.Name, b.Name); 1263Assert.Equal(a.Name, b.Name);

Symbols\Source\BaseClassTests.cs (26)

Symbols\Source\CustomModifierCopyTests.cs (3)

890Assert.Equal("Bug813305.IBug813305.M(dynamic)", method.ToDisplayString()); 1296Assert.Equal("(object a, object b) Base.P", baseProperty1.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)); 1303Assert.Equal("(object a, object b) C.P", classProperty1.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat));

Symbols\Source\DeclaringSyntaxNodeTests.cs (1)

144Assert.Equal(name, sym.Name);

Symbols\Source\DelegateTests.cs (43)

Symbols\Source\EventTests.cs (3)

44Assert.Equal("main1, Test1", actual); 436Assert.Equal("f => f.Print()", lambdaSyntax.ToFullString()); 482Assert.Equal("f => f.Print()", lambdaSyntax.ToFullString());

Symbols\Source\ExternAliasTests.cs (2)

489Assert.Equal("A", externAliasSymbol.Name); 495Assert.Equal("C", usingAliasSymbol.Name);

Symbols\Source\FieldTests.cs (6)

204Assert.Equal("M", s.Name); 237Assert.Equal("in", ein.Name); 238Assert.Equal("C1.@in", ein.ToString()); 240Assert.Equal("out", dout.Name); 241Assert.Equal("@out", dout.ToString()); 257Assert.Equal("x", mem.Name);

Symbols\Source\FileModifierTests.cs (4)

4126Assert.Equal("System.Void@<tree 0>", typeInfo.Type!.ToDisplayString(SymbolDisplayFormat.TestFormat.WithCompilerInternalOptions(SymbolDisplayCompilerInternalOptions.IncludeContainingFileForFileTypes))); 4245Assert.Equal("C", sourceTypeCByMetadataName.MetadataName); 4260Assert.Equal("C", metadataTypeCByMetadataName.MetadataName); 4591Assert.Equal("trees[1]", ex.ParamName);

Symbols\Source\LocalTests.cs (1)

61Assert.Equal("x", expressionSyntax.ToString());

Symbols\Source\LocationTests.cs (1)

35Assert.Equal("MetadataFile(CommonLanguageRuntimeLibrary)", obj.Locations[0].ToString());

Symbols\Source\MethodTests.cs (60)

Symbols\Source\NullablePublicAPITests.cs (1)

2636Assert.Equal("s", symbol.Name);

Symbols\Source\PropertyTests.cs (6)

412Assert.Equal(prop.Locations[0].ToString(), backField.Locations[0].ToString()); 431Assert.Equal(prop.Locations[0].ToString(), backField.Locations[0].ToString()); 451Assert.Equal("in", ein.Name); 452Assert.Equal("C1.@in", ein.ToString()); 454Assert.Equal("out", dout.Name); 455Assert.Equal("@out", dout.ToString());

Symbols\Source\RecordTests.cs (2)

1061Assert.Equal(v1.VisualizeIL("C.Equals(C)"), v2.VisualizeIL("C.Equals(C)")); 1062Assert.Equal(v1.VisualizeIL("C.Equals(object)"), v2.VisualizeIL("C.Equals(object)"));

Symbols\Source\UsingAliasTests.cs (42)

Symbols\StaticAbstractMembersInInterfacesTests.cs (32)

Symbols\SymbolDistinguisherTests.cs (34)

Symbols\SymbolErrorTests.cs (5)

2588Assert.Equal("B", baseType.Name); 2593Assert.Equal("BB", baseType.Name); 2598Assert.Equal("CC", baseType.Name); 16916Assert.Equal("B", fieldType.Name); 16953Assert.Equal("B", fieldType.Name);

Symbols\TypeResolutionTests.cs (4)

131Assert.Equal("System.StringComparison", strcmpSym.ToDisplayString()); 135Assert.Equal("System.Collections.Generic.List<int>[][*,*,*]", arraySym.ToDisplayString()); 139Assert.Equal("char**", ptrSym.ToDisplayString()); 143Assert.Equal(testType1 + ".C<int, bool>.D.E<double, float>.F<byte>", nestedSym1.ToDisplayString());

Symbols\TypeTests.cs (22)

Symbols\UnsignedRightShiftTests.cs (21)

Diagnostics\DiagnosticTest.cs (4)

74Assert.Equal("MOCK0001", di1.MessageIdentifier); 75Assert.Equal("The first error", di1.GetMessage(englishCulture)); 80Assert.Equal("MOCK1002", di2.MessageIdentifier); 81Assert.Equal("The second warning about Elvis and Mort", di2.GetMessage(englishCulture));

Diagnostics\LocationsTests.cs (16)

50Assert.Equal(expectedPath, mappedSpan.Path); 53Assert.Equal("", actualDisplayPath); 57Assert.Equal(string.Format("[{0};{1}]", expectedPath, hasMappedPath ? syntaxTree.FilePath : null), actualDisplayPath); 95Assert.Equal("c:\\goo.cs", flpsX.Path); 102Assert.Equal("d:\\banana.cs", flpsX.Path); 109Assert.Equal("c:\\goo.cs", flpsXToCloseBrace.Path); 116Assert.Equal("d:\\banana.cs", flpsXToCloseBrace.Path); 496Assert.Equal("SourceFile([91..93))", loc1.ToString()); 498Assert.Equal("SourceFile([148..150))", loc2.ToString()); 507Assert.Equal("test.txt(3,2): warning CS0000: msg", CSharpDiagnosticFormatter.Instance.Format(diagnostic, EnsureEnglishUICulture.PreferredOrNull)); 524Assert.Equal("test.txt(3,2): warning CS0000: msg", CSharpDiagnosticFormatter.Instance.Format(diagnosticWithoutMapping, EnsureEnglishUICulture.PreferredOrNull)); 527Assert.Equal("test2.txt(4,3): warning CS0000: msg", CSharpDiagnosticFormatter.Instance.Format(diagnosticWithMapping, EnsureEnglishUICulture.PreferredOrNull)); 530Assert.Equal(filePath, lineInfo.Path); 535Assert.Equal(filePath, mappedLineInfo.Path); 540Assert.Equal(filePath, lineInfo.Path); 545Assert.Equal(mappedFilePath, mappedLineInfo.Path);

IncrementalParsing\IncrementalParsingTests.cs (17)

654Assert.Equal("//", fullText); 706Assert.Equal(newText.ToString(), finalText); 720Assert.Equal(newText.ToString(), output); 1262Assert.Equal(parsedTree.GetCompilationUnitRoot().ToFullString(), incrementalTree.GetCompilationUnitRoot().ToFullString()); 1478Assert.Equal(parsedTree.GetText().ToString(), incrementalTree.GetText().ToString()); 1533Assert.Equal(parsedTree.GetText().ToString(), incrementalTree.GetText().ToString()); 1620Assert.Equal(parsedTree.GetText().ToString(), incrementalTree.GetText().ToString()); 1726Assert.Equal(parsedTree.GetCompilationUnitRoot().ChildNodesAndTokens()[0].AsNode().ToFullString(), incrementalTree.GetCompilationUnitRoot().ChildNodesAndTokens()[0].AsNode().ToFullString()); 1832Assert.Equal(parsedTree.GetCompilationUnitRoot().ToFullString(), incrementalTree.GetCompilationUnitRoot().ToFullString()); 2507Assert.Equal(oldText.ToString(), startTree.GetCompilationUnitRoot().ToFullString()); 2648Assert.Equal(fullText, incText); 2662Assert.Equal(fullText, incText); 2796Assert.Equal(text, oldRoot.ToFullString()); 2810Assert.Equal(oldClassC.ToFullString(), newClassC.ToFullString()); 2821Assert.Equal(oldToken.ToFullString(), newToken.ToFullString()); 3452Assert.Equal(pd.ElementAt(i).Inspect(), id.ElementAt(i).Inspect()); 3464Assert.Equal(oldText.ToString(), startTree.GetCompilationUnitRoot().ToFullString());

IncrementalParsing\NodeValidators.cs (10)

24Assert.Equal(pointerName.ElementType.ToString(), name); 31Assert.Equal(predefName.ToString(), typeName); 38Assert.Equal(arrayType.ElementType.ToString(), arrayName); 47Assert.Equal(aliasName.Alias.ToString(), alias); 48Assert.Equal(aliasName.Name.ToString(), name); 56Assert.Equal(dottedName.Left.ToString(), left); 57Assert.Equal(dottedName.Right.ToString(), right); 65Assert.Equal(genericName.Identifier.ToString(), name); 70Assert.Equal(genericName.TypeArgumentList.Arguments[i].ToString(), str); 80Assert.Equal(genericName.ToString(), name);

LexicalAndXml\DocumentationCommentLexerTestBase.cs (2)

62Assert.Equal(expectedToken.Text, actualToken.Text); //This first, since it's easiest to debug. 63Assert.Equal(expectedToken.ValueText, actualToken.ValueText);

LexicalAndXml\LexicalTests.cs (328)

LexicalAndXml\PreprocessorTests.cs (33)

LexicalAndXml\RawStringLiteralLexingTests.cs (3)

193Assert.Equal(input, token.ToFullString()); 197Assert.Equal(expectedValue, token.ValueText); 221Assert.All(diagnostics, d => Assert.Equal(spans.Single().Key, d.Id));

LexicalAndXml\SyntaxTokenParserTests.cs (1)

423Assert.Equal(text, leadingTrivia[i].ToFullString());

LexicalAndXml\XmlDocCommentTests.cs (245)

Parsing\DeclarationParsingTests.cs (519)

Parsing\DeconstructionTests.cs (2)

1883Assert.Equal("(T, T)[]", declaration.Type.ToString()); 1884Assert.Equal("id", declaration.Variables.ToString());

Parsing\ExpressionParsingTests.cs (252)

Parsing\InterpolatedStringExpressionTests.cs (2)

15Assert.Equal("$\"\"", SyntaxFactory.InterpolatedStringExpression(SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken)).ToFullString()); 21Assert.Equal("$\"goo\"", SyntaxFactory.InterpolatedStringExpression(

Parsing\InterpolationTests.cs (2)

14Assert.Equal("{a}", SyntaxFactory.Interpolation(SyntaxFactory.IdentifierName("a")).ToFullString()); 20Assert.Equal("{a,b:c}", SyntaxFactory.Interpolation(

Parsing\LocalFunctionParsingTests.cs (4)

1351Assert.Equal("int", s1.ReturnType.ToString()); 1352Assert.Equal("local", s1.Identifier.ToString()); 1361Assert.Equal("int", s1.ReturnType.ToString()); 1362Assert.Equal("local", s1.Identifier.ToString());

Parsing\NameParsingTests.cs (50)

Parsing\ParserErrorMessageTests.cs (1)

2634Assert.Equal("error CS1029: #error: '\u0444\u0430\u0439\u043B'", CSharpDiagnosticFormatter.Instance.Format(error.WithLocation(Location.None), EnsureEnglishUICulture.PreferredOrNull));

Parsing\ParserRegressionTests.cs (6)

227Assert.Equal("202", actualErrors.Count().ToString()); 228Assert.Equal("(1,1201): error CS1056: Unexpected character '\\u003C'", actualErrors.ElementAt(200).ToString(EnsureEnglishUICulture.PreferredOrNull)); 229Assert.Equal("(1,1207): error CS1056: Unexpected character '\\u003E\\u003E\\u003E\\u003E'", actualErrors.ElementAt(201).ToString(EnsureEnglishUICulture.PreferredOrNull)); 245Assert.Equal("202", actualErrors.Count().ToString()); 246Assert.Equal("(1,2001): error CS1056: Unexpected character '\\U0000003C'", actualErrors.ElementAt(200).ToString(EnsureEnglishUICulture.PreferredOrNull)); 247Assert.Equal("(1,2011): error CS1056: Unexpected character '\\u003E\\u003E\\u003E\\u003E'", actualErrors.ElementAt(201).ToString(EnsureEnglishUICulture.PreferredOrNull));

Parsing\ParsingErrorRecoveryTests.cs (337)

Parsing\ParsingTests.cs (3)

113Assert.Equal(text, node.ToFullString()); 135Assert.Equal(text, node.ToFullString()); 211Assert.Equal(current.ToString(), value);

Parsing\RoundTrippingTests.cs (6)

31Assert.Equal(text, toText); 57Assert.Equal(text, toText); 105Assert.Equal(text, toText); 1584Assert.Equal(text, newTest); 1593Assert.Equal(text, typeOfExpression.ToFullString()); 1597Assert.Equal("typeof(System.String ", typeOfExpression.ToFullString());

Parsing\ScriptParsingTests.cs (2)

39Assert.Equal(text, parsedText.ToFullString()); 9742Assert.Equal(expectedSkippedText, skippedText.ToString());

Parsing\StatementParsingTests.cs (287)

Syntax\SeparatedSyntaxListTests.cs (14)

54Assert.Equal("x", addList.ToFullString()); 57Assert.Equal("y,x", insertBefore.ToFullString()); 60Assert.Equal("x,y", insertAfter.ToFullString()); 63Assert.Equal("x,a,b,c,y", insertBetween.ToFullString()); 70Assert.Equal(@"a, // a is good 78Assert.Equal(@"a, 84Assert.Equal("a,c, /* b is best */ b", insertBeforeMultiLineComment.ToFullString()); 102Assert.Equal("A", list[0].ToString()); 103Assert.Equal("B", list[1].ToString()); 104Assert.Equal("C", list[2].ToString()); 249Assert.Equal("D", newList.ToFullString()); 253Assert.Equal("D,E", newList.ToFullString()); 257Assert.Equal("D", newList.ToFullString()); 261Assert.Equal("D,E", newList.ToFullString());

Syntax\StructuredTriviaTests.cs (13)

27Assert.Equal(conditionName, ((IdentifierNameSyntax)structuredTrivia.Condition).Identifier.ValueText); 53Assert.Equal(" <goo> </goo> ", xmlElement.ToFullString()); 54Assert.Equal("<goo> </goo>", xmlElement.ToString()); 57Assert.Equal(" <goo> </goo> ", docComment.ToFullString()); 60Assert.Equal(" <goo> </goo> ", child.ToFullString()); 61Assert.Equal("<goo> </goo>", child.ToString()); 62Assert.Equal(" <goo> ", child.StartTag.ToFullString()); 63Assert.Equal("<goo>", child.StartTag.ToString()); 69Assert.Equal(" <goo> </goo> banana ", ident.ToFullString()); 70Assert.Equal("banana", ident.ToString()); 71Assert.Equal(" <goo> </goo> ", ident.LeadingTrivia[0].ToFullString()); 79Assert.Equal("goo", result.ToString()); 83Assert.Equal(" ", trResult.ToString());

Syntax\SyntaxDiffingTests.cs (18)

Syntax\SyntaxFactoryTests.cs (36)

Syntax\SyntaxListTests.cs (8)

58Assert.Equal("A", list[0].ToString()); 59Assert.Equal("B", list[1].ToString()); 60Assert.Equal("C", list[2].ToString()); 201Assert.Equal("D ", newList.ToFullString()); 205Assert.Equal("D E ", newList.ToFullString()); 209Assert.Equal("D ", newList.ToFullString()); 213Assert.Equal("D E ", newList.ToFullString()); 306Assert.Equal(expectedArgName, ((ArgumentSyntax)item).Expression.ToString());

Syntax\SyntaxNodeOrTokenListTests.cs (7)

45Assert.Equal("A", list[0].ToString()); 46Assert.Equal("B", list[1].ToString()); 47Assert.Equal("C", list[2].ToString()); 190Assert.Equal("D ", newList.ToFullString()); 194Assert.Equal("D E ", newList.ToFullString()); 198Assert.Equal("D ", newList.ToFullString()); 202Assert.Equal("D E ", newList.ToFullString());

Syntax\SyntaxNodeTests.cs (122)

Syntax\SyntaxNormalizerTests.cs (10)

Syntax\SyntaxRewriterTests.cs (13)

Syntax\SyntaxTests.cs (1)

184Assert.Equal(expected, actual);

Syntax\SyntaxTokenListTests.cs (7)

67Assert.Equal("A", list[0].ToString()); 68Assert.Equal("B", list[1].ToString()); 69Assert.Equal("C", list[2].ToString()); 210Assert.Equal("D ", newList.ToFullString()); 214Assert.Equal("D E ", newList.ToFullString()); 218Assert.Equal("D ", newList.ToFullString()); 222Assert.Equal("D E ", newList.ToFullString());

Syntax\SyntaxTreeTests.cs (14)

94Assert.Equal("#define U | #undef U | #define Y", ((CSharpSyntaxTree)tree).GetDirectives().GetDebuggerDisplay()); 249Assert.Equal(newRoot.ToString(), newTree.GetRoot().ToString()); 267Assert.Equal(newRoot.ToString(), newTree.GetRoot().ToString()); 280Assert.Equal(newRoot.ToString(), newTree.GetRoot().ToString()); 291Assert.Equal("new.cs", newTree.FilePath); 292Assert.Equal(oldTree.ToString(), newTree.ToString()); 307Assert.Equal("new.cs", newTree.FilePath); 308Assert.Equal(oldTree.ToString(), newTree.ToString()); 320Assert.Equal("new.cs", newTree.FilePath); 321Assert.Equal(oldTree.ToString(), newTree.ToString()); 328Assert.Equal(string.Empty, oldTree.WithFilePath(null).FilePath); 330Assert.Equal(string.Empty, oldTree.WithFilePath(null).FilePath); 331Assert.Equal(string.Empty, SyntaxFactory.ParseSyntaxTree("", path: null).FilePath); 332Assert.Equal(string.Empty, CSharpSyntaxTree.Create((CSharpSyntaxNode)oldTree.GetRoot()).FilePath);

Syntax\SyntaxTriviaListTests.cs (32)

Syntax\TrackNodeTests.cs (7)

28Assert.Equal("a", currentA.ToString()); 40Assert.Equal("a", currentAs.ElementAt(0).ToString()); 74Assert.Equal(newA.ToFullString(), latestA.ToFullString()); 89Assert.Equal(newA.ToFullString(), latestAs.ElementAt(0).ToFullString()); 141Assert.Equal("a", nodes[0].ToString()); 142Assert.Equal("a", nodes[1].ToString()); 159Assert.Equal(id.ToString(), currentId.ToString());

AttributeValidation.cs (3)

22Assert.Equal("IsUnmanagedAttribute", attributeType.Name); 33Assert.Equal(WellKnownTypes.GetMetadataName(WellKnownType.System_Runtime_CompilerServices_CompilerGeneratedAttribute), isUnmanagedTypeAttributes[0].AttributeClass.ToDisplayString()); 34Assert.Equal(AttributeDescription.CodeAnalysisEmbeddedAttribute.FullName, isUnmanagedTypeAttributes[1].AttributeClass.ToDisplayString());

CompilationTestUtils.cs (4)

40Assert.Equal(symbolDescriptions[i], descriptions[i]); 55Assert.Equal(symbolDescriptions[i], descriptions[i]); 74Assert.Equal(symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat), description); 79Assert.Equal(symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat), description);

CSharpTestBase.cs (3)

1109Assert.Equal(text, parsedText.ToFullString()); 1553Assert.Equal(expectedMessage, e.Message); 1778Assert.Equal(bindText, node.ToString());

Extensions.cs (1)

413Assert.Equal(namedArg.Key, name);

FunctionPointerUtilities.cs (3)

59Assert.Equal(string.Empty, symbol.Name); 109Assert.Equal(string.Empty, symbol.Name); 338=> typeSymbol => Assert.Equal(typeName, typeSymbol.Name);

Metadata\WinMdEventTests.cs (1)

3348Assert.Equal("EventRegistrationTokenTable", fieldType.Name);

Metadata\WinMdMetadataTests.cs (3)

137Assert.Equal("System.Runtime.WindowsRuntime.dll", ((PENamedTypeSymbol)((((PropertySymbol)(blk)).GetMethod).ReturnType)).ContainingModule.ToString()); 180Assert.Equal("ulong?", 244Assert.Equal("C1, W, Version=255.255.255.255, Culture=neutral, PublicKeyToken=null, ContentType=WindowsRuntime", value);

CodeGeneration\AddAttributesTests.cs (1)

63Assert.Equal(attributeAddedText, actualText);

CodeGeneration\AddImportsTests.cs (2)

97Assert.Equal(importsAddedText, actualText); 820Assert.Equal(@"using System;

CodeGeneration\SymbolEditorTests.cs (32)

CodeGeneration\SyntaxGeneratorTests.cs (113)

CSharpCommandLineParserServiceTests.cs (6)

27Assert.Equal("true", options.Features["test"]); 34Assert.Equal("dog", options.Features["test"]); 41Assert.Equal("true", options.Features["test1"]); 42Assert.Equal("true", options.Features["test2"]); 49Assert.Equal("dog", options.Features["test1"]); 50Assert.Equal("cat", options.Features["test2"]);

Formatting\EditorConfigOptionParserTests.cs (2)

31Assert.Equal(roundtrip, CSharpFormattingOptions2.ToEditorConfigValue(value)); 107Assert.Equal(roundtrip, CSharpFormattingOptions2.ToEditorConfigValue(value));

Formatting\FormattingElasticTriviaTests.cs (5)

90Assert.Equal(expected, newCompilation.ToFullString()); 130Assert.Equal(expected, formatted); 133Assert.Equal(expected, elasticOnlyFormatted); 136Assert.Equal(expected, annotationFormatted); 186Assert.Equal(expected, newCompilation.ToFullString());

Formatting\FormattingTests.cs (1)

4657Assert.Equal(expected, newProperty.ToFullString());

Formatting\FormattingTreeEditTests.cs (2)

48Assert.Equal(@" 61Assert.Equal(@"

Formatting\FormattingTriviaTests.cs (2)

1757Assert.Equal(expected, actual); 1801Assert.Equal(expected, actual);

AbstractCommandHandlerTestState.cs (1)

249Assert.Equal(expectedLine.Trim(), SubjectBuffer.CurrentSnapshot.GetLineFromLineNumber(line).GetText().Trim());

AbstractTypingCommandHandlerTest.cs (1)

49Assert.Equal(expectedCode, view.TextSnapshot.GetText());

AutomaticCompletion\AbstractAutomaticBraceCompletionTests.cs (1)

94=> Assert.Equal(result, session.SubjectBuffer.CurrentSnapshot.GetText());

AutomaticCompletion\AbstractAutomaticLineEnderTests.cs (1)

110Assert.Equal(expected, buffer.CurrentSnapshot.GetText());

Classification\ClassificationTestHelper.cs (3)

30Assert.Equal(expectedText, actualText); 55Assert.Equal(expected.Text, text); 56Assert.Equal(expected.ClassificationName, actual.ClassificationType);

CommentSelection\AbstractToggleCommentTestBase.cs (1)

72Assert.Equal(actualExpectedText, textBuffer.CurrentSnapshot.GetText());

Completion\AbstractArgumentProviderTests`1.cs (1)

72Assert.Equal(expectedDefaultValue, context.DefaultValue);

Completion\AbstractCompletionProviderTests.cs (4)

501Assert.Equal(codeBeforeCommit, actualExpectedCode); 543Assert.Equal(codeBeforeCommit, actualExpectedCode); 558Assert.Equal(actualExpectedCode, actualCodeAfterCommit); 622Assert.Equal(expectedCodeAfterCommit, text.ToString());

DocumentationComments\AbstractDocumentationCommentTests.cs (2)

165Assert.Equal(expectedCode, actual); 170Assert.Equal(expectedMarkup, actualWithCaret);

DocumentationComments\AbstractXmlTagCompletionTests.cs (1)

42Assert.Equal(expectedCode, view.TextSnapshot.GetText());

ExtractInterface\AbstractExtractInterfaceTests.cs (7)

115Assert.Equal(expectedMemberName, testState.TestExtractInterfaceOptionsService.AllExtractableMembers.Single().Name); 120Assert.Equal(expectedInterfaceName, testState.TestExtractInterfaceOptionsService.DefaultInterfaceName); 125Assert.Equal(expectedNamespaceName, testState.TestExtractInterfaceOptionsService.DefaultNamespace); 130Assert.Equal(expectedTypeParameterSuffix, testState.TestExtractInterfaceOptionsService.GeneratedNameTypeParameterSuffix); 137Assert.Equal(expectedUpdatedOriginalDocumentCode, updatedCode); 144Assert.Equal(expectedInterfaceCode, interfaceCode); 164Assert.Equal(expectedMarkup, updatedCode);

Formatting\CoreFormatterTestsBase.cs (4)

150Assert.Equal(expected, view.TextSnapshot.GetText()); 217Assert.Equal(expected, newRootNode.ToFullString()); 267Assert.Equal(expected, view.TextSnapshot.GetText()); 293Assert.Equal(expected, actual);

NavigateTo\AbstractNavigateToTests.cs (8)

175Assert.Equal(expectedItem.Name, actualItem.Name); 178Assert.Equal(expectedItem.Language, actualItem.Language); 179Assert.Equal(expectedItem.Kind, actualItem.Kind); 193Assert.Equal(name, result.Name); 195Assert.Equal(this.Language, result.Language); 196Assert.Equal(navigateToItemKind, result.Kind); 204Assert.Equal(displayMarkup, itemDisplay.Name); 211Assert.Equal(additionalInfo, itemDisplay.AdditionalInformation);

QuickInfo\AbstractSemanticQuickInfoSourceTests.cs (1)

68Assert.Equal(expectedText, actualText);

QuickInfo\ToolTipAssert.cs (4)

78Assert.Equal(expected.AutomationName, actual.AutomationName); 92Assert.Equal(expected.ClassificationTypeName, actual.ClassificationTypeName); 93Assert.Equal(expected.Text, actual.Text); 94Assert.Equal(expected.Tooltip, actual.Tooltip);

Rename\RenamerTests.cs (1)

93Assert.Equal(endDocument.DocumentName, updatedDocument.Name);

SignatureHelp\AbstractSignatureHelpProviderTests.cs (2)

245Assert.Equal(expectedTestItem.Description, ToString(actualSignatureHelpItem.DescriptionParts)); 253Assert.Equal(string.Join(", ", classificationTypeNames), string.Join(", ", classifiedSpans.Select(s => s.ClassificationType)));

Structure\AbstractSyntaxStructureProviderTests.cs (1)

111Assert.Equal(expected.BannerText, actual.BannerText);

CodeFixes\CodeFixServiceTests.cs (3)

128Assert.Equal(codeFix.FixableDiagnosticIds.Single(), analyzerWithFix.SupportedDiagnostics.Single().Id); 892Assert.Equal("Additional Document", txtDocument.GetTextSynchronously(CancellationToken.None).ToString()); 893Assert.Equal($"Additional Document{fixer1.Title}", changedtxtDocument.GetTextSynchronously(CancellationToken.None).ToString());

CodeFixes\ExtensionOrderingTests.cs (3)

81Assert.Equal(PredefinedConfigurationFixProviderNames.Suppression, actualOrder[0].Metadata.Name); 82Assert.Equal(PredefinedConfigurationFixProviderNames.ConfigureCodeStyleOption, actualOrder[1].Metadata.Name); 83Assert.Equal(PredefinedConfigurationFixProviderNames.ConfigureSeverity, actualOrder[2].Metadata.Name);

CodeGeneration\CodeGenerationTests.cs (1)

962Assert.Equal(_expected, actual);

CodeRefactorings\CodeRefactoringServiceTest.cs (2)

183Assert.Equal(refactoring1.Title, changedtxtDocument.GetTextSynchronously(CancellationToken.None).ToString()); 222Assert.Equal(refactoring1.Title, changedEditorConfig.GetTextSynchronously(CancellationToken.None).ToString());

Collections\Immutable\Maps\MapTests.cs (2)

24Assert.Equal("1", v.Key); 30Assert.Equal("1", ((KeyValuePair<string, int>)v).Key);

Diagnostics\AnalyzerLoadFailureTests.cs (1)

35Assert.Equal(languageName, diagnostic.Language);

Diagnostics\DiagnosticAnalyzerServiceTests.cs (5)

677Assert.Equal($"#pragma warning disable {NamedTypeAnalyzer.DiagnosticId} // Unnecessary", pragma1); 679Assert.Equal($"#pragma warning disable CS0168 // Variable is declared but never used - Unnecessary", pragma2); 684Assert.Equal($@"System.Diagnostics.CodeAnalysis.SuppressMessage(""Category2"", ""{NamedTypeAnalyzer.DiagnosticId}"")", attribute1); 686Assert.Equal($@"System.Diagnostics.CodeAnalysis.SuppressMessage(""Category3"", ""CS0168"")", attribute2); 783Assert.Equal(expectedText, actualText);

Diagnostics\IDEDiagnosticIDConfigurationTests.cs (1)

85Assert.Equal("https://github.com/dotnet/roslyn/issues/41640", helpLinkUri);

EditAndContinue\EditAndContinueLanguageServiceTests.cs (2)

276Assert.Equal(source1, (await documentState.GetTextAsync(CancellationToken.None)).ToString()); 283Assert.Equal(source1, (await document.GetTextAsync(CancellationToken.None)).ToString());

EditorAdapter\TextSnapshotImplementationTest.cs (3)

34Assert.Equal(tuple.Item1.GetText(), text.ToString()); 45Assert.Equal("goo", line1.ToString()); 56Assert.Equal("bar", line1.ToString());

EditorConfigSettings\Data\CodeStyleSettingsTest.cs (4)

41Assert.Equal(string.Empty, setting.Category); 42Assert.Equal("TestDesciption", setting.Description); 72Assert.Equal(string.Empty, setting.Category); 73Assert.Equal("TestDesciption", setting.Description);

Emit\CompilationOutputFilesTests.cs (1)

53Assert.Equal("lib", mdReader.GetString(mdReader.GetAssemblyDefinition().Name));

Extensions\IProjectionBufferFactoryServiceExtensionsTests.cs (8)

73Assert.Equal("...", lines[0].GetText()); 74Assert.Equal(" line 2", lines[1].GetText()); 75Assert.Equal("...", lines[2].GetText()); 76Assert.Equal(" line 4", lines[3].GetText()); 103Assert.Equal("line 1", lines[0].GetText()); 104Assert.Equal("...", lines[1].GetText()); 105Assert.Equal("line 3", lines[2].GetText()); 106Assert.Equal(" line 4", lines[3].GetText());

Extensions\ITextExtensionsTests.cs (16)

Extensions\ITextSnapshotExtensionsTests.cs (16)

InheritanceMargin\InheritanceMarginTests.cs (2)

141Assert.Equal(expectedTarget.TargetSymbolName, actualTarget.DisplayName); 148Assert.Equal(expectedTarget.ProjectName, actualTarget.ProjectName);

LinkedFiles\LinkedFileDiffMergingEditorTests.cs (2)

91Assert.Equal(s_expectedCode, (await workspace.CurrentSolution.GetRequiredDocument(documentId).GetTextAsync()).ToString()); 92Assert.Equal(s_expectedCode, (await workspace.CurrentSolution.GetRequiredDocument(linkedDocumentId).GetTextAsync()).ToString());

MetadataAsSource\AbstractMetadataAsSourceTests.cs (1)

64Assert.Equal(expected, lineText);

MetadataAsSource\DocCommentFormatterTests.cs (2)

33Assert.Equal(expectedCSharp, csharpFormattedComment); 34Assert.Equal(expectedVB, vbFormattedComment);

MetadataAsSource\MetadataAsSourceTests.cs (2)

1718Assert.Equal("mscorlib", openedDocument.Project.AssemblyName); 1719Assert.Equal("mscorlib", openedDocument.Project.Name);

MetadataAsSource\MetadataAsSourceTests.CSharp.cs (1)

33Assert.Equal(expectedXMLFragment, extractedXMLFragment);

MetadataAsSource\MetadataAsSourceTests.VisualBasic.cs (1)

193Assert.Equal(expectedXMLFragment, extractedXMLFragment);

Preview\PreviewWorkspaceTests.cs (1)

82Assert.Equal(previewWorkspace.CurrentSolution.Projects.First().Documents.First().GetTextAsync().Result.ToString(), text);

RenameTracking\RenameTrackingTaggerProviderTests.cs (11)

StackTraceExplorer\StackTraceExplorerTests.cs (1)

70Assert.Equal(contents[i], frames[i].ToString());

Structure\BlockSpanTests.cs (3)

29Assert.Equal(bannerText, outliningRegion.BannerText); 45Assert.Equal("{Span=[0..1), HintSpan=[2..3), BannerText=\"Goo\", AutoCollapse=True, IsDefaultCollapsed=False}", outliningRegion.ToString()); 59Assert.Equal("{Span=[0..1), BannerText=\"Goo\", AutoCollapse=True, IsDefaultCollapsed=False}", outliningRegion.ToString());

Structure\StructureTaggerTests.cs (38)

TextEditor\OpenDocumentTests.cs (4)

65Assert.Equal("Hello, World!", newDocumentWithChanges.GetTextSynchronously(CancellationToken.None).ToString()); 66Assert.Equal("Hello, World!", newDocumentWithChanges.GetLinkedDocuments().Single().GetTextSynchronously(CancellationToken.None).ToString()); 71Assert.Equal("Hello", originalDocumentWithChanges.GetTextSynchronously(CancellationToken.None).ToString()); 72Assert.Equal("Hello", originalDocumentWithChanges.GetLinkedDocuments().Single().GetTextSynchronously(CancellationToken.None).ToString());

TextEditor\TryGetDocumentTests.cs (1)

43Assert.Equal(expected, newSourceText.ToString());

ValueTracking\AbstractBaseValueTrackingTests.cs (1)

89Assert.Equal(text, item.ToString());

Workspaces\TextFactoryTests.cs (2)

94Assert.Equal(text.ToString(), text2.ToString()); 114Assert.Equal(text.ToString(), text2.ToString());

VisualBasicParsingTests.cs (1)

50Assert.Equal(expectedKind, actualKind);

ResultProviderTestBase.cs (8)

Snippets\AbstractSnippetProviderTests.cs (1)

67Assert.Equal(markupAfterCommit, documentTextAfterSnippet.ToString());

EditAndContinue\EditAndContinueDiagnosticDescriptorsTests.cs (10)

21Assert.Equal("ENC0001", d.Id); 22Assert.Equal(DiagnosticCategory.EditAndContinue, d.Category); 25Assert.Equal("", d.HelpLinkUri); 30Assert.Equal("ENC0087", EditAndContinueDiagnosticDescriptors.GetDescriptor(RudeEditKind.ComplexQueryExpression).Id); 33Assert.Equal("ENC1001", d.Id); 34Assert.Equal(DiagnosticCategory.EditAndContinue, d.Category); 37Assert.Equal("", d.HelpLinkUri); 43Assert.Equal("ENC2012", d.Id); 44Assert.Equal(DiagnosticCategory.EditAndContinue, d.Category); 47Assert.Equal("", d.HelpLinkUri);

EditAndContinue\EditAndContinueMethodDebugInfoReaderTests.cs (1)

112Assert.Equal("21-C8-B2-D7-A3-6B-49-C7-57-DF-67-B8-1F-75-DF-6A-64-FD-59-22", BitConverter.ToString([.. actualChecksum]));

CodeActions\RunCodeActionsTests.cs (1)

60Assert.Equal(expectedTextForB, textForB.ToString());

Completion\CompletionResolveTests.cs (1)

343Assert.Equal("(byte)", results.Label);

Diagnostics\PullDiagnosticTests.cs (2)

179Assert.Equal(vsDiagnostic.ExpandedMessage, AnalyzersResources.Avoid_unused_parameters_in_your_code_If_the_parameter_cannot_be_removed_then_change_its_name_so_it_starts_with_an_underscore_and_is_optionally_followed_by_an_integer_such_as__comma__1_comma__2_etc_These_are_treated_as_special_discard_symbol_names); 508Assert.Equal(csproj1Diagnostic.Identifier, csproj2Diagnostic.Identifier);

DocumentChanges\DocumentChangesTests.cs (9)

52Assert.Equal(documentText, document.ToString()); 57Assert.Equal(expected, document.ToString()); 85Assert.Equal(documentText, document.ToString()); 206Assert.Equal(expected, document.ToString()); 241Assert.Equal(documentText, documentTextFromWorkspace); 284Assert.Equal(expected, document.ToString()); 323Assert.Equal(expected, document.ToString()); 363Assert.Equal(expected, document.ToString()); 447Assert.Equal(expected, document.ToString());

DocumentChanges\DocumentChangesTests.LinkedDocuments.cs (2)

43Assert.Equal(documentText, document.GetTextSynchronously(CancellationToken.None).ToString()); 94Assert.Equal(updatedText, document.GetTextSynchronously(CancellationToken.None).ToString());

Formatting\FormatDocumentOnTypeTests.cs (2)

51Assert.Equal(expected, actualText); 82Assert.Equal(expected, actualText);

Formatting\FormatDocumentRangeTests.cs (2)

48Assert.Equal(expected, actualText); 76Assert.Equal(expected, actualText);

Formatting\FormatDocumentTests.cs (3)

49Assert.Equal(expected, actualText); 77Assert.Equal(expected, actualText); 105Assert.Equal(expected, actualText);

Hover\HoverTests.cs (1)

514Assert.Equal(expectedContent, content);

MapCode\MapCodeTests.cs (1)

136Assert.Equal(expected, actualText);

Miscellaneous\LspMiscellaneousFilesWorkspaceTests.cs (2)

242Assert.Equal(LanguageNames.CSharp, miscDoc.Project.Language); 286Assert.Equal(LanguageNames.CSharp, miscDoc.Project.Language);

ProtocolConversionsTests.cs (20)

38Assert.Equal(expectedAbsoluteUri, ProtocolConversions.GetAbsoluteUriString(filePath)); 41Assert.Equal(expectedAbsoluteUri, uri.AbsoluteUri); 42Assert.Equal(filePath, uri.LocalPath); 65Assert.Equal(expectedAbsoluteUri, ProtocolConversions.GetAbsoluteUriString(filePath)); 68Assert.Equal(expectedAbsoluteUri, uri.AbsoluteUri); 69Assert.Equal(filePath.Replace('/', '\\'), uri.LocalPath); 79Assert.Equal(expectedRawUri, ProtocolConversions.GetAbsoluteUriString(filePath)); 82Assert.Equal(expectedNormalizedUri, uri.AbsoluteUri); 83Assert.Equal(Path.GetFullPath(filePath).Replace('/', '\\'), uri.LocalPath); 99Assert.Equal(expectedAbsoluteUri, ProtocolConversions.GetAbsoluteUriString(filePath)); 102Assert.Equal(expectedAbsoluteUri, uri.AbsoluteUri); 103Assert.Equal(filePath, uri.LocalPath); 126Assert.Equal(expectedUri, uri.AbsoluteUri); 144Assert.Equal(expectedRelativeUri, uri.AbsoluteUri); 154Assert.Equal(expectedRawUri, ProtocolConversions.GetAbsoluteUriString(filePath)); 157Assert.Equal(expectedNormalizedUri, uri.AbsoluteUri); 158Assert.Equal(filePath, uri.LocalPath); 167Assert.Equal(url, ProtocolConversions.CreateAbsoluteUri(url).AbsoluteUri); 179Assert.Equal(expectedAbsoluteUri, url.AbsoluteUri); 188Assert.Equal(expectedAbsoluteUri, url.AbsoluteUri);

References\FindAllReferencesHandlerTests.cs (1)

130Assert.Equal("class A", actualText);

Symbols\DocumentSymbolsTests.cs (1)

165Assert.Equal(expected.Name, actual.Name);

UriTests.cs (7)

153Assert.Equal(fileDocumentText, fileTextResult.ToString()); 160Assert.Equal(gitDocumentText, gitText.ToString()); 190Assert.Equal("LSP text", originalText.ToString()); 207Assert.Equal("LSP text", encodedText.ToString()); 242Assert.Equal("LSP text", originalText.ToString()); 255Assert.Equal("LSP text", lowerCaseText.ToString()); 290Assert.Equal("LSP text", originalText.ToString());

Workspaces\LspWorkspaceManagerTests.cs (24)

BasicDeterministicKeyBuilderTests.cs (2)

148Assert.Equal(effective.ToString(), obj.Value<string>("languageVersion")); 149Assert.Equal(languageVersion.ToString(), obj.Value<string>("specifiedLanguageVersion"));

CSharpDeterministicKeyBuilderTests.cs (4)

285Assert.Equal(binderFlags.ToString(), value.Value<string>("topLevelBinderFlags")); 286Assert.Equal(nullableContextOptions.ToString(), value.Value<string>("nullableContextOptions")); 330Assert.Equal(effective.ToString(), obj.Value<string>("languageVersion")); 331Assert.Equal(languageVersion.ToString(), obj.Value<string>("specifiedLanguageVersion"));

DeterministicKeyBuilderTests.cs (8)

82Assert.Equal(expected, actual); 316Assert.Equal(outputKind.ToString(), obj.Value<string>("outputKind")); 354Assert.Equal(key, compilation.GetDeterministicKey()); 376Assert.Equal(expected.ToString(), actual.ToString()); 432Assert.Equal(sourceCodeKind.ToString(), obj.Value<string>("kind")); 433Assert.Equal(documentationMode.ToString(), obj.Value<string>("documentationMode")); 568Assert.Equal(@"util.pdb", obj.Value<string>("pdbFilePath")); 585Assert.Equal(@"c:\src\util.pdb", obj.Value<string>("pdbFilePath"));

TelemetryLoggerTests.cs (2)

100Assert.Equal("vs/ide/vbcs/debugging/encsession/editsession/emitdeltaerrorid", postedEvent.Name); 122Assert.Equal("vs/ide/vbcs/debugging/encsession/editsession/emitdeltaerrorid", scope.EndEvent.Name);

GlobalAssemblyCacheTests.cs (8)

30Assert.Equal("mscorlib", name.Name); 37Assert.Equal("mscorlib", name.Name); 44Assert.Equal("mscorlib", name.Name); 51Assert.Equal("System.Core", name.Name); 60Assert.Equal("System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", name.GetDisplayName()); 71Assert.Equal("System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", name.GetDisplayName()); 99Assert.Equal("netstandard", name.Name); 116Assert.Equal(Path.GetFullPath(location), location);

MetadataShadowCopyProviderTests.cs (7)

91Assert.Equal(dll.Path, sc1.PrimaryModule.OriginalPath); 231Assert.Equal(Path.Combine(Path.GetDirectoryName(sc.PrimaryModule.FullPath), @"a.xml"), sc.DocumentationFile.FullPath); 232Assert.Equal("Invariant", File.ReadAllText(sc.DocumentationFile.FullPath)); 237Assert.Equal(Path.Combine(Path.GetDirectoryName(sc.PrimaryModule.FullPath), @"el-GR", "a.xml"), sc.DocumentationFile.FullPath); 238Assert.Equal("Greek", File.ReadAllText(sc.DocumentationFile.FullPath)); 243Assert.Equal(Path.Combine(Path.GetDirectoryName(sc.PrimaryModule.FullPath), @"a.xml"), sc.DocumentationFile.FullPath); 244Assert.Equal("Invariant", File.ReadAllText(sc.DocumentationFile.FullPath));

ObjectFormatterTestBase.cs (3)

26Assert.Equal(expected[i] + " {", line); 30Assert.Equal(expected[i] + Environment.NewLine + "}" + Environment.NewLine, line); 34Assert.Equal(expected[i] + ",", line);

ScriptingTestHelpers.cs (3)

30Assert.Equal(expectedOutput, output.Trim()); 45Assert.Equal(expectedOutput, output.Trim()); 57Assert.Equal(expectedOutput, output.Trim());

NuGetPackageResolverTests.cs (2)

47Assert.Equal(expectedName, name); 48Assert.Equal(expectedVersion, version);

CommonTestBase.cs (1)

667Assert.Equal(original, cloned);

Compilation\OperationTreeVerifier.cs (1)

879Assert.Equal(argumentNames[i], operation.GetArgumentName(i));

Compilation\TestOperationVisitor.cs (3)

56Assert.Equal(LanguageNames.CSharp, operation.Parent.Language); 1489Assert.Equal("Deconstruct", method.Name); 1493Assert.Equal("ITuple", type.Name);

Diagnostics\CommonDiagnosticAnalyzers.cs (5)

1289Assert.Equal(new ArgumentNullException("operationBlock").Message, ex.Message); 1298Assert.Equal(new ArgumentException(CodeAnalysisResources.InvalidOperationBlockForAnalysisContext, "operationBlock").Message, ex.Message); 2175Assert.Equal(SuppressionDescriptor.SuppressedDiagnosticId, diagnostic.Id); 2308Assert.Equal(_unsupportedDescriptor.SuppressedDiagnosticId, diagnostic.Id); 2340Assert.Equal(_supportedDescriptor.SuppressedDiagnosticId, diagnostic.Id);

EncodingTestHelpers.cs (1)

55Assert.Equal(expected.WebName, actual.WebName);

PDB\DeterministicBuildCompilationTestHelpers.cs (4)

31Assert.Equal(expectedValueString, actualValueString); 63Assert.Equal(compilerVersion.ToString(), pdbOptions["compiler-version"]); 66Assert.Equal(runtimeVersion, pdbOptions[CompilationOptionNames.RuntimeVersion]); 73Assert.Equal(compilation.Language, pdbOptions["language"]);

PDB\MetadataReferenceInfo.cs (1)

44Assert.Equal(Name, other.Name);

AnalyzerAssemblyLoaderTests.cs (30)

188Assert.Equal("TestAnalyzer", analyzers[0].ToString()); 260Assert.Equal(expected, actual); 284Assert.Equal(name.FullName, assembly.GetName().FullName); 328Assert.Equal(@"", actual); 335Assert.Equal(@"Delta: Gamma: Beta: Test B 483Assert.Equal(@"Delta: Gamma: Test G 515Assert.Equal(@"Delta: Gamma: Test G 545Assert.Equal(externalAccessRazorPath, assembly.Location); 583Assert.Equal(externalAccessRazorPath, razorAssembly.Location); 631Assert.Equal(@"Delta: Gamma: Test G 680Assert.Equal(@"Delta: Gamma: Test G 710Assert.Equal("TestAnalyzer", analyzers[0].ToString()); 768Assert.Equal( 811Assert.Equal( 829Assert.Equal( 864Assert.Equal( 879Assert.Equal( 951Assert.Equal( 968Assert.Equal( 1013Assert.Equal( 1027Assert.Equal( 1081Assert.Equal( 1089Assert.Equal( 1120Assert.Equal( 1154Assert.Equal( 1184Assert.Equal( 1214Assert.Equal("42", sb.ToString()); 1233Assert.Equal(ExecutionConditionUtil.IsCoreClr ? "1" : "42", sb.ToString()); 1322Assert.Equal( 1364Assert.Equal(@"Delta: Gamma: Test G

Analyzers\AnalyzerConfigTests.cs (46)

Analyzers\AnalyzerFileReferenceTests.cs (47)

AssemblyUtilitiesTests.cs (2)

125Assert.Equal(expected: "netstandard", actual: results[0].Name); 140Assert.Equal(expected: "Alpha", actual: result.Name);

Collections\ImmutableArrayExtensionsTests.cs (2)

47Assert.Equal("hello", e.First()); 49Assert.Equal("hello", aa[0]);

Collections\ImmutableDictionaryBuilderTestBase.nonnetstandard.cs (3)

24Assert.Equal("a", actualKey); 27Assert.Equal("a", actualKey); 30Assert.Equal("b", actualKey);

Collections\ImmutableDictionaryTestBase.cs (3)

228Assert.Equal("a", actualKey); 231Assert.Equal("a", actualKey); 234Assert.Equal("b", actualKey);

Collections\ImmutableSetTest.nonnetstandard.cs (2)

104Assert.Equal("foo", actual); 107Assert.Equal("nonexistent", actual);

Collections\RopeTests.cs (6)

39Assert.Equal(string.Empty, r.ToString()); 59Assert.Equal(s, Rope.ForString(s).ToString()); 77Assert.Equal(c1.ToString(), s); 78Assert.Equal(c2.ToString(), s); 83Assert.Equal(c3.ToString(), s); 114Assert.Equal(concatted[..i], r.ToString(i));

CommonCommandLineParserTests.cs (20)

CommonSyntaxTests.cs (18)

CorLibTypesTests.cs (5)

244Assert.Equal($"ConstantValueNull(null: {value})", cv.ToString()); 247Assert.Equal($"ConstantValueNull(null: {value})", cv.ToString()); 253Assert.Equal(@"ConstantValueString(""QC"": String)", cv.ToString()); 256Assert.Equal("ConstantValueI8(-128: SByte)", cv.ToString()); 259Assert.Equal("ConstantValueI64(123456789: UInt64)", cv.ToString());

Diagnostics\DiagnosticLocalizationTests.cs (20)

Diagnostics\OperationTests.cs (10)

59Assert.Equal(name, dynamicExpression.GetArgumentName(0)); 158Assert.Equal(new ArgumentException(argumentExceptionMessage, "body").Message, ex.Message); 176Assert.Equal(new ArgumentException(argumentExceptionMessage, "initializer").Message, ex.Message); 194Assert.Equal(new ArgumentException(argumentExceptionMessage, "initializer").Message, ex.Message); 212Assert.Equal(new ArgumentException(argumentExceptionMessage, "initializer").Message, ex.Message); 234Assert.Equal(new ArgumentException(argumentExceptionMessage, "constructorBody").Message, ex.Message); 254Assert.Equal(new ArgumentException(argumentExceptionMessage, "methodBody").Message, ex.Message); 287Assert.Equal(ex.Message, new ArgumentNullException("node").Message); 300Assert.Equal(ex.Message, new ArgumentNullException("semanticModel").Message); 315Assert.Equal(ex.Message, new ArgumentException(CodeAnalysisResources.NotARootOperation, "operation").Message);

Diagnostics\SarifErrorLoggerTests.cs (2)

48Assert.Equal(ExpectedOutputForAdditionalLocationsAsRelatedLocations, actual); 88Assert.Equal(ExpectedOutputForDescriptorIdCollision, actual);

DiffUtilTests.cs (1)

31Assert.Equal(@" A

EmbeddedTextTests.cs (13)

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); 172Assert.Equal(

FileLinePositionSpanTests.cs (3)

83Assert.Equal("C:\\goo.cs: (1,2)-(3,5)", new FileLinePositionSpan("C:\\goo.cs", new LinePosition(1, 2), new LinePosition(3, 5)).ToString()); 84Assert.Equal("\\server\\goo.vb: (1,2)-(3,5)", new FileLinePositionSpan("\\server\\goo.vb", new LinePosition(1, 2), new LinePosition(3, 5)).ToString()); 85Assert.Equal("~\\goo.huh: (1,2)-(3,5)", new FileLinePositionSpan("~\\goo.huh", new LinePosition(1, 2), new LinePosition(3, 5)).ToString());

FileSystem\PathUtilitiesTests.cs (6)

364Assert.Equal(Path.Combine(path1, path2), PathUtilities.CombinePaths(path1, path2)); 381Assert.Equal(Path.Combine(path1, path2), PathUtilities.CombinePaths(path1, path2)); 393Assert.Equal(Path.Combine(path1, path2), PathUtilities.CombinePaths(path1, path2)); 405Assert.Equal(expected, PathUtilities.CombinePaths(path1, path2)); 413Assert.Equal(expected, result); 421Assert.Equal(expected, result);

FileSystem\RelativePathResolverTests.cs (16)

43Assert.Equal(subFilePath, path); 47Assert.Equal(filePath, path); 59Assert.Equal(subFilePath, path); 62Assert.Equal(subFilePath, path); 65Assert.Equal(dotted, path); 71Assert.Equal(filePath, path); 74Assert.Equal(filePath, path); 83Assert.Equal(filePath, path); 92Assert.Equal(filePath, path); 117Assert.Equal(filePath, path); 121Assert.Equal(subFilePath, path); 130Assert.Equal(filePath, path); 143Assert.Equal(filePath, path); 153Assert.Equal(filePath, path); 157Assert.Equal(filePath, path); 175Assert.Equal(f1, path);

FileUtilitiesTests.cs (49)

InternalUtilities\StringExtensionsTests.cs (4)

16Assert.Equal("0", StringExtensions.GetNumeral(0)); 17Assert.Equal("5", StringExtensions.GetNumeral(5)); 18Assert.Equal("10", StringExtensions.GetNumeral(10)); 19Assert.Equal("10000000", StringExtensions.GetNumeral(10000000));

MetadataReferences\AssemblyIdentityDisplayNameTests.cs (13)

MetadataReferences\AssemblyIdentityTests.cs (25)

MetadataReferences\AssemblyMetadataTests.cs (4)

51Assert.Equal("MultiModule.dll", a.GetModules()[0].Name); 66Assert.Equal("MultiModule.dll", a.GetModules()[0].Name); 67Assert.Equal("mod2.netmodule", a.GetModules()[1].Name); 68Assert.Equal("mod3.netmodule", a.GetModules()[2].Name);

MetadataReferences\FusionAssemblyIdentityTests.cs (11)

60Assert.Equal(name.Name, rtName.Name); 68Assert.Equal(fullName, displayName); 73Assert.Equal(name.Name, rtName.Name); 96Assert.Equal("goo, Version=65535.65535.65535.65535, Culture=neutral, PublicKeyToken=null", display); 161Assert.Equal("mscorlib", name.Name); 170Assert.Equal("mscorlib", name.Name); 179Assert.Equal("mscorlib", name.Name); 188Assert.Equal("mscorlib", name.Name); 191Assert.Equal("en-US", name.CultureInfo.Name); 198Assert.Equal("Windows", name.Name); 223Assert.Equal(c.ToString(), name.Name);

MetadataReferences\MetadataHelpersTests.cs (8)

238Assert.Equal(expectedTopLevelType, decodedName.TopLevelType); 239Assert.Equal(expectedAssemblyName, decodedName.AssemblyName); 455Assert.Equal("", array[0].Key); 457Assert.Equal("-", array[1].Key); 459Assert.Equal("a", array[2].Key); 492Assert.Equal("", nestedNS.Key); 503Assert.Equal("a", nestedNamespaces.ElementAt(0).Key); 504Assert.Equal("b", nestedNamespaces.ElementAt(1).Key);

MetadataReferences\MetadataReferenceTests.cs (37)

38Assert.Equal("", inMemoryAssembly.Location); 104Assert.Equal(CodeAnalysisResources.InMemoryAssembly, r.Display); 112Assert.Equal("CommonLanguageRuntimeLibrary", metadata.GetModules()[0].Name); 119Assert.Equal(CodeAnalysisResources.InMemoryAssembly, r.Display); 135Assert.Equal(CodeAnalysisResources.InMemoryAssembly, r.Display); 151Assert.Equal(CodeAnalysisResources.InMemoryModule, r.Display); 166Assert.Equal(file.Path, r.FilePath); 167Assert.Equal(file.Path, r.Display); 178Assert.Equal(module ? "ModuleCS00.netmodule" : "CommonLanguageRuntimeLibrary", metadata.GetModules()[0].Name); 189Assert.Equal(file.Path, r.FilePath); 190Assert.Equal(file.Path, r.Display); 201Assert.Equal(module ? "ModuleCS00.netmodule" : "CommonLanguageRuntimeLibrary", metadata.Name); 209Assert.Equal(assembly.Location, r.FilePath); 210Assert.Equal(assembly.Location, r.Display); 226Assert.Equal(assembly.Location, r.FilePath); 227Assert.Equal(assembly.Location, r.Display); 264Assert.Equal(@"c:\temp", r.FilePath); 268Assert.Equal(@"c:\temp", r1.FilePath); 272Assert.Equal(@"c:\temp", r2.FilePath); 303Assert.Equal(@"c:\temp", r.FilePath); 307Assert.Equal(@"c:\temp", r2.FilePath); 315Assert.Equal(r.FilePath, r3.FilePath); 323Assert.Equal(r.FilePath, r4.FilePath); 410Assert.Equal(path, r.FilePath); 425Assert.Equal(path, r.FilePath); 434Assert.Equal(CodeAnalysisResources.InMemoryAssembly, r.Display); 437Assert.Equal(CodeAnalysisResources.InMemoryModule, r.Display); 440Assert.Equal(@"c:\blah", r.Display); 443Assert.Equal(@"dddd", r.Display); 446Assert.Equal(@"dddd", r.Display); 449Assert.Equal(@"compilation name", r.Display); 452Assert.Equal(@"compilation name", r.Display); 533Assert.Equal("m1a", m1a.Display); 535Assert.Equal("m1b", m1b.Display); 537Assert.Equal("m2", m2.Display); 578Assert.Equal("<member name='T:System.Collections.ArrayList'><summary>T:System.Collections.ArrayList</summary></member>", summary); 585Assert.Equal(CodeAnalysisResources.InMemoryAssembly, r.Display);

SourceFileResolverTest.cs (2)

41Assert.Equal(new ArgumentException(CodeAnalysisResources.NullValueInPathMap, "pathMap").Message, argException.Message); 64Assert.Equal(new ArgumentException(CodeAnalysisResources.AbsolutePathExpected, "baseDirectory").Message, argException.Message);

StringTableTests.cs (1)

140Assert.Equal("abcd", s1);

Symbols\DocumentationCommentIdTests.cs (4)

43Assert.Equal(expectedDocId, actualDocId); 70Assert.Equal(expectedDocId, actualDocId); 93Assert.Equal(expectedDocId, actualDocId); 117Assert.Equal(expectedDocId, actualDocId);

Text\LargeTextTests.cs (8)

47Assert.Equal(HelloWorld, text.ToString()); 130Assert.Equal(HelloWorld, new string(buffer)); 167Assert.Equal(lineText, textLine.ToString()); 168Assert.Equal(text.ToString().Substring(start, length), textLine.ToString()); 316Assert.Equal("goo", data.Lines[0].ToString()); 317Assert.Equal("bar baz", data.Lines[1].ToString()); 325Assert.Equal("goo", data.Lines[0].ToString()); 337Assert.Equal("goo", actualSourceText.Lines[0].ToString());

Text\SourceTextTests.cs (4)

430Assert.Equal("BCDEFGHIJKLMNOPQRSTUVWXYZ", writer.ToString()); 449Assert.Equal(Text.Substring(span.Start, span.Length), writer.ToString()); 458Assert.Equal("span", ex.ParamName); 467Assert.Equal("span", ex.ParamName);

Text\StringText_LineTest.cs (3)

54Assert.Equal("goo", line.ToString()); 85Assert.Equal("", line.ToString()); 99Assert.Equal("", line.ToString());

Text\StringTextDecodingTests.cs (15)

62Assert.Equal(sjis.GetString(TestResources.General.ShiftJisSource), data.ToString()); 72Assert.Equal(sjis.GetString(TestResources.General.ShiftJisSource), data.ToString()); 82Assert.Equal("2fd4e1c6 7a2d28fc ed849ee1 bb76e739 1b93eb12", StringTextTest.ChecksumToHexQuads(checksum)); 91Assert.Equal("9d0047c0 8c84a7ef a55a955e aa3b4aae f62c9c39", StringTextTest.ChecksumToHexQuads(checksum)); 100Assert.Equal("72b2beae c76188ac 5b38c16c 4f9d518a 2be0a34c", StringTextTest.ChecksumToHexQuads(checksum)); 110Assert.Equal("da39a3ee 5e6b4b0d 3255bfef 95601890 afd80709", StringTextTest.ChecksumToHexQuads(checksum)); 119Assert.Equal("d62636d8 caec13f0 4e28442a 0a6fa1af eb024bbb", StringTextTest.ChecksumToHexQuads(checksum)); 128Assert.Equal("26237800 2c95ae7e 29535cb9 f438db21 9adf98f5", StringTextTest.ChecksumToHexQuads(checksum)); 137Assert.Equal("f1945cd6 c19e56b3 c1c78943 ef5ec181 16907a4c a1efc40a 57d48ab1 db7adfc5", StringTextTest.ChecksumToHexQuads(checksum)); 171Assert.Equal(text, sourceText.ToString()); 179Assert.Equal(text, sourceText.Encoding.GetString(bytes)); 196Assert.Equal(text, sourceText.ToString()); 197Assert.Equal(Encoding.UTF8.EncodingName, sourceText.Encoding.EncodingName); 226Assert.Equal(expectedText, sourceText.ToString()); 312Assert.Equal(expectedText, encodedText.ToString());

Text\StringTextTest.cs (10)

120Assert.Equal(lineText, textLine.ToString()); 121Assert.Equal(text.ToString().Substring(start, length), textLine.ToString()); 209Assert.Equal("goo", data.Lines[0].ToString()); 210Assert.Equal("bar baz", data.Lines[1].ToString()); 218Assert.Equal("goo", data.Lines[0].ToString()); 226Assert.Equal("88d3ed78 9b0bae8b ced8e348 91133516 b79ba9fb", ChecksumToHexQuads(checksum)); 235Assert.Equal("abc", source.ToString()); 250Assert.Equal("ab?", source.ToString()); 262Assert.Equal("\u1234", source.ToString()); 277Assert.Equal("abc", source.ToString());

Text\StringTextTests_Default.cs (9)

73Assert.Equal("goo", data.ToString(data.Lines[0].Span)); 74Assert.Equal("bar", data.ToString(data.Lines[1].Span)); 75Assert.Equal("baz", data.ToString(data.Lines[2].Span)); 83Assert.Equal("goo", data.ToString(data.Lines[0].Span)); 84Assert.Equal("bar", data.ToString(data.Lines[1].Span)); 101Assert.Equal("goo", data.Lines[0].ToString()); 102Assert.Equal("bar baz", data.Lines[1].ToString()); 109Assert.Equal("goo", data.Lines[0].ToString()); 148Assert.Equal(originalText, encodedText.ToString());

Text\TextChangeTests.cs (113)

Text\TextSpanTest.cs (3)

93Assert.Equal("[0..0)", span.ToString()); 104Assert.Equal("[0..1)", span.ToString()); 116Assert.Equal("[15..1500)", span.ToString());

Win32Res.cs (1)

152Assert.Equal(xmlExpectedVersion, rsrcInXml);

XmlDocumentationCommentTextReaderTests.cs (1)

36Assert.Equal(" ", new string(buffer, 0, charsRead));

CommandLineArgumentsTests.vb (4)

231Assert.Equal(True, dict("Blah")) 232Assert.Equal(True, dict("blah")) 265Assert.Equal(True, dict("Blah")) 266Assert.Equal(True, dict("blah"))

CommandLineBreakingChanges.vb (5)

29Assert.Equal("", output.Trim()) 60Assert.Equal("", output.Trim()) 92Assert.Equal("", output.Trim()) 124Assert.Equal("", output.Trim()) 159Assert.Equal("", output.Trim())

CommandLineTests.vb (284)

SarifErrorLoggerTests.vb (5)

61Assert.Equal("", outWriter.ToString().Trim()) 67Assert.Equal(expectedOutput, actualOutput) 106Assert.Equal(expectedOutput, actualOutput) 148Assert.Equal(expectedOutput, actualOutput) 190Assert.Equal(expectedOutput, actualOutput)

TouchedFileLoggingTests.vb (4)

52Assert.Equal("", outWriter.ToString().Trim()) 86Assert.Equal(String.Empty, outWriter.ToString().Trim()) 128Assert.Equal(String.Empty, writer.ToString().Trim()) 149Assert.Equal(expectedDoc, xml.ReadAllText().Trim())

Attributes\AttributeTests_MarshalAs.vb (2)

56Assert.Equal(CType(blob(0), UnmanagedType), parameter.MarshallingType) 58Assert.Equal(CType(0, UnmanagedType), parameter.MarshallingType)

CodeGen\CodeGenTuples.vb (11)

10121Sub(t) Assert.Equal(SpecialType.System_Int32, t.SpecialType)) 15838Assert.Equal("Rest", m.Name) 18563Assert.Equal(0, comparison12) 18664Assert.Equal(0, comparison12) 20493Assert.Equal(1, c.TypeParameters.Length) 20495Assert.Equal(1, param.ConstraintTypes.Length) 20503Sub(t) Assert.Equal(SpecialType.System_Int32, t.SpecialType)) 20508Assert.Equal(1, c2.TypeParameters.Length) 20510Assert.Equal(1, param.ConstraintTypes.Length) 20518Sub(t) Assert.Equal(SpecialType.System_Int32, t.SpecialType)) 21681Assert.Equal("corlib", found.ContainingAssembly.Name)

Emit\NoPiaEmbedTypes.vb (169)

InteractiveSessionTests.vb (6)

24Assert.Equal(3, s.ReturnValue) 32Assert.Equal(1, VisualBasicScript.EvaluateAsync(source).Result) 40Assert.Equal(1, VisualBasicScript.EvaluateAsync(source).Result) 65Assert.Equal(6, VisualBasicScript.EvaluateAsync(source).Result) 85Assert.Equal("True False True", script.EvaluateAsync().Result) 111Assert.Equal("True False True", script.EvaluateAsync().Result)

ObjectFormatterTests.vb (12)

42Assert.Equal("Outer.Nested(Of Integer) { A=1, B=2 }", str) 45Assert.Equal("Outer.Nested(Of Integer)", str) 48Assert.Equal("A(Of Integer).B(Of Integer)", str) 52Assert.Equal("A(Of Integer).B(Of Boolean).C.D(Of String, Double).E", str) 56Assert.Equal("Sort { aB=-1, ab=1, Ac=-1, Ad=1, ad=-1, aE=1, aF=-1...", str) 60Assert.Equal("Sort ...", str) 64Assert.Equal("Sort...", str) 67Assert.Equal("Sor...", str) 70Assert.Equal("So...", str) 73Assert.Equal("S...", str) 76Assert.Equal("Sort { aB=-1, ab=1, Ac=-1, Ad=1, ad=-1, aE=1, aF=-1, AG=1 }", str) 82Assert.Equal("ObjectFormatterFixtures.Signatures.ArrayParameters(Integer(), Integer(,), Integer(,,))", result)

PrintOptionsTests.vb (18)

ScriptTests.vb (5)

30Assert.Equal("? 1 + 2", script.Code) 36Assert.Equal(3, value.Result) 42Assert.Equal(3, state.ReturnValue) 50Assert.Equal(3, state.ReturnValue) 56Assert.Equal(3, state.ReturnValue)

Compilation\SuppressAccessibilityChecksTests.vb (4)

90Assert.Equal("A", creationExpression.Type.Name) 123Assert.Equal("_p", symbolInfo.Symbol.Name) 269Assert.Equal("_p", symbolSpeculation.Symbol.Name) 270Assert.Equal("Int32", typeSpeculation.Type.Name)

FlowAnalysis\IterationJumpYieldStatementTests.vb (167)

FlowAnalysis\TryLockUsingStatementTests.vb (335)

Semantics\QueryExpressions_FlowAnalysis.vb (656)

SymbolDisplay\ObjectDisplayTests.vb (97)

SymbolsTests\Metadata\PE\NoPiaInstantiationOfGenericClassAndStruct.vb (5)

120Assert.Equal(SymbolKind.ErrorType, m.Parameters.[Where](Function(arg) arg.Name = "c1").[Select](Function(arg) arg).[Single]().[Type].BaseType.Kind) 124Assert.Equal(SymbolKind.ErrorType, m.ReturnType.BaseType.Kind) 370Assert.Equal(SymbolKind.Parameter, m.Parameters.[Where](Function(arg) arg.Name = "c1").[Select](Function(arg) arg).[Single]().Kind) 375Assert.Equal(SymbolKind.NamedType, m.ReturnType.Kind) 483Assert.Equal(SymbolKind.ErrorType, m.ReturnType.Kind)

SymbolsTests\Retargeting\RetargetCustomModifiers.vb (1)

60Assert.Equal("System.Runtime.CompilerServices.IsConst", p2Mod.Modifier.ToTestDisplayString())

Parser\DeclarationTests.vb (3)

58Assert.Equal("", decl1.Name) 59Assert.Equal("", decl2.Name) 198Assert.Equal("", decl1.Name)

Syntax\ManualTests.vb (8)

39Assert.Equal(expectedText, actualText) 109Assert.Equal(" ", node.GetLeadingTrivia().First().ToString()) 119Assert.Equal(" ", node.GetLeadingTrivia().First().ToString()) 164Assert.Equal("", null1.ToString()) 176Assert.Equal("", empty1.ToString()) 188Assert.Equal("a", singleton1.ToString()) 200Assert.Equal("a,b,c", list1.ToString()) 228Assert.Equal(">", token.ToString())

Syntax\SeparatedSyntaxListTests.vb (32)

Syntax\SyntaxNormalizerTests.vb (5)

28Assert.Equal(expected, actual) 80Assert.Equal(expected, actual) 751Assert.Equal(expected, actual) 759Assert.Equal(expected, actual) 796Assert.Equal(expected, actual)

Syntax\SyntaxTokenFactoryTests.vb (23)

CompilationTestUtils.vb (3)

1182Assert.Equal(ExpectedDispName(count), item.ToDisplayString()) 1214Assert.Equal(symbolDescriptions(i), descriptions(i)) 1223Assert.Equal(symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat), description)

ParserTestUtilities.vb (3)

116Assert.Equal(source, root.ToFullString) 240Assert.Equal(x1.ToString, x2.ToString) 768Assert.Equal(tk.ToString().Trim(), tk.ToString())

SemanticModelTestBase.vb (1)

42Assert.Equal(bindText, node.ToString())

CodeGeneration\AddImportsTests.vb (1)

103Assert.Equal(importsAddedText, actualText)

CodeGeneration\SyntaxGeneratorTests.vb (102)

EmbeddedLanguages\VirtualChars\VisualBasicVirtualCharServiceTests.vb (1)

38Assert.Equal(expected, actual)

Formatting\FormattingTests.vb (2)

3789Assert.Equal(expected, result) 4212Assert.Equal(actual, actual)

VisualBasicCommandLineArgumentsFactoryServiceTests.vb (6)

27Assert.Equal("true", options.Features("test")) 33Assert.Equal("dog", options.Features("test")) 39Assert.Equal("true", options.Features("test1")) 40Assert.Equal("true", options.Features("test2")) 46Assert.Equal("dog", options.Features("test1")) 47Assert.Equal("cat", options.Features("test2"))

MSBuildWorkspaceTestBase.cs (1)

121Assert.Equal("EmittedCSharpProject.dll", Path.GetFileName(p1.OutputFilePath));

NetCoreTests.cs (6)

124Assert.Equal(libraryProject.FilePath, workspace.CurrentSolution.GetProject(projectRefId).FilePath); 170Assert.Equal(projectRefFilePath, project.Solution.GetProject(projectRefId).FilePath); 240Assert.Equal("Project.NetCore", project.DefaultNamespace); 244Assert.Equal("Project.NetStandard", project.DefaultNamespace); 248Assert.Equal("Project.NetFramework", project.DefaultNamespace); 480Assert.Equal(projectRefFilePath, project.Solution.GetProject(projectRefId).FilePath);

RpcTests.cs (1)

102Assert.Equal("Hello, World!", rpcTarget.Message);

VisualStudioMSBuildWorkspaceTests.cs (41)

Formatting\FormattingTestBase.cs (1)

75Assert.Equal(expected, newRootNode.ToFullString());

CodeStyle\NamingStylePreferencesUpgradeTests.cs (1)

26=> Assert.Equal(expected.Trim(), actual.Trim());

CommandLineProject\CommandLineProjectTests.cs (16)

CommandLineProject\CommandLineProjectWorkspaceTests.cs (9)

32Assert.Equal("TestProject", project.Name); 33Assert.Equal("goo", project.AssemblyName); 40Assert.Equal(tempFile.Path, gooDoc.FilePath); 43Assert.Equal(tempFile.ReadAllText(), text); 60Assert.Equal("TestProject", project.Name); 61Assert.Equal("goo", project.AssemblyName); 68Assert.Equal(@"C:\ProjectDirectory\goo.cs", gooDoc.FilePath); 72Assert.Equal("subdir", barDoc.Folders[0]); 73Assert.Equal(@"C:\ProjectDirectory\subdir\bar.cs", barDoc.FilePath);

Differencing\LongestCommonSubsequenceTests.cs (2)

42Assert.Equal(expectedPairsStr, actualPairsStr); 75Assert.Equal(editedStr, newStr);

Editing\SyntaxEditorTests.cs (1)

32Assert.Equal(expectedText, actualText);

ExtensionOrdererTests.cs (1)

217Assert.Equal(expected, actualOrder);

Formatter\FormatterTests.cs (2)

141Assert.Equal("\r", formattingOptions.NewLine); 209Assert.Equal("\r", options.NewLine);

FormattingTests.cs (1)

89Assert.Equal(expected, actualFormattedText);

ObjectSerializationTests.cs (14)

451Assert.Equal("YYY", reader.ReadString()); 452Assert.Equal("\uD800\uDC00", reader.ReadString()); // valid surrogate pair 453Assert.Equal("\uDC00\uD800", reader.ReadString()); // invalid surrogate pair 454Assert.Equal("\uD800", reader.ReadString()); // incomplete surrogate pair 519Assert.Equal("YYY", (String)reader.ReadScalarValue()); 520Assert.Equal("\uD800\uDC00", (String)reader.ReadScalarValue()); // valid surrogate pair 521Assert.Equal("\uDC00\uD800", (String)reader.ReadScalarValue()); // invalid surrogate pair 522Assert.Equal("\uD800", (String)reader.ReadScalarValue()); // incomplete surrogate pair 714Assert.Equal(GooString, string1); 715Assert.Equal(BarString, string2); 716Assert.Equal(largeString, string3); 728Assert.Equal(largeString, string4); 729Assert.Equal(BarString, string5); 730Assert.Equal(GooString, string6);

Options\OptionKeyTests.cs (10)

81Assert.Equal("config", ((IOption)option1).Feature); 82Assert.Equal("name", ((IOption)option1).Name); 84Assert.Equal("name", option1.ToString()); 87Assert.Equal("config", ((IOption)option2).Feature); 88Assert.Equal("name", ((IOption)option2).Name); 90Assert.Equal("name", option2.ToString()); 102Assert.Equal("FooFeature - BarName", toStringResult); 113Assert.Equal("FooFeature - BarName", toStringResult); 124Assert.Equal("(BazLanguage) FooFeature - BarName", toStringResult); 133Assert.Equal("", toStringResult);

Remote\ServiceDescriptorTests.cs (1)

358Assert.Equal(expectedName, descriptorCoreClr64ServerGC.GetFeatureDisplayName());

SolutionTests\DocumentInfoTests.cs (4)

44Assert.Equal("doc", info.Name); 63Assert.Equal("doc", info.Name); 75Assert.Equal("folder", ((ImmutableArray<string>)info1.Folders).Single()); 97Assert.Equal(path, info.FilePath);

SolutionTests\ProjectDependencyGraphTests.cs (1)

96Assert.Equal(expectedResult, actualResult);

SolutionTests\ProjectInfoTests.cs (2)

168Assert.Equal(@"ProjectInfo Goo C:\", projectInfo.GetDebuggerDisplay()); 175Assert.Equal(@"ProjectInfo Goo", projectInfo.GetDebuggerDisplay());

SolutionTests\SolutionInfoTests.cs (1)

54Assert.Equal(path, info.FilePath);

SolutionTests\SolutionTests.cs (56)

179Assert.Equal(name, newSolution1.GetDocument(documentId)!.Name); 311Assert.Equal(root.ToString(), actualRoot!.ToString()); 444Assert.Equal(text1.ToString(), text2.ToString()); 488Assert.Equal(text1.ToString(), text2.ToString()); 532Assert.Equal(text1.ToString(), text2.ToString()); 576Assert.Equal(text1.ToString(), text2.ToString()); 611Assert.Equal(text1.ToString(), text2.ToString()); 662Assert.Equal(text1.ToString(), text2.ToString()); 697Assert.Equal(text1.ToString(), text2.ToString()); 742Assert.Equal(text1.ToString(), text2.ToString()); 774Assert.Equal(text1.ToString(), text2.ToString()); 818Assert.Equal(text1.ToString(), text2.ToString()); 927Assert.Equal("new text", newSolution1.GetDocument(documentId)!.GetTextSynchronously(CancellationToken.None).ToString()); 949Assert.Equal("new text", newSolution1.GetAdditionalDocument(documentId)!.GetTextSynchronously(CancellationToken.None).ToString()); 971Assert.Equal("new text", newSolution1.GetAnalyzerConfigDocument(documentId)!.GetTextSynchronously(CancellationToken.None).ToString()); 1144Assert.Equal("class NewD1;", newText1.ToString()); 1153Assert.Equal("class NewD3;", newDocument3.GetTextSynchronously(CancellationToken.None).ToString()); 1165Assert.Equal("new text1", newAddText1.ToString()); 1174Assert.Equal("new text3", newAddDocument3.GetTextSynchronously(CancellationToken.None).ToString()); 1186Assert.Equal("#new empty1", newConfigText1.ToString()); 1195Assert.Equal("#new empty3", newConfigDocument3.GetTextSynchronously(CancellationToken.None).ToString()); 1353Assert.Equal(assemblyName, newSolution.GetProject(projectId)!.AssemblyName); 2256Assert.Equal("text", sourceText.ToString()); 2346Assert.Equal("class C {}", sourceText.ToString()); 2375Assert.Equal("class C {}", sourceText.ToString()); 2404Assert.Equal("bar", project.AssemblyName); 3004Assert.Equal(text, root.ToString()); 3027Assert.Equal("class Class { }", newText); 3128Assert.Equal(OldFilePath, oldDocument.FilePath); 3129Assert.Equal(OldFilePath, oldDocument.GetSyntaxTreeAsync().Result.FilePath); 3136Assert.Equal(NewFilePath, newDocument.FilePath); 3137Assert.Equal(NewFilePath, newDocument.GetSyntaxTreeAsync().Result.FilePath); 3165Assert.Equal(text2, textOnDisk); 3172Assert.Equal(text1, observedText2.ToString()); 3192Assert.Equal(text, docText.ToString()); 3214Assert.Equal(text, docText.ToString()); 3239Assert.Equal(text, docText.ToString()); 3259Assert.Equal(text, docTree.GetRoot().ToString()); 3280Assert.Equal(text, docTree.GetRoot().ToString()); 3322Assert.Equal(text, docRoot.ToString()); 3388Assert.Equal(expectedText, observedText.ToString()); 3419Assert.Equal(expectedText, observedText.ToString()); 3639Assert.Equal("new path", tree2.FilePath); 3667Assert.Equal("old path", tree3.FilePath); 3678Assert.Equal("old path", tree4.FilePath); 3777Assert.Equal(@"C:\doesnotexist.cs: (0,0)-(0,0)", diagnostic.Location.GetLineSpan().ToString()); 3778Assert.Equal("", text.ToString()); 3783Assert.Equal("", syntaxTree.ToString()); 3939Assert.Equal("DocumentToFreeze.cs", tree.FilePath); 3964Assert.Equal("DocumentToFreeze.cs", tree.FilePath); 4379Assert.Equal(expected, ex.Message); 4393Assert.Equal(expected, ex.Message); 4705Assert.Equal("CS8602", diagnostic.Id); 5601Assert.Equal("// source1", generatedDocuments.Single().GetTextSynchronously(CancellationToken.None).ToString()); 5623Assert.Equal("// source1", forkedGeneratedDocuments.Single().GetTextSynchronously(CancellationToken.None).ToString()); 5627Assert.Equal("// source2", forkedGeneratedDocuments.Single().GetTextSynchronously(CancellationToken.None).ToString());

SolutionTests\SolutionWithSourceGeneratorTests.cs (5)

265Assert.Equal(expectedGeneratedContents, generatedSyntaxTree.GetText().ToString()); 838Assert.Equal("// Frozen Document", (await frozenWithSingleDocument.GetTextAsync()).ToString()); 841Assert.Equal("// Frozen Document", frozenTree.ToString()); 866Assert.Equal("// Frozen 1", (await (await solutionWithFrozenDocuments.GetRequiredProject(projectId1).GetSourceGeneratedDocumentsAsync()).Single().GetTextAsync()).ToString()); 867Assert.Equal("// Frozen 2", (await (await solutionWithFrozenDocuments.GetRequiredProject(projectId2).GetSourceGeneratedDocumentsAsync()).Single().GetTextAsync()).ToString());

SolutionTests\TryApplyChangesTests.cs (2)

108Assert.Equal(WorkspacesResources.Changing_compilation_options_is_not_supported, exception.Message); 156Assert.Equal(WorkspacesResources.Changing_parse_options_is_not_supported, exception.Message);

SymbolKeyTests.cs (6)

422Assert.Equal("x", resolved?.Name); 446Assert.Equal("b", resolved?.Name); 1179Assert.Equal("Collections", propType.ContainingNamespace.Name); 1180Assert.Equal("System", propType.ContainingNamespace.ContainingNamespace.Name); 1226Assert.Equal("Collections", propType.ContainingNamespace.Name); 1227Assert.Equal("System", propType.ContainingNamespace.ContainingNamespace.Name);

SyntaxNodeTests.cs (3)

41Assert.Equal(expected, actual); 75Assert.Equal(expected, actual); 124Assert.Equal("public class C\r\n{\r\n private int X;\r\n void M()\r\n {\r\n }\r\n}", finalClassDecl.NormalizeWhitespace().ToString());

SyntaxPathTests.cs (15)

UtilityTest\DocumentationCommentIdTests.cs (3)

26Assert.Equal(expectedId, id); 48Assert.Equal(expectedId, id); 54Assert.Equal(expectedId, id);

UtilityTest\DocumentationCommentTests.cs (67)

UtilityTest\SourceTextSerializationTests.cs (1)

46Assert.Equal(originalText.ToString(), recovered.ToString());

UtilityTest\XmlDocumentationProviderTests.cs (2)

44Assert.Equal("member", xmlDocument.Root!.Name.LocalName); 45Assert.Equal("T:Microsoft.CodeAnalysis.AdditionalTextFile", xmlDocument.Root!.Attribute("name")!.Value);

WorkspaceServiceTests\GlobalOptionServiceTests.cs (12)

WorkspaceServiceTests\TemporaryStorageServiceTests.cs (1)

83Assert.Equal(text.ToString(), text2.ToString());

WorkspaceTests\AdhocWorkspaceTests.cs (33)

38Assert.Equal(info.Name, project.Name); 40Assert.Equal(info.AssemblyName, project.AssemblyName); 41Assert.Equal(info.Language, project.Language); 50Assert.Equal("TestProject", project.Name); 51Assert.Equal(LanguageNames.CSharp, project.Language); 63Assert.Equal(info.Name, doc.Name); 75Assert.Equal(name, doc.Name); 76Assert.Equal(source, (await doc.GetTextAsync()).ToString()); 100Assert.Equal(pinfo.Name, project.Name); 102Assert.Equal(pinfo.AssemblyName, project.AssemblyName); 103Assert.Equal(pinfo.Language, project.Language); 132Assert.Equal(info1.Name, project1.Name); 134Assert.Equal(info1.AssemblyName, project1.AssemblyName); 135Assert.Equal(info1.Language, project1.Language); 138Assert.Equal(info2.Name, project2.Name); 140Assert.Equal(info2.AssemblyName, project2.AssemblyName); 141Assert.Equal(info2.Language, project2.Language); 175Assert.Equal("NewProject", proj.Name); 176Assert.Equal("NewProject.dll", proj.AssemblyName); 177Assert.Equal(LanguageNames.CSharp, proj.Language); 181Assert.Equal("MyDoc.cs", doc.Name); 416Assert.Equal("TestDocument", originalDoc.Name); 420Assert.Equal(newName, changedDoc.Name); 435Assert.Equal(newName, appliedDoc.Name); 469Assert.Equal("A", appliedDoc.Folders[0]); 470Assert.Equal("B", appliedDoc.Folders[1]); 487Assert.Equal(newPath, changedDoc.FilePath); 502Assert.Equal(newPath, appliedDoc.FilePath); 546Assert.Equal("TestDocument", originalDoc.Name); 563Assert.Equal(newName, appliedDoc.Name); 565Assert.Equal("A", appliedDoc.Folders[0]); 566Assert.Equal("B", appliedDoc.Folders[1]); 567Assert.Equal(newPath, appliedDoc.FilePath);

WorkspaceTests\WorkspaceTests.cs (9)

29Assert.Equal(WorkspacesResources.Changing_documents_is_not_supported, 39Assert.Equal("TestDocument", originalDoc.Name); 43Assert.Equal(newName, changedDoc.Name); 45Assert.Equal(WorkspacesResources.Changing_document_property_is_not_supported, 63Assert.Equal(WorkspacesResources.Changing_document_property_is_not_supported, 78Assert.Equal(newPath, changedDoc.FilePath); 80Assert.Equal(WorkspacesResources.Changing_document_property_is_not_supported, 96Assert.Equal(WorkspacesResources.Changing_document_property_is_not_supported, 108Assert.Equal(WorkspacesResources.Adding_analyzer_references_is_not_supported,

ExampleTests.cs (1)

23Assert.Equal("Method textDocument/didOpen was implemented more than once.", ex.Message);

RequestExecutionQueueTests.cs (2)

105Assert.Equal("stuff", response?.Response); 115Assert.Equal("true", response?.Response);

ArrowStringColumnTests.cs (9)

28Assert.Equal("foo", stringColumn[0]); 29Assert.Equal("bar", stringColumn[1]); 43Assert.Equal("joe", stringColumn[0]); 45Assert.Equal("mark", stringColumn[2]); 46Assert.Equal("", stringColumn[3]); 49Assert.Equal("joe", ret[0]); 51Assert.Equal("mark", ret[2]); 52Assert.Equal("", ret[3]); 89Assert.Equal(column[i] + "123", ret[i]);

DataFrame.IOTests.cs (42)

225Assert.Equal("payment_type", df.Columns[5].Name); 226Assert.Equal("payment_type.1", df.Columns[6].Name); 227Assert.Equal("payment_type.2", df.Columns[7].Name); 332Assert.Equal("vendor_id", df.Columns[0].Name); 333Assert.Equal("rate_code", df.Columns[1].Name); 334Assert.Equal("passenger_count", df.Columns[2].Name); 335Assert.Equal("trip_time_in_secs", df.Columns[3].Name); 336Assert.Equal("trip_distance", df.Columns[4].Name); 337Assert.Equal("payment_type", df.Columns[5].Name); 338Assert.Equal("fare_amount", df.Columns[6].Name); 440Assert.Equal("vendor_id", df.Columns[0].Name); 441Assert.Equal("rate_code", df.Columns[1].Name); 442Assert.Equal("passenger_count", df.Columns[2].Name); 443Assert.Equal("trip_time_in_secs", df.Columns[3].Name); 444Assert.Equal("trip_distance", df.Columns[4].Name); 445Assert.Equal("payment_type", df.Columns[5].Name); 446Assert.Equal("fare_amount", df.Columns[6].Name); 503Assert.Equal("vendor_id", df.Columns[0].Name); 504Assert.Equal("rate_code", df.Columns[1].Name); 505Assert.Equal("passenger_count", df.Columns[2].Name); 506Assert.Equal("trip_time_in_secs", df.Columns[3].Name); 507Assert.Equal("trip_distance", df.Columns[4].Name); 508Assert.Equal("payment_type", df.Columns[5].Name); 509Assert.Equal("fare_amount", df.Columns[6].Name); 510Assert.Equal("date", df.Columns[7].Name); 710Assert.Equal("IndexColumn", dataFrame.Columns[0].Name); 780Assert.Equal("vendor_id", df.Columns[0].Name); 781Assert.Equal("rate_code", df.Columns[1].Name); 782Assert.Equal("passenger_count", df.Columns[2].Name); 783Assert.Equal("trip_time_in_secs", df.Columns[3].Name); 823Assert.Equal("vendor_id", df.Columns[0].Name); 824Assert.Equal("rate_code", df.Columns[1].Name); 825Assert.Equal("passenger_count", df.Columns[2].Name); 826Assert.Equal("trip_time_in_secs", df.Columns[3].Name); 885Assert.Equal("vendor_id", df.Columns[0].Name); 886Assert.Equal("rate_code", df.Columns[1].Name); 887Assert.Equal("passenger_count", df.Columns[2].Name); 888Assert.Equal("trip_time_in_secs", df.Columns[3].Name); 1128Assert.Equal("vendor_id", df.Columns[0].Name); 1129Assert.Equal("empty", df.Columns[1].Name); 1146Assert.Equal("", emptyColumn[i]); 1289Assert.Equal(_columnNames[j], df.Columns[j].Name);

DataFrameGroupByTests.cs (1)

52Assert.Equal("even", grouping.First().Key);

DataFrameIDataViewTests.cs (53)

DataFrameTests.cs (39)

25Assert.Equal("Int1", dataFrame.Columns[0].Name); 54Assert.Equal("a1", dc.Name); 70Assert.Equal("IntColumn", dataFrame.Columns[0].Name); 72Assert.Equal("FloatColumn", dataFrame.Columns[1].Name); 192Assert.Equal("Town", renamedColumn.Name); 211Assert.Equal("Town", renamedColumn.Name); 332Assert.Equal(originalColumn[r].ToString(), headColumn[verify[r]].ToString()); 355Assert.Equal(originalColumn[originalColumnVerify[r]].ToString(), tailColumn[tailColumnVerity[r]].ToString()); 369Assert.Equal(((long)(r == 0 ? 8 : 9)).ToString(), maxColumn[r].ToString()); 392Assert.Equal(r == 0 ? "0" : "1", minColumn[r].ToString()); 395Assert.Equal("0", productColumn[r].ToString()); 398Assert.Equal("20", sumColumn[r].ToString()); 509Assert.Equal("01234<null>6789", actualStrings.ToString()); 524Assert.Equal("foofoofoofoofoo<null>foofoofoofoo", actualStrings.ToString()); 539Assert.Equal("01234<null>6789", actualStrings.ToString()); 554Assert.Equal("01234<null>6789", actualStrings.ToString()); 617Assert.Equal("3", column[i].ToString()); 619Assert.Equal(4.ToString(), column[4].ToString()); 621Assert.Equal(6.ToString(), column[6].ToString()); 624Assert.Equal("7", column[i].ToString()); 666Assert.Equal(First.Name, Second.Name); 670Assert.Equal(First.Name, "Prefix_" + Second.Name); 678Assert.Equal("Prefix_" + First.Name, Second.Name); 685Assert.Equal(First.Name, "Prefix_" + Second.Name); 689Assert.Equal("Prefix_" + First.Name + "_Suffix", Second.Name); 697Assert.Equal("Prefix_" + First.Name + "_Suffix", Second.Name); 728Assert.Equal("Description", descriptionColumn.Name); 736Assert.Equal(df.Columns[i - 1].Name, column.Name); 746Assert.Equal("DateTime", dateTimeColumn.Name); 769Assert.Equal("Info", infoColumn.Name); 776Assert.Equal(df.Columns[i - 1].DataType.ToString(), column[0].ToString()); 837Assert.Equal("foo", strColumn[0]); 838Assert.Equal("foo", strColumn[1]); 850Assert.Equal("foo", arrowColumnFilled[1]); 851Assert.Equal(arrowColumn[0], arrowColumnFilled[0]); 852Assert.Equal(arrowColumn[2], arrowColumnFilled[2]); 1008Assert.Equal("12", value.ToString()); 1045Assert.Equal(row[j]?.ToString(), (check2.Rows[i - check1.Rows.Count][j])?.ToString()); 1245Assert.Equal(i.ToString(), column[i].ToString());

DataFrameTests.Filter.cs (1)

42Assert.Equal(verify[j].ToString(), column[j].ToString());

DataFrameTests.Merge.cs (2)

31Assert.Equal("Left", (string)merge.Columns["String_left"][0]); 32Assert.Equal("Right", (string)merge.Columns["String_right"][0]);

DataFrameTests.Sort.cs (2)

58Assert.Equal("0", sortedStrColumn[0]); 63Assert.Equal("4", sortedStrColumn[0]);

PrimitiveDataFrameColumnTests.cs (10)

StringDataFrameColumnTests.cs (6)

23Assert.Equal(stringColumn.Name, clonedColumn.Name); 28Assert.Equal(stringColumn[i], clonedColumn[i]); 39Assert.Equal(stringColumn.Name, clonedColumn.Name); 55Assert.Equal(stringColumn.Name, clonedColumn.Name); 71Assert.Equal(stringColumn.Name, clonedColumn.Name); 88Assert.Equal(stringColumn.Name, clonedColumn.Name);

TextFieldParserTests.cs (16)

133Assert.Equal( 143Assert.Equal("abc", parser.ReadLine()); 147Assert.Equal("123", parser.ReadToEnd()); 154Assert.Equal("abc", parser.ReadLine()); 158Assert.Equal("123", parser.ReadLine()); 181Assert.Equal("", parser.ErrorLine); 185Assert.Equal("", parser.ErrorLine); 189Assert.Equal("def 45", parser.ErrorLine); 193Assert.Equal("def 45", parser.ErrorLine); 250Assert.Equal("a", parser.PeekChars(1)); 251Assert.Equal("abc,123", parser.PeekChars(10)); 253Assert.Equal("abc,123", parser.ReadLine()); 258Assert.Equal("d", parser.PeekChars(1)); 259Assert.Equal("def,456", parser.PeekChars(10)); 265Assert.Equal("g", parser.PeekChars(1)); 266Assert.Equal("ghi,789", parser.PeekChars(10));

CalculateAssemblyAndFileVersionsTests.cs (4)

25Assert.Equal(expectedAssemblyVersion, task.AssemblyVersion); 26Assert.Equal(expectedFileVersion, task.FileVersion); 44Assert.Equal(expectedVersion, task.AssemblyVersion); 45Assert.Equal(expectedVersion, task.FileVersion);

GenerateResxSourceTests.cs (1)

72Assert.Equal(expectedIdentifier, GenerateResxSource.GetIdentifierFromResourceName(name));

GetLicenseFilePathTests.cs (1)

30Assert.Equal(licensePath, task.Path);

PublishToSymbolServerTest.cs (1)

407Assert.Equal(containerId, test);

GenerateFileFromTemplateTests.cs (3)

27Assert.Equal(ReadAllText("Directory.Build.props.in").Replace("${DefaultNetCoreTargetFramework}", "net6.0"), File.ReadAllText(filePath)); 55Assert.Equal(ReadAllText("Directory.Build.props.in").Replace("${DefaultNetCoreTargetFramework}", string.Empty), File.ReadAllText(filePath)); 80Assert.Equal(ReadAllText(filename), File.ReadAllText(filePath));

OptProf\FindLatestDropTests.cs (1)

14Assert.Equal("OptimizationData/dotnet/roslyn/master-vs-deps/41416da1e8531ab0f4e5e7dc67318237323acf23/202326/813349/1",

OptProf\GenerateTrainingInputFilesTests.cs (4)

179Assert.Equal( 190Assert.Equal( 201Assert.Equal( 211Assert.Equal(

OptProf\GenerateTrainingPropsFileTests.cs (2)

28Assert.Equal(@"<?xml version=""1.0""?> 56Assert.Equal(@"<?xml version=""1.0""?>

OptProf\GetRunSettingsSessionConfigurationTests.cs (4)

400Assert.Equal(expectedUrl, GetRunSettingsSessionConfiguration.GetTestsDropName(jsonString)); 433Assert.Equal( 457Assert.Equal(expectedContainerString, actualContainerString); 458Assert.Equal(expectedTestCaseFilterString, actualTestCaseFilterString);

CreateVisualStudioWorkloadSetTests.cs (1)

69Assert.Equal(DefaultValues.PackageTypeMsiWorkloadSet, workloadSetSwixItem.GetMetadata(Metadata.PackageType));

CreateVisualStudioWorkloadTests.cs (8)

81Assert.Equal("{C4F269D9-6B65-36C5-9556-75B78EFE9EDA}", MsiUtils.GetProperty(manifestMsiItem.ItemSpec, MsiProperty.UpgradeCode)); 84Assert.Equal("6.33.28", MsiUtils.GetProperty(manifestMsiItem.ItemSpec, MsiProperty.ProductVersion)); 85Assert.Equal("Microsoft.NET.Workload.Emscripten,6.0.200,x64", MsiUtils.GetProviderKeyName(manifestMsiItem.ItemSpec)); 90Assert.Equal("x64;1033", si.Template); 217Assert.Equal("{CBA7CF4A-F3C9-3B75-8F1F-0D08AF7CD7BE}", MsiUtils.GetProperty(manifestMsiItem.ItemSpec, MsiProperty.UpgradeCode)); 220Assert.Equal("6.33.28", MsiUtils.GetProperty(manifestMsiItem.ItemSpec, MsiProperty.ProductVersion)); 221Assert.Equal("Microsoft.NET.Workload.Emscripten,6.0.200,arm64", MsiUtils.GetProviderKeyName(manifestMsiItem.ItemSpec)); 226Assert.Equal("Arm64;1033", si.Template);

MsiTests.cs (10)

61Assert.Equal("Microsoft.NET.Workload.Mono.ToolChain,6.0.200,6.0.3,x64", MsiUtils.GetProviderKeyName(msiPath603)); 62Assert.Equal("Microsoft.NET.Workload.Mono.ToolChain,6.0.200,6.0.4,x64", MsiUtils.GetProviderKeyName(msiPath604)); 97Assert.Equal("{E4761192-882D-38E9-A3F4-14B6C4AD12BD}", MsiUtils.GetProperty(msiPath, MsiProperty.UpgradeCode)); 98Assert.Equal("1.2.3", MsiUtils.GetProperty(msiPath, MsiProperty.ProductVersion)); 99Assert.Equal("Microsoft.NET.Workload.Mono.ToolChain,6.0.200,x64", MsiUtils.GetProviderKeyName(msiPath)); 100Assert.Equal("x64;1033", si.Template); 129Assert.Equal("{EC4D6B34-C9DE-3984-97FD-B7AC96FA536A}", MsiUtils.GetProperty(msiPath, MsiProperty.UpgradeCode)); 131Assert.Equal("15.2.302.0", MsiUtils.GetProperty(msiPath, MsiProperty.ProductVersion)); 132Assert.Equal("Microsoft.iOS.Templates,15.2.302-preview.14.122,x64", MsiUtils.GetProviderKeyName(msiPath)); 133Assert.Equal("x64;1033", si.Template);

PackageTests.cs (3)

27Assert.Equal("Microsoft.NET.Workload.Mono.ToolChain", p.ManifestId); 40Assert.Equal(expectedVersion, actualSdkVersion); 65Assert.Equal(expectedWorkloadSetVerion, workloadSetVersion);

SwixDependencyTests.cs (1)

23Assert.Equal(expectedVersionRange, dep.GetVersionRange());

SwixPackageGroupTests.cs (3)

33Assert.Equal(expectedPackageId, packageGroup.Name); 42Assert.Equal(expectedFeatureBand, packageGroupItem.GetMetadata(Metadata.SdkFeatureBand)); 43Assert.Equal(DefaultValues.PackageTypeManifestPackageGroup, packageGroupItem.GetMetadata(Metadata.PackageType));

SwixPackageTests.cs (2)

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); 55Assert.Equal($"Microsoft.iOS.Templates.{packageVersion}", msiItem.GetMetadata(Metadata.SwixPackageId));

WorkloadManifestTests.cs (2)

18Assert.Equal(expectedVersion, actualSdkVersion); 32Assert.Equal(expectedVersion, $"{actualFeatureBandVersion}");

Payloads\AdHocPayloadTests.cs (2)

18Assert.Equal("files", exception.ParamName); 26Assert.Equal("files", exception.ParamName);

HelpersTests.cs (3)

21Assert.Equal(workItemNameWithEncodedChars, actual); 31Assert.Equal(WebUtility.UrlDecode(workItemName), actual); 42Assert.Equal(workItemNameExpected, actual);

ReplacePackagePartsTests.cs (1)

56Assert.Equal("<replacement>", reader.ReadToEnd());

TestHelpers\AssertEx.cs (2)

351Assert.Equal(parameterName, e.ParamName); 363Assert.Equal(parameterName, e.ParamName);

VersionUpdaterTests.cs (1)

43Assert.Equal(expectedParts[i].name, actualParts[i].name);

OpenApiAddURLTests.cs (13)

OpenApiRefreshTests.cs (1)

95Assert.Equal(Content, await File.ReadAllTextAsync(expectedJsonPath));

ValidateUsageAgainstBaselineTests.cs (3)

41Assert.Equal( 112Assert.Equal(a.IdentityGlob, b.IdentityGlob); 113Assert.Equal(a.IdentityRegex, b.IdentityRegex);

WriteBuildOutputPropsTests.cs (2)

13Assert.Equal( 17Assert.Equal(

AssertHelper.cs (1)

12Assert.Equal(

XElementExtensionsTests.cs (11)

XlfDocumentTests.cs (1)

605e => Assert.Equal(expected: "The element 'trans-unit' in namespace 'urn:oasis:names:tc:xliff:document:1.2' has invalid child element 'target' in namespace 'urn:oasis:names:tc:xliff:document:1.2'. List of possible elements expected: 'source' in namespace 'urn:oasis:names:tc:xliff:document:1.2'.", actual: e.Message)

AsyncCollectionAssertsTests.cs (38)

BooleanAssertsTests.cs (6)

21 Assert.Equal( 35 Assert.Equal( 51 Assert.Equal("Custom User Message", ex.Message); 69 Assert.Equal( 83 Assert.Equal( 99 Assert.Equal("Custom User Message", ex.Message);

CollectionAssertsTests.cs (69)

DictionaryAssertsTests.cs (2)

46 Assert.Equal( 98 Assert.Equal(

EqualityAssertsTests.cs (152)

EquivalenceAssertsTests.cs (67)

EventAssertsTests.cs (16)

24 Assert.Equal( 46 Assert.Equal("Assert.Raises() Failure: No event was raised", ex.Message); 81 Assert.Equal( 106 Assert.Equal( 146 Assert.Equal( 191 Assert.Equal( 250 Assert.Equal( 272 Assert.Equal( 365 Assert.Equal( 424 Assert.Equal( 446 Assert.Equal( 539 Assert.Equal( 561 Assert.Equal("Assert.Raises() Failure: No event was raised", ex.Message); 596 Assert.Equal( 621 Assert.Equal( 661 Assert.Equal(

ExceptionAssertsTests.cs (36)

30 Assert.Equal( 55 Assert.Equal( 73 Assert.Equal( 102 Assert.Equal("You must call Assert.ThrowsAsync when testing async code", ex.Message); 113 Assert.Equal( 138 Assert.Equal( 156 Assert.Equal( 186 Assert.Equal( 211 Assert.Equal( 229 Assert.Equal( 255 Assert.Equal("You must call Assert.ThrowsAsync when testing async code", ex.Message); 266 Assert.Equal( 291 Assert.Equal( 309 Assert.Equal( 338 Assert.Equal( 362 Assert.Equal( 380 Assert.Equal( 398 Assert.Equal( 424 Assert.Equal( 448 Assert.Equal( 466 Assert.Equal( 484 Assert.Equal( 513 Assert.Equal( 538 Assert.Equal( 572 Assert.Equal("You must call Assert.ThrowsAnyAsync when testing async code", ex.Message); 583 Assert.Equal( 608 Assert.Equal( 643 Assert.Equal( 668 Assert.Equal( 702 Assert.Equal( 727 Assert.Equal( 745 Assert.Equal( 771 Assert.Equal( 795 Assert.Equal( 813 Assert.Equal( 831 Assert.Equal(

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); 43 Assert.Equal(

MultipleAssertsTests.cs (1)

65 Assert.Equal(

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); 69 Assert.Equal( 85 Assert.Equal(

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)

20 Assert.Equal( 40 Assert.Equal( 54 Assert.Equal( 74 Assert.Equal( 107 Assert.Equal( 130 Assert.Equal( 150 Assert.Equal( 170 Assert.Equal( 187 Assert.Equal(

Sdk\ArgumentFormatterTests.cs (29)

Sdk\CollectionTrackerTests.cs (22)

SetAssertsTests.cs (12)

41 Assert.Equal( 91 Assert.Equal( 129 Assert.Equal( 155 Assert.Equal( 169 Assert.Equal( 195 Assert.Equal( 221 Assert.Equal( 235 Assert.Equal( 279 Assert.Equal( 293 Assert.Equal( 336 Assert.Equal( 350 Assert.Equal(

TypeAssertsTests.cs (16)

23 Assert.Equal( 74 Assert.Equal( 92 Assert.Equal( 143 Assert.Equal( 169 Assert.Equal( 185 Assert.Equal( 201 Assert.Equal( 232 Assert.Equal( 248 Assert.Equal( 264 Assert.Equal( 295 Assert.Equal( 327 Assert.Equal( 369 Assert.Equal( 405 Assert.Equal( 431 Assert.Equal( 467 Assert.Equal(

ConditionalAttributeTests.cs (2)

46Assert.Equal("outerloop", res[0].Value); 57Assert.Equal("outerloop", res[0].Value);

CSharpIdentifierTest.cs (4)

58Assert.Equal(expectdOutput, output); 72Assert.Equal(expectdOutput, output); 88Assert.Equal(expectdOutput, output); 104Assert.Equal(expectdOutput, output);

GetCurrentOpenApiReferenceTest.cs (1)

44Assert.Equal(expectedIdentity, output.ItemSpec);

GetOpenApiReferenceMetadataTest.cs (9)

53Assert.Equal(identity, output.ItemSpec); 111Assert.Equal(identity, output.ItemSpec); 169Assert.Equal(identity, output.ItemSpec); 227Assert.Equal(identity, output.ItemSpec); 377Assert.Equal(identity, output.ItemSpec); 440Assert.Equal(identity, output.ItemSpec); 540Assert.Equal(identity12, output.ItemSpec); 552Assert.Equal(identity12, output.ItemSpec); 564Assert.Equal(identity3, output.ItemSpec);

MetadataSerializerTest.cs (12)

82Assert.Equal(value, item.GetMetadata(key)); 126Assert.Equal(identity, item.ItemSpec); 152Assert.Equal(identity, item.ItemSpec); 153Assert.Equal(value, item.GetMetadata("Value")); 167Assert.Equal(value, item.ItemSpec); 168Assert.Equal("a value", item.GetMetadata("Value")); 197Assert.Equal(expectedResult, result); 214Assert.Equal(expectedResult, result); 230Assert.Equal(expectedResult, result); 262Assert.Equal(expectedResult, result); 286Assert.Equal(expectedResult, result); 309Assert.Equal(expectedResult, result);

GetDocumentTests.cs (4)

43Assert.Equal("GetDocumentSample | v1", document.Info.Title); 68Assert.Equal("GetDocumentSample | v1", document.Info.Title); 94Assert.Equal("GetDocumentSample | v1", document.Info.Title); 120Assert.Equal("GetDocumentSample | internal", document.Info.Title);

ServiceConstructionTests.cs (2)

96Assert.Equal(expected, actual); 109Assert.Equal(expected, actual);

SizeTests.cs (4)

31Assert.Equal(expected, actual); 43Assert.Equal(expected, actual); 74Assert.Equal(expected, actual.Value); 82Assert.Equal(expected, actual.Value);

SqlServerCacheWithDatabaseTest.cs (1)

88Assert.Equal("The absolute expiration value must be in the future.", exception.Message);

RedisCacheSetAndRemoveTests.cs (4)

144Assert.Equal(Hex(payload), Hex(raw)); 149Assert.Equal(payload, value); 167Assert.Equal(Hex(payload), Hex(raw)); 172Assert.Equal(payload, value);

TimeExpirationAsyncTests.cs (1)

25Assert.Equal(paramName, ex.ParamName);

Classification\DataClassificationAttributeTests.cs (1)

29Assert.Equal("Hello", attribute.Notes);

Classification\DataClassificationTests.cs (5)

17Assert.Equal(TaxonomyName, dc.TaxonomyName); 18Assert.Equal(Value, dc.Value); 47Assert.Equal($"{TaxonomyName}:{Value}", dc.ToString()); 49Assert.Equal("None", DataClassification.None.ToString()); 50Assert.Equal("Unknown", DataClassification.Unknown.ToString());

Redaction\NullRedactorTest.cs (2)

18Assert.Equal(string.Empty, emptyStringRedacted); 22Assert.Equal(string.Empty, emptyStringRedacted);

Redaction\RedactorTest.cs (13)

18Assert.Equal(string.Empty, r.Redact((string?)null)); 19Assert.Equal(string.Empty, r.Redact<object?>(null)); 20Assert.Equal(string.Empty, r.Redact(string.Empty.AsSpan())); 40Assert.Equal(data, redacted); 68Assert.Equal(extBuffer.ToString(), buffer.ToString()); 86Assert.Equal(redactedDirectly, redacted); 125Assert.Equal(redactedDirectly, redacted); 164Assert.Equal(redactedDirectly, redacted); 194Assert.Equal("", redacted); 203Assert.Equal("", redacted); 252Assert.Equal(data.ToString(), new string(buffer, 0, charsWritten)); 270Assert.Equal(data.ToString(), new string(buffer, 0, charsWritten)); 288Assert.Equal(data.ToString("R"), new string(buffer, 0, charsWritten));

HmacRedactorTest.cs (2)

114Assert.Equal(example.Hash, result); 139Assert.Equal(example.Hash, result);

RedactionAcceptanceTests.cs (2)

32Assert.Equal(redacted, data); 36Assert.Equal(redacted, data);

FakeRedactorProviderTests.cs (1)

18Assert.Equal("Hello", redactor.Redact("Hello"));

FakeRedactorTests.cs (4)

29Assert.Equal(redacted1, redacted2); 30Assert.Equal(redacted1, redacted3); 48Assert.Equal(RedactedConstOutput, redacted); 58Assert.Equal(redacted, data);

RedactionFakesAcceptanceTests.cs (9)

129Assert.Equal($"xxx{data}xxx", redacted); 149Assert.Equal($"xxx{data}xxx", redacted); 169Assert.Equal($"xxx{data}xxx", redacted); 189Assert.Equal($"xxx{data}xxx", redacted); 213Assert.Equal(data2, collector.LastRedactedData.Original); 214Assert.Equal(redacted2, collector.LastRedactedData.Redacted); 218Assert.Equal(data, collector.AllRedactedData[0].Original); 219Assert.Equal(redacted, collector.AllRedactedData[0].Redacted); 255Assert.Equal(redacted, collector.LastRedactedData.Redacted);

ConfigurationProviderTestBase.cs (5)

135Assert.Equal("Value1", options.Key1); 136Assert.Equal("Value12", options.Section1.Key2); 137Assert.Equal("Value123", options.Section1.Section2.Key3); 138Assert.Equal("Value344", options.Section3.Section4.Key4); 181Assert.Equal(

KeyPerFileTests.cs (32)

ApplicationLifecycleHealthChecksExtensionsTests.cs (1)

62Assert.Equal("ApplicationLifecycle", r.Name);

ManualHealthCheckExtensionsTests.cs (1)

57Assert.Equal(r.Name, name);

TelemetryHealthChecksPublisherTests.cs (1)

105Assert.Equal(expectedLogMessage, collector.LatestRecord.Message);

DefaultHealthCheckServiceTest.cs (38)

DependencyInjection\HealthChecksBuilderTest.cs (11)

36Assert.Equal("test", registration.Name); 56Assert.Equal("test", registration.Name); 79Assert.Equal("test", registration.Name); 101Assert.Equal("test", registration.Name); 107Assert.Equal("hi", check.S); 127Assert.Equal("test", registration.Name); 150Assert.Equal("test", registration.Name); 173Assert.Equal("test", registration.Name); 196Assert.Equal("test", registration.Name); 219actual => Assert.Equal("Foo", actual.Name), 220actual => Assert.Equal("Bar", actual.Name));

HealthCheckPublisherHostedServiceTest.cs (1)

370Assert.Equal("CheckDefault", Assert.Single(Assert.Single(publisher.Entries).report.Entries.Keys));

Linux\LinuxUtilizationProviderTests.cs (1)

206Assert.Equal(ResourceUtilizationInstruments.MeterName, meter.Name);

Linux\OSFileSystemTests.cs (6)

37Assert.Equal(Content, s); 51Assert.Equal(Content, s); 82Assert.Equal(expected, actual); 113Assert.Equal(expectedLines[i], line.ToString()); 161Assert.Equal(expectedLines[i], line.ToString()); 209Assert.Equal(expectedLines.ElementAt(cnt), line.ToString().Replace("\r", ""));

ResourceMonitoringOptionsCustomValidatorTests.cs (1)

78Assert.Equal("Property PublishingWindow: Value must be <= to CollectionWindow (00:00:01), but is 00:00:02.", failureMessage);

Windows\WindowsContainerSnapshotProviderTests.cs (1)

345Assert.Equal(ResourceUtilizationInstruments.MeterName, meter.Name);

Windows\WindowsSnapshotProviderTests.cs (1)

169Assert.Equal(ResourceUtilizationInstruments.MeterName, meter.Name);

Logging\FakeLogCollectorTests.cs (16)

Logging\FakeLoggerProviderTests.cs (3)

20Assert.Equal("Storage", logger.LatestRecord.Category); 32Assert.Equal("Microsoft.Extensions.Logging.Testing.Test.Logging.FakeLoggerProviderTests", logger.LatestRecord.Category); 50Assert.Equal("Storage", records[1].Category);

Logging\FakeLoggerTests.cs (19)

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

EmbeddedFileProviderTests.cs (6)

55Assert.Equal("File.txt", fileInfo.Name); 121Assert.Equal("File3.txt", fileInfo.Name); 159Assert.Equal("File.txt", fileInfo.Name); 197Assert.Equal("File3.txt", fileInfo.Name); 213file => Assert.Equal("File.txt", file.Name), 214file => Assert.Equal("ResourcesInSubdirectory.File3.txt", file.Name));

ManifestEmbeddedFileProviderTests.cs (10)

31Assert.Equal("jquery.validate.js", jqueryValidate.Name); 38Assert.Equal("jquery.min.js", jqueryMin.Name); 45Assert.Equal("site.css", siteCss.Name); 68Assert.Equal("jquery.validate.js", jqueryValidate.Name); 75Assert.Equal("jquery.min.js", jqueryMin.Name); 82Assert.Equal("site.css", siteCss.Name); 167Assert.Equal("jquery.validate.js", jqueryValidate.Name); 190Assert.Equal("jquery.validate.js", jqueryValidate.Name); 237Assert.Equal(path, file.Name); 441Assert.Equal("jquery.validate.js", jqueryValidate.Name);

FakeConfigurationSourceTests.cs (4)

22Assert.Equal("testKey", item.Key); 23Assert.Equal("testValue", item.Value); 27Assert.Equal("anotherTestKey", item.Key); 28Assert.Equal("anotherTestValue", item.Value);

HostingFakesExtensionsTests.cs (21)

HostTerminatorServiceTests.cs (2)

46Assert.Equal( 62Assert.Equal(

Logging\AcceptanceTests.cs (8)

46Assert.Equal(LoggingCategory, logRecord.Category); 47Assert.Equal($"{HttpMethod.Get} {_unreachableRequestUri.Host}/{TelemetryConstants.Redacted}", logRecord.Message); 78Assert.Equal(LoggingCategory, firstLogRecord.Category); 87Assert.Equal(LoggingCategory, secondLogRecord.Category); 88Assert.Equal($"{HttpMethod.Get} {_unreachableRequestUri.Host}/{TelemetryConstants.Redacted}", secondLogRecord.Message); 117Assert.Equal($"{httpRequestMessage.Method} {httpRequestMessage.RequestUri.Host}/{TelemetryConstants.Redacted}", logRecord.Message); 624r => Assert.Equal("RequestPipelineStart", r.Id.Name), 625r => Assert.Equal("RequestPipelineEnd", r.Id.Name));

Logging\HttpClientLoggerTest.cs (5)

441Assert.Equal($"{httpRequestMessage.Method} {httpRequestMessage.RequestUri.Host}/{TelemetryConstants.Redacted}", logRecord.Message); 780Assert.Equal(nameof(Log.EnrichmentError), logRecords[0].Id.Name); 783Assert.Equal(nameof(Log.OutgoingRequest), logRecords[1].Id.Name); 825Assert.Equal(nameof(Log.EnrichmentError), logRecords[0].Id.Name); 828Assert.Equal(nameof(Log.OutgoingRequestError), logRecords[1].Id.Name);

Logging\Internal\LogRecordExtensions.cs (1)

30Assert.Equal(expectedValue, actualValue);

Logging\LoggerMessageStateExtensionsTests.cs (2)

45Assert.Equal(prefix + NormalizedHeader1, state.TagArray[0].Key); 48Assert.Equal(prefix + NormalizedHeader2, state.TagArray[1].Key);

Telemetry\DownstreamDependencyMetadataManagerTests.cs (8)

56Assert.Equal(new BackslashDownstreamDependencyMetadata().DependencyName, requestMetadata.DependencyName); 57Assert.Equal(expectedRequestName, requestMetadata.RequestName); 58Assert.Equal(expectedRequestRoute, requestMetadata.RequestRoute); 59Assert.Equal(httpMethod, requestMetadata.MethodType); 77Assert.Equal("EmptyRouteService", requestMetadata.DependencyName); 78Assert.Equal(expectedRequestName, requestMetadata.RequestName); 79Assert.Equal("GET", requestMetadata.MethodType); 80Assert.Equal(expectedRequestRoute, requestMetadata.RequestRoute);

TelemetryCommonExtensionsTests.cs (8)

22Assert.Equal(TelemetryConstants.Unknown, requestMetadata.DependencyName); 34Assert.Equal(TelemetryConstants.Unknown, requestMetadata.RequestRoute); 79Assert.Equal(metadata.DependencyName, extractedMetadata!.DependencyName); 80Assert.Equal(metadata.RequestName, extractedMetadata!.RequestName); 81Assert.Equal(metadata.RequestRoute, extractedMetadata!.RequestRoute); 97Assert.Equal(TelemetryConstants.Unknown, extractedMetadata!.DependencyName); 98Assert.Equal(TelemetryConstants.Unknown, extractedMetadata!.RequestName); 99Assert.Equal(TelemetryConstants.Unknown, extractedMetadata!.RequestRoute);

PolicyHttpMessageHandlerTest.cs (1)

220Assert.Equal(

Hedging\HedgingTests.cs (6)

131Assert.Equal("https://enpoint-1:80/some-path?query", Requests[0]); 153Assert.Equal("The routing strategy did not provide any route URL on the first attempt.", exception.Message); 175Assert.Equal("Something went wrong!", exception.Message); 303Assert.Equal("https://enpoint-1:80/some-path?query", Requests[0]); 304Assert.Equal("https://enpoint-2:80/some-path?query", Requests[1]); 305Assert.Equal("https://enpoint-3:80/some-path?query", Requests[2]);

Hedging\StandardHedgingTests.cs (1)

89Assert.Equal(ClientId, Builder.RoutingStrategyBuilder.Name);

Resilience\PipelineNameHelperTest.cs (1)

14Assert.Equal("client-pipeline", PipelineNameHelper.GetName("client", "pipeline"));

Resilience\RequestMessageSnapshotTests.cs (1)

29Assert.Equal("StreamContent content cannot by cloned.", exception.Message);

StringLocalizerOfTRootNamespaceTest.cs (1)

24Assert.Equal("ValFromResource", value);

ResourceManagerStringLocalizerFactoryTest.cs (6)

87Assert.Equal(typeFactory.BaseName, stringFactory.BaseName); 88Assert.Equal(typeFactory.Assembly!.FullName, stringFactory.Assembly!.FullName); 152Assert.Equal($"{rootNamespace}.{nameof(Model)}", typeFactory.BaseName); 181Assert.Equal($"{rootNamespace}.My.Resources.{nameof(Model)}", typeFactory.BaseName); 203Assert.Equal("Microsoft.Extensions.Localization.Tests.My.Resources." + nameof(ResourceManagerStringLocalizerFactoryTest), factory.BaseName); 283Assert.Equal("Microsoft.Extensions.Localization.Tests.My.Resources.baseName", factory.BaseName);

ResourceManagerStringLocalizerTest.cs (4)

113Assert.Equal("Resources.TestResource", value.SearchedLocation); 140Assert.Equal("ResourceManagerStringLocalizer searched for 'a key!' in 'Resources.TestResource' with culture 'en-US'.", write.State.ToString()); 170Assert.Equal("TestName", value.Value); 208Assert.Equal(expected, exception.Message);

StringLocalizerOfTTest.cs (3)

19Assert.Equal("factory", exception.ParamName); 49Assert.Equal("name", exception.ParamName); 84Assert.Equal("name", exception.ParamName);

DependencyInjectionExtensionsTests.cs (2)

136Assert.Equal(TestDependency.DefaultMessage, pool!.Get().ReadMessage()); 151Assert.Equal(TestDependency.DefaultMessage, pool!.Get().ReadMessage());

AcceptanceTests.cs (2)

96Assert.Equal("Fahrenheit", (await forecastService.GetForecast(new WeatherForecastContext { Country = "US" }, CancellationToken.None)).First().TemperatureScale); 97Assert.Equal("Celsius", (await forecastService.GetForecast(new WeatherForecastContext { Country = "CA" }, CancellationToken.None)).First().TemperatureScale);

ContextualOptionsServiceCollectionExtensionsTests.cs (2)

38Assert.Equal(string.Empty, loader.Name); 48Assert.Equal(string.Empty, loader.Name);

InitCommandTest.cs (4)

57Assert.Equal(SecretId, idResolver.Resolve(null, null)); 71Assert.Equal(SecretId, idResolver.Resolve(null, null)); 85Assert.Equal(SecretId, idResolver.Resolve(null, null)); 128Assert.Equal(NewId, idResolver.Resolve(null, null));

MsBuildProjectFinderTest.cs (1)

25Assert.Equal(Path.Combine(files.Root, filename), finder.FindMsBuildProject(null));

SetCommandTest.cs (6)

42Assert.Equal("str value", secretStore["Key1"]); 43Assert.Equal("1234", secretStore["Key2"]); 44Assert.Equal("False", secretStore["Key3"]); 70Assert.Equal("value", secretStore["Key1:nested"]); 71Assert.Equal("1", secretStore["array:0"]); 72Assert.Equal("2", secretStore["array:1"]);

DnsServicePublicApiTests.cs (6)

20Assert.Equal(nameof(services), exception.ParamName); 32Assert.Equal(nameof(services), exception.ParamName); 44Assert.Equal(nameof(configureOptions), exception.ParamName); 55Assert.Equal(nameof(services), exception.ParamName); 67Assert.Equal(nameof(services), exception.ParamName); 79Assert.Equal(nameof(configureOptions), exception.ParamName);

DnsSrvServiceEndpointResolverTests.cs (1)

220Assert.Equal("basket", hostNameFeature.HostName);

ConfigurationServiceEndpointResolverTests.cs (3)

178Assert.Equal("basket", hostNameFeature.HostName); 310Assert.Equal("basket", hostNameFeature.HostName); 332Assert.Equal("basket", hostNameFeature.HostName);

ServiceEndpointResolverTests.cs (4)

30Assert.Equal("No provider which supports the provided service name, 'https://basket', has been configured.", exception.Message); 41Assert.Equal("No service endpoint providers are configured.", exception.Message); 43Assert.Equal("No service endpoint providers are configured.", exception.Message); 64Assert.Equal("No provider which supports the provided service name, 'http://foo', has been configured.", exception.Message);

YarpServiceDiscoveryPublicApiTests.cs (3)

21Assert.Equal(nameof(builder), exception.ParamName); 32Assert.Equal(nameof(services), exception.ParamName); 43Assert.Equal(nameof(services), exception.ParamName);

YarpServiceDiscoveryTests.cs (1)

262Assert.Equal(expectedScheme, uri.Scheme);

Http\AbstractionTests.cs (11)

15Assert.Equal("GET", requestMetadata.MethodType); 16Assert.Equal(TelemetryConstants.Unknown, requestMetadata.DependencyName); 17Assert.Equal(TelemetryConstants.Unknown, requestMetadata.RequestName); 18Assert.Equal(TelemetryConstants.Unknown, requestMetadata.RequestRoute); 29Assert.Equal("POST", requestMetadata.MethodType); 30Assert.Equal("MyDependency", requestMetadata.DependencyName); 31Assert.Equal("TestRequest", requestMetadata.RequestName); 32Assert.Equal("/v1/temp/route/{routeId}", requestMetadata.RequestRoute); 38Assert.Equal("Extensions-RequestMetadata", TelemetryConstants.RequestMetadataKey); 39Assert.Equal("unknown", TelemetryConstants.Unknown); 40Assert.Equal("REDACTED", TelemetryConstants.Redacted);

Latency\CheckpointTests.cs (2)

15Assert.Equal(name, c.Name); 45Assert.Equal(name, c.Name);

Latency\MeasureTests.cs (2)

16Assert.Equal(c.Name, name); 45Assert.Equal(c.Name, name);

Latency\TagTests.cs (3)

16Assert.Equal(t.Name, name); 17Assert.Equal(t.Value, value); 26Assert.Equal(c.Name, name);

Logging\LoggerMessageHelperTests.cs (7)

20Assert.Equal(expected, LoggerMessageHelper.Stringify(enumerable)); 26Assert.Equal("null", LoggerMessageHelper.Stringify((IEnumerable<KeyValuePair<string, string>>?)null)); 32Assert.Equal("{\"One\"=\"Un\"}", LoggerMessageHelper.Stringify(d0)); 39Assert.Equal("{\"One\"=\"Un\",\"Two\"=\"Deux\"}", LoggerMessageHelper.Stringify(d1)); 46Assert.Equal("{null=\"Un\",\"Two\"=null}", LoggerMessageHelper.Stringify(d2)); 54Assert.Equal("{\"Zero\"=\"0\",\"One\"=\"1\",\"Two\"=\"2\"}", LoggerMessageHelper.Stringify(d3)); 62Assert.Equal("{\"0\"=\"Zero\",\"1\"=\"One\",\"2\"=\"Two\"}", LoggerMessageHelper.Stringify(d4));

Logging\LoggerMessageStateTests.cs (22)

Logging\TagNameAttributeTests.cs (1)

15Assert.Equal("a", a.Name);

Logging\TagProviderAttributeTests.cs (1)

44Assert.Equal(ProviderMethod, attr.ProviderMethod);

Metrics\MetricAttributeTests.cs (11)

22Assert.Equal(MyMetric, attribute.Name); 35Assert.Equal(MyMetric, attribute.Name); 48Assert.Equal(MyMetric, attribute.Name); 61Assert.Equal(MyMetric, attribute.Name); 74Assert.Equal(MyMetric, attribute.Name); 88Assert.Equal(MyMetric, attribute.Name); 102Assert.Equal(MyMetric, attribute.Name); 116Assert.Equal(MyMetric, attribute.Name); 130Assert.Equal(MyMetric, attribute.Name); 144Assert.Equal(MyMetric, attribute.Name); 153Assert.Equal("testName", attribute.Name);

Http\HttpParserTests.cs (11)

66Assert.Equal(TelemetryCommonExtensions.UnsupportedEnumValueExceptionMessage, ex.Message); 390Assert.Equal("api/routes/{routeId}/chats/{chatId}", routeSegments.RouteTemplate); 402Assert.Equal("api/routes/{routeId}/chats/{chatId}/messages", routeSegments.RouteTemplate); 420Assert.Equal("api/routes/{routeId}/chats/{chatId}/messages", routeSegments.RouteTemplate); 433Assert.Equal("api/routes/{routeId}/chats/{chatId}/messages", routeSegments.RouteTemplate); 451Assert.Equal(httpRoute, routeSegments.RouteTemplate); 485Assert.Equal(name, parameter.Name); 486Assert.Equal(value, parameter.Value); 493Assert.Equal(content, segment.Content); 495Assert.Equal(paramName, segment.ParamName); 496Assert.Equal(defaultValue, segment.DefaultValue);

Http\HttpRouteFormatterTests.cs (56)

Http\TelemetryCommonExtensionsTests.cs (2)

20Assert.Equal(TelemetryConstants.Unknown, requestMetadata.DependencyName); 32Assert.Equal(TelemetryConstants.Unknown, requestMetadata.RequestRoute);

Latency\Internal\LatencyConsoleExporterTests.cs (4)

86Assert.Equal(_fullResult, result); 108Assert.Equal(_longResult, result); 130Assert.Equal(_truncatedResult, result); 152Assert.Equal(_emptyResult, result);

Latency\Internal\LatencyContextTests.cs (4)

121Assert.Equal(TokenName, measures[0].Name); 147Assert.Equal(TokenName, measures[0].Name); 205Assert.Equal(Tag, tags[0].Value); 282Assert.Equal(TokenName, checkpoints[0].Name);

Latency\Internal\LatencyContextTokenIssuerTests.cs (6)

24Assert.Equal("cb", ct.Name); 28Assert.Equal("mc", mt.Name); 32Assert.Equal("ta", tt.Name); 43Assert.Equal("ta", ct.Name); 47Assert.Equal("cb", mt.Name); 51Assert.Equal("mc", tt.Name);

Latency\Internal\RegistryTests.cs (1)

50Assert.Equal(ok1[i], ok2[i]);

Logging\ExtendedLoggerFactoryTests.cs (29)

Logging\ExtendedLoggerTests.cs (58)

Logging\JustInTimeRedactorTests.cs (8)

43Assert.Equal($"{ShortRedactorPrefix}<{redactorInput}>", r.ToString()); 47Assert.Equal($"{ShortRedactorPrefix}<{redactorInput}>", d.Slice(0, charsWritten).ToString()); 55Assert.Equal($"{ShortRedactorPrefix}<{redactorInput}>", r.ToString()); 60Assert.Equal($"{ShortRedactorPrefix}<{redactorInput}>", r.ToString()); 67Assert.Equal($"{longRedactorPrefix}<{redactorInput}>", r.ToString()); 71Assert.Equal($"{longRedactorPrefix}<{redactorInput}>", d.Slice(0, charsWritten).ToString()); 76Assert.Equal($"{longRedactorPrefix}<{redactorInput}>", r.ToString()); 81Assert.Equal($"{longRedactorPrefix}<{redactorInput}>", r.ToString());

Logging\SerialExtendedLoggerTests.cs (1)

59Assert.Equal(Category, sink.Category);

FakeTimeProviderTests.cs (1)

220Assert.Equal("2022-01-02T03:04:05.006", timeProvider.ToString());

EncoderServiceCollectionExtensionsTests.cs (6)

49Assert.Equal("abcde", htmlEncoder.Encode("abcde")); 53Assert.Equal(@"a\u0062c\u0064e", javaScriptEncoder.Encode("abcde")); 57Assert.Equal("a%62c%64e", urlEncoder.Encode("abcde")); 81Assert.Equal("HtmlEncode[[abcde]]", htmlEncoder.Encode("abcde")); 84Assert.Equal("JavaScriptEncode[[abcde]]", javaScriptEncoder.Encode("abcde")); 87Assert.Equal("a%62c%64e", urlEncoder.Encode("abcde"));

HtmlTestEncoderTest.cs (1)

23Assert.Equal(expectedOutput, output);

GeneratorTests.cs (2)

87Assert.Equal(golden, generated); 133Assert.Equal("AUDREPGEN001", diag.Id);

EmitterTests.cs (1)

151Assert.Equal(golden, result);

ParserTests.cs (2)

33Assert.Equal("TestClasses.ClassWithUnusableProperties", result.Single().HintName); 50Assert.Equal(".NamespacelessRecord", result.Single().HintName);

SyntaxContextReceiverTests.cs (4)

36Assert.Equal(declaration.Key.Name, declaration.Value.Single().Identifier.Text); 37Assert.Equal("TestClasses", declaration.Key.ContainingNamespace.ToString()); 73Assert.Equal("TestClasses", declaration.Key.ContainingNamespace.ToString()); 75Assert.All(declaration.Value.Select(dec => dec.Identifier.Text), className => Assert.Equal("Class2", className));

DataClassificationTests.cs (1)

23Assert.Equal("M2", collector.LatestRecord.Message);

LoggerFromMemberTests.cs (12)

LoggerMessageAttributeTests.cs (13)

LogMethodTests.cs (114)

LogPropertiesRedactionTests.cs (6)

31Assert.Equal("LogProperties with redaction: ----", collector.LatestRecord.Message); 57Assert.Equal(string.Empty, collector.LatestRecord.Message); 80Assert.Equal("No template params", collector.LatestRecord.Message); 111Assert.Equal(string.Empty, collector.LatestRecord.Message); 140Assert.Equal("Only ----------- as param", collector.LatestRecord.Message); 166Assert.Equal(string.Empty, collector.LatestRecord.Message);

LogPropertiesTests.cs (48)

PrimaryConstructorTests.cs (4)

24Assert.Equal("Test.", collector.LatestRecord.Message); 38Assert.Equal("Test.", collector.LatestRecord.Message); 52Assert.Equal("Test.", collector.LatestRecord.Message); 66Assert.Equal("Test.", collector.LatestRecord.Message);

TagNameTests.cs (1)

33Assert.Equal("0", logger.Collector.LatestRecord.Message);

TagProviderTests.cs (25)

AttributeParserTests.cs (4)

142Assert.Equal(DiagDescriptors.MissingLoggerParameter.Id, diagnostics[0].Id); 170Assert.Equal(DiagDescriptors.LoggingMethodShouldBeStatic.Id, diagnostics[0].Id); 192Assert.Equal(DiagDescriptors.CantUseDataClassificationWithLogPropertiesOrTagProvider.Id, diagnostics[0].Id); 222Assert.Equal(DiagDescriptors.CantUseDataClassificationWithLogPropertiesOrTagProvider.Id, diagnostics[0].Id);

EmitterUtilsTests.cs (3)

22Assert.Equal("\"" + expected + "\"", Emitter.EscapeMessageString(input)); 34Assert.Equal(expected, Emitter.EscapeMessageStringForXmlDocumentation(input)); 64Assert.Equal(ParamName, Emitter.GetLoggerMethodLogLevel(lm));

LoggingMethodParameterTests.cs (4)

64Assert.Equal(lp.ParameterName, lp.ParameterNameWithAtIfNeeded); 71Assert.Equal(lp.Type, lp.PotentiallyNullableType); 75Assert.Equal(lp.Type, lp.PotentiallyNullableType); 83Assert.Equal(lp.Type, lp.PotentiallyNullableType);

LoggingMethodTests.cs (1)

18Assert.Equal("_logger", instance.LoggerMember);

EmitterTests.cs (2)

50Assert.Equal(goldenCache, result); 53Assert.Equal(goldenMetrics, result);

ParserTests.cs (19)

ParserTests.Diagnostics.cs (11)

EmitterTests.cs (3)

95Assert.Equal(string.Empty, emitter.GenerateReport(null!, CancellationToken.None)); 102Assert.Equal(string.Empty, emitter.GenerateReport(Array.Empty<ReportedMetricClass>(), CancellationToken.None)); 183Assert.Equal(expected, json);

GeneratorTests.cs (1)

71Assert.Equal(golden, generated);

DotNetObjectReferenceTest.cs (1)

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

Infrastructure\ByteArrayJsonConverterTest.cs (9)

26Assert.Equal("JSON serialization is attempting to deserialize an unexpected byte array.", ex.Message); 39Assert.Equal("Unexpected JSON Token EndObject, expected 'PropertyName'.", ex.Message); 52Assert.Equal("Unexpected JSON Property foo.", ex.Message); 92Assert.Equal("JSON serialization is attempting to deserialize an unexpected byte array.", ex.Message); 124Assert.Equal("Unexpected JSON Token PropertyName, expected 'EndObject'.", ex.Message); 140Assert.Equal("Unexpected JSON Token String, expected 'Number'.", ex.Message); 156Assert.Equal("Unexpected number, expected 32-bit integer.", ex.Message); 172Assert.Equal("Byte array -5 not found.", ex.Message); 227Assert.Equal($"{{\"__byte[]\":{i + 1}}}", json);

Infrastructure\DotNetDispatcherTest.cs (25)

47Assert.Equal($"There is no loaded assembly with the name '{assemblyName}'.", ex.Message); 69Assert.Equal($"The assembly '{thisAssemblyName}' does not contain a public invokable method with [JSInvokableAttribute(\"{methodIdentifier}\")].", ex.Message); 94Assert.Equal("Test", result.StringVal); 107Assert.Equal("InvokableMethodWithoutCustomIdentifier", result.StringVal); 136Assert.Equal("ANOTHER STRING", resultDto1.StringVal); 146Assert.Equal("MY STRING", resultDto2.StringVal); 171Assert.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); 279Assert.Equal(testDTO.StringVal, result.StringVal); 297Assert.Equal(expected, ex.Message); 461Assert.Equal("[\"You passed myvalue\",{\"__dotNetObject\":3}]", resultJson); 464Assert.Equal("MY STRING", resultDto.StringVal); 480Assert.Equal("\"hello world\"", resultJson); 496Assert.Equal("\"hello world\"", resultJson); 556Assert.Equal("The call to 'InvocableStaticWithParams' expects '3' parameters, but received '2'.", ex.Message); 579Assert.Equal("Unexpected JSON token Number. Ensure that the call to `InvocableStaticWithParams' is supplied with exactly '3' parameters.", ex.Message); 607Assert.Equal(callId, jsRuntime.LastCompletionCallId); 612Assert.Equal("STRING VIA JSON", result.SomeDTO.StringVal); 617Assert.Equal("MY STRING", resultDto2.StringVal); 647Assert.Equal(callId, jsRuntime.LastCompletionCallId); 671Assert.Equal(callId, jsRuntime.LastCompletionCallId); 689Assert.Equal(callId, jsRuntime.LastCompletionCallId); 711Assert.Equal(callId, jsRuntime.LastCompletionCallId); 731Assert.Equal(callId, jsRuntime.LastCompletionCallId); 747Assert.Equal(callId, jsRuntime.LastCompletionCallId); 834Assert.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\DotNetObjectReferenceJsonConverterTest.cs (4)

24Assert.Equal("Required property __dotNetObject not found.", ex.Message); 38Assert.Equal("Unexpected JSON property foo.", ex.Message); 141Assert.Equal($"{{\"__dotNetObject\":{dotNetObjectRef.ObjectId}}}", json1); 142Assert.Equal(json1, json2);

Infrastructure\DotNetStreamReferenceJsonConverterTest.cs (2)

40Assert.Equal("{\"__dotNetStream\":1}", json); 53Assert.Equal($"{{\"__dotNetStream\":{i}}}", json);

Infrastructure\JSObjectReferenceJsonConverterTest.cs (3)

28Assert.Equal("Required property __jsObjectId not found.", ex.Message); 39Assert.Equal("Unexpected JSON property foo.", ex.Message); 88Assert.Equal($"{{\"__jsObjectId\":{jsObjectRef.Id}}}", json);

Infrastructure\JSStreamReferenceJsonConverterTest.cs (4)

28Assert.Equal("Required property __jsObjectId not found.", ex.Message); 39Assert.Equal("Unexpected JSON property foo.", ex.Message); 73Assert.Equal("Required property __jsStreamReferenceLength not found.", ex.Message); 118Assert.Equal($"{{\"__jsObjectId\":{jsObjectRef.Id}}}", json);

JSInProcessRuntimeTest.cs (5)

25Assert.Equal("Hello", syncResult.StringValue); 26Assert.Equal("test identifier 1", call.Identifier); 27Assert.Equal("[\"arg1\",123,true]", call.ArgsJson); 54Assert.Equal("test identifier", call.Identifier); 55Assert.Equal("[{\"__dotNetObject\":1},{\"obj2\":{\"__dotNetObject\":2},\"obj3\":{\"__dotNetObject\":3}}]", call.ArgsJson);

JSRuntimeExtensionsTest.cs (4)

30Assert.Equal("Hello", result); 54Assert.Equal("Hello", result); 108Assert.Equal(expected, result); 131Assert.Equal(expected, result);

JSRuntimeTest.cs (13)

28Assert.Equal("test identifier 1", call.Identifier); 29Assert.Equal("[\"arg1\",123,true]", call.ArgsJson); 33Assert.Equal("test identifier 2", call.Identifier); 34Assert.Equal("[\"some other arg\"]", call.ArgsJson); 125Assert.Equal("my result", task.Result); 150Assert.Equal("Test", poco.Name); 175Assert.Equal("Test", poco.Name); 203Assert.Equal("This is a test exception", jsException.Message); 256Assert.Equal("Some data", result); 285Assert.Equal("test identifier", call.Identifier); 286Assert.Equal("[{\"__dotNetObject\":1},{\"obj2\":{\"__dotNetObject\":2},\"obj3\":{\"__dotNetObject\":3},\"obj1SameRef\":{\"__dotNetObject\":1},\"obj1DifferentRef\":{\"__dotNetObject\":4}}]", call.ArgsJson); 311Assert.Equal("0", call.CallId); 396Assert.Equal("Element id '7' cannot be added to the byte arrays to be revived with length '2'.", ex.Message);

AutoFitTests.cs (2)

634Assert.Equal(col.Name, resTrainTest.Schema[col.Index].Name); 635Assert.Equal(col.Name, resCV.Schema[col.Index].Name);

ColumnInferenceTests.cs (20)

UserInputValidationTests.cs (8)

39Assert.Equal("Provided label column cannot be null", ex.Message); 51Assert.Equal($"Provided label column '{columnName}' not found in training data.", ex.Message); 65Assert.Equal($"Provided label column '{mistypedColumnName}' not found in training data. Did you mean '{originalColumnName}'.", 79Assert.Equal("Provided label column 'Label' was of type Boolean, but only type Single is allowed.", ex.Message); 90Assert.Equal("Null column string was specified as numeric in column information", ex.Message); 229Assert.Equal("Provided text column 'TextColumn' was of type Single, but only type String is allowed.", ex.Message); 406Assert.Equal($"Provided label column '{mistypedColumnName}' not found in training data. Did you mean '{originalColumnName}'.", 421Assert.Equal($"Provided label column '{mistypedColumnName}' not found in training data.",

Util.cs (1)

21Assert.Equal(expectedJson, actualJson);

CodeGenTests.cs (8)

38Assert.Equal(expected, actual.Item1); 40Assert.Equal("using Microsoft.ML.Trainers.LightGbm;\r\n", actual.Item2.First()); 60Assert.Equal(expectedTrainer, actual.Item1); 61Assert.Equal(expectedUsing, actual.Item2[0]); 74Assert.Equal(expected, actual[0].Item1); 88Assert.Equal(expectedTransform, actual[0].Item1); 133Assert.Equal(expectedTrainer, actual.Item1); 134Assert.Equal(expectedUsings, actual.Item2[0]);

TrainerGeneratorTests.cs (58)

TransformGeneratorTests.cs (13)

UtilTest.cs (1)

201Assert.Equal(expectedStrArray[i], actualStr);

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

UnitTests\TestCustomTypeRegister.cs (3)

198Assert.Equal(tribeEnumerable[0].Name, "Super " + tribe[0].Name); 210Assert.Equal(superAlien.Name, "Super " + alien.Name); 233Assert.Equal(superAlien.Name, "Super " + alien.Name);

UnitTests\TestEntryPoints.cs (9)

376Assert.Equal("OtherWeight", instance.ExampleWeightColumnName); 380Assert.Equal("AnotherWeight", instance.ExampleWeightColumnName); 2548Assert.Equal(cat.ToString(), catValue.ToString()); 3377Assert.Equal(expected, json); 3419Assert.Equal(expected, json); 3435Assert.Equal(expected, json); 3454Assert.Equal(expected, json); 4849Assert.Equal(expected[i], schema[i].Name); 6575Assert.Equal("Softmax", schema[2].Name);

UnitTests\TestModelLoad.cs (5)

33Assert.Equal("Image", result.Schema[0].Name); 34Assert.Equal("Class", result.Schema[1].Name); 51Assert.Equal("Label", result.Schema[0].Name); 52Assert.Equal("Features", result.Schema[1].Name); 53Assert.Equal("Features", result.Schema[2].Name);

Common.cs (2)

110Assert.Equal(schemaPair.Item1.Name, schemaPair.Item2.Name); 156Assert.Equal(testType1.Tx.ToString(), testType2.Tx.ToString());

Debugging.cs (2)

140Assert.Equal("Label", column.Name); 142Assert.Equal(HousingRegression.Features[i - 1], column.Name);

DnnImageFeaturizerTest.cs (1)

243Assert.Equal("tomato", result.Prediction);

TestTransposer.cs (1)

73Assert.Equal(view.Schema[viewCol].Name, trans.Schema[col].Name);

TestSweeper.cs (8)

34Assert.Equal(name, value.Name); 35Assert.Equal(valueText, value.ValueText); 45Assert.Equal("5", unNormalizedValue.ValueText); 49Assert.Equal("5", param.ValueText); 61Assert.Equal(name, value.Name); 62Assert.Equal(valueText, value.ValueText); 86Assert.Equal("bla", value.Name); 87Assert.Equal(expected, value.ValueText);

TensorflowTests.cs (16)

591Assert.Equal("Placeholder", opType.ToString()); 602Assert.Equal("Identity", opType.ToString()); 608Assert.Equal("conv2d/kernel", inputOps.GetValues()[0].ToString()); 617Assert.Equal("Conv2D", opType.ToString()); 622Assert.Equal("reshape/Reshape", inputOps.GetValues()[0].ToString()); 623Assert.Equal("conv2d/Conv2D/ReadVariableOp", inputOps.GetValues()[1].ToString()); 632Assert.Equal("Softmax", opType.ToString()); 637Assert.Equal("sequential/dense_1/BiasAdd", inputOps.GetValues()[0].ToString()); 644Assert.Equal(name.ToString(), schema[i].Name); 1362Assert.Equal(input.A[i], textOutput.AOut[i]); 1363Assert.Equal(string.Join(" ", input.B).Replace("/", " "), textOutput.BOut[0]); 1392Assert.Equal("This is fine.Thank you very much!.", primitiveOutput.string_merge); 1583Assert.Equal("daisy", predictionFirst.PredictedLabel); 1584Assert.Equal("roses", predictionSecond.PredictedLabel); 1742Assert.Equal("daisy", predictionFirst.PredictedLabel); 1743Assert.Equal("roses", predictionSecond.PredictedLabel);

BaseTestBaseline.cs (1)

800Assert.Equal(expected.ToString(), actual.ToString());

DataPipe\Parquet.cs (1)

32Assert.Equal("Nullable object must have a value.", ex.Message);

DataPipe\TestDataPipe.cs (4)

1193Assert.Equal("Foo", view.Schema[0].Name); 1194Assert.Equal("Bar", view.Schema[1].Name); 1195Assert.Equal("Biz", view.Schema[2].Name); 1610Assert.Equal(ex.Message, string.Format("The specified documents are all empty in column '{0}'.", colName));

DataPipe\TestDataPipeBase.cs (1)

162Assert.Equal(p.Name, d.Name);

FakeSchemaTest.cs (3)

38Assert.Equal("A", columnA.Name); 42Assert.Equal("B", columnB.Name); 46Assert.Equal("C", columnC.Name);

ImagesTests.cs (3)

1238Assert.Equal(image1.Tag, image2.Tag); 1249Assert.Equal("image1", image1.Tag); 1251Assert.Equal("image2", image2.Tag);

OnnxConversionTest.cs (1)

1529Assert.Equal(mlNetSlotNames[j].ToString(), onnxSlotNames[j].ToString());

OnnxSequenceTypeWithAttributesTest.cs (1)

110Assert.Equal(expectedExceptionMessage, ex.Message.Substring(0, 387));

PermutationFeatureImportanceTests.cs (48)

Scenarios\Api\Estimators\PredictAndMetadata.cs (9)

54Assert.Equal("Iris-setosa", originalLabels.GetItemOrDefault(0).ToString()); 55Assert.Equal("Iris-versicolor", originalLabels.GetItemOrDefault(1).ToString()); 56Assert.Equal("Iris-virginica", originalLabels.GetItemOrDefault(2).ToString()); 95Assert.Equal("Iris-setosa", metrics.ConfusionMatrix.PredictedClassesIndicators[0].ToString()); 96Assert.Equal("Iris-versicolor", metrics.ConfusionMatrix.PredictedClassesIndicators[1].ToString()); 97Assert.Equal("Iris-virginica", metrics.ConfusionMatrix.PredictedClassesIndicators[2].ToString()); 129Assert.Equal("0", metrics2.ConfusionMatrix.PredictedClassesIndicators[0].ToString()); 130Assert.Equal("1", metrics2.ConfusionMatrix.PredictedClassesIndicators[1].ToString()); 131Assert.Equal("2", metrics2.ConfusionMatrix.PredictedClassesIndicators[2].ToString());

Scenarios\Api\TestApi.cs (1)

338Assert.Equal(col.Name, split.Schema[col.Index].Name);

TextLoaderTests.cs (18)

303Assert.Equal("This text contains comma, within quotes.", text.ToString()); 313Assert.Equal("This text contains extra punctuations and special characters.;*<>?!@#$%^&*()_+=-{}|[]:;'", text.ToString()); 323Assert.Equal("This text has no quotes", text.ToString()); 564Assert.Equal("There is a space at the end", text.ToString()); 574Assert.Equal("There is no space at the end", text.ToString()); 753Assert.Equal("SepalLength", previewIris.Schema[0].Name); 758Assert.Equal(entry.Key, previewIris.RowView[0].Values[index].Key); 761Assert.Equal("Type", previewIris.RowView[0].Values[index].Key); 762Assert.Equal("Iris-setosa", previewIris.RowView[0].Values[index].Value.ToString()); 774Assert.Equal("Features", previewIrisStartEnd.RowView[0].Values[0].Key); 851Assert.Equal("SepalLength", previewIris.Schema[0].Name); 856Assert.Equal(entry.Key, previewIris.RowView[0].Values[index].Key); 859Assert.Equal("Type", previewIris.RowView[0].Values[index].Key); 860Assert.Equal("Iris-setosa", previewIris.RowView[0].Values[index].Value.ToString()); 1352Assert.Equal(ids[i], line); 1359Assert.Equal(descriptions[i], line); 1365Assert.Equal(animals[i], line); 1559Assert.Equal(baselineDescription.ToString(), testDescription.ToString());

TrainerEstimators\TreeEnsembleFeaturizerTest.cs (9)

60Assert.Equal(treesColumnName, treeValuesColumn.Name); 71Assert.Equal("Tree000", slotNames.GetItemOrDefault(0).ToString()); 72Assert.Equal("Tree009", slotNames.GetItemOrDefault(9).ToString()); 78Assert.Equal(leavesColumnName, treeLeafIdsColumn.Name); 94Assert.Equal("Tree000Leaf000", leafIdsSlotNames.GetItemOrDefault(0).ToString()); 95Assert.Equal("Tree009Leaf004", leafIdsSlotNames.GetItemOrDefault(49).ToString()); 101Assert.Equal(pathsColumnName, treePathIdsColumn.Name); 117Assert.Equal("Tree000Node000", pathIdsSlotNames.GetItemOrDefault(0).ToString()); 118Assert.Equal("Tree009Node003", pathIdsSlotNames.GetItemOrDefault(39).ToString());

TrainerEstimators\TreeEstimators.cs (2)

821Assert.Equal("Tree node", row.IsLeaf); 844Assert.Equal("Leaf node", row.IsLeaf);

Transformers\CategoricalTests.cs (3)

146Assert.Equal("hello", slotNames.GetItemOrDefault(0).ToString()); 147Assert.Equal("my", slotNames.GetItemOrDefault(1).ToString()); 148Assert.Equal("friend", slotNames.GetItemOrDefault(2).ToString());

Transformers\ConvertTests.cs (3)

299Assert.Equal("hello", slotNames.GetItemOrDefault(0).ToString()); 300Assert.Equal("my", slotNames.GetItemOrDefault(1).ToString()); 301Assert.Equal("friend", slotNames.GetItemOrDefault(2).ToString());

Transformers\GroupUngroup.cs (16)

64Assert.Equal("Amy", grouped[0].UserName[0]); 65Assert.Equal("Willy", grouped[0].UserName[1]); 67Assert.Equal("Girl", grouped[0].Gender[0]); 68Assert.Equal("Boy", grouped[0].Gender[1]); 73Assert.Equal("Dori", grouped[1].UserName[0]); 74Assert.Equal("Ariel", grouped[1].UserName[1]); 76Assert.Equal("Fish", grouped[1].Gender[0]); 77Assert.Equal("Mermaid", grouped[1].Gender[1]); 94Assert.Equal("Amy", ungrouped[0].UserName); 95Assert.Equal("Girl", ungrouped[0].Gender); 98Assert.Equal("Willy", ungrouped[1].UserName); 99Assert.Equal("Boy", ungrouped[1].Gender); 102Assert.Equal("Dori", ungrouped[2].UserName); 103Assert.Equal("Fish", ungrouped[2].Gender); 106Assert.Equal("Ariel", ungrouped[3].UserName); 107Assert.Equal("Mermaid", ungrouped[3].Gender);

Transformers\LineParserTests.cs (2)

38Assert.Equal(expectedKey, result.key); 67Assert.Equal("word", result.key);

Transformers\NormalizerTests.cs (2)

646Assert.Equal("output", t.GetColumnPairs()[0].OutputColumnName); 647Assert.Equal("input", t.GetColumnPairs()[0].InputColumnName);

Transformers\SelectColumnsTests.cs (4)

188Assert.Equal("A", result.Schema[0].Name); 189Assert.Equal("B", result.Schema[1].Name); 208Assert.Equal("A", result.Schema[0].Name); 209Assert.Equal("B", result.Schema[1].Name);

Transformers\TextFeaturizerTests.cs (24)

Transformers\ValueMappingTests.cs (1)

792Assert.Equal(expectedCategories[i], feature.PriceCategory);

Transformers\WordTokenizeTests.cs (2)

75Assert.Equal(tokenizeA[i], nativeResult.TokenizeA[i]); 83Assert.Equal(tokenizeB[i], nativeResult.TokenizeB[i]);

TimeSeriesDirectApi.cs (5)

968Assert.Equal("DataCenter", rootCause.Items[0].Path[0]); 997Assert.Equal("DataCenter", preparedCauses[0].Items[0].Path[0]); 1013Assert.Equal("DeviceType", preparedCauses[1].Items[0].Path[0]); 1045Assert.Equal("DataCenter", rootCause.Items[0].Path[0]); 1195Assert.Equal("DataCenter", rootCause.Items[0].Path[0]);

BpeTests.cs (5)

266Assert.Equal(decodedTokens, tokenizer.Decode(encodingIds)); 267Assert.Equal(decodedTokensWithoutUnknownToken, bpe.Decode(encodingIds, considerSpecialTokens: false)); 276Assert.Equal(expectedTokens[i], encoding[i].Value); 280Assert.Equal(encoding[i].Value, reverseVocabulary[encodingIds[i]]); 320Assert.Equal(expectedDecoded, destinationBuffer.AsSpan().ToString());

CodeGenTests.cs (17)

EnglishRobertaTests.cs (5)

280Assert.Equal(expectedDecodedString, tokenizer.Decode(encodingIds)); 294Assert.Equal(filteredToken![i], reverseVocab[encodingIds[i]].Replace("\u0120", " ")); 298Assert.Equal(tokens[i], reverseVocab[encodingIds[i]]); 300Assert.Equal(unfilteredToken![i], reverseVocab[encodingIds[i]]); 331Assert.Equal(expectedDecoded, destinationBuffer.AsSpan().ToString());

LlamaTests.cs (59)

NormalizerTests.cs (2)

62Assert.Equal(normalized, normalizedText); 66Assert.Equal(normalized, normalizedString);

TitokenTests.cs (12)

139Assert.Equal(text, tokenizer.Decode(encoded)!); 183Assert.Equal(expectedDecoded, destinationBuffer.AsSpan().ToString()); 192Assert.Equal(text, GPT4.Decode(encoded)); 223Assert.Equal(text, gpt4Tokenizer.Decode(encoded)); 235Assert.Equal(text, GPT4.Decode(encoded)); 270Assert.Equal(text, GPT4.Decode(encoded)); 296Assert.Equal(text, GPT4o.Decode(encoded)); 304Assert.Equal(text, GPT4o.Decode(encoded)); 332Assert.Equal(text, GPT2.Decode(encoded)); 351Assert.Equal(text, P50kBase.Decode(encoded)); 370Assert.Equal(text, P50kEdit.Decode(encoded)); 389Assert.Equal(text, R50kBase.Decode(encoded));

TokenizerTests.cs (1)

24Assert.Equal(

NerTests.cs (6)

76Assert.Equal("outputColumn", estimatorSchema[2].Name); 83Assert.Equal("outputColumn", transformerSchema[4].Name); 155Assert.Equal("outputColumn", estimatorSchema[2].Name); 162Assert.Equal("outputColumn", transformerSchema[4].Name); 229Assert.Equal("outputColumn", estimatorSchema[2].Name); 263Assert.Equal("outputColumn", transformerSchema[4].Name);

QATests.cs (4)

47Assert.Equal("Answer", estimatorSchema[4].Name); 48Assert.Equal("Score", estimatorSchema[5].Name); 56Assert.Equal("Answer", transformerSchema[4].Name); 57Assert.Equal("Score", transformerSchema[5].Name);

TextClassificationTests.cs (8)

105Assert.Equal("outputColumn", estimatorSchema[3].Name); 114Assert.Equal("outputColumn", transformerSchema[3].Name); 243Assert.Equal("outputColumn", estimatorSchema[3].Name); 250Assert.Equal("outputColumn", transformerSchema[4].Name); 327Assert.Equal("outputColumn", estimatorSchema[3].Name); 334Assert.Equal("outputColumn", transformerSchema[5].Name); 393Assert.Equal("Score", estimatorSchema[3].Name); 400Assert.Equal("Score", estimatorSchema[3].Name);

CacheControlHeaderValueTest.cs (19)

ContentDispositionHeaderValueTest.cs (9)

ContentRangeHeaderValueTest.cs (3)

91Assert.Equal("myunit 1-2/3", range.ToString()); 94Assert.Equal("bytes 123456789012345678-123456789012345679/*", range.ToString()); 97Assert.Equal("bytes */150", range.ToString());

CookieHeaderValueTest.cs (3)

204Assert.Equal(expectedValue, input.ToString()); 214Assert.Equal(expectedValue, header.ToString()); 224Assert.Equal(expectedValue, header!.ToString());

DateParserTest.cs (2)

45Assert.Equal("Sat, 31 Jul 2010 15:38:57 GMT", 48Assert.Equal("Fri, 01 Jan 2010 01:01:01 GMT",

EntityTagHeaderValueTest.cs (3)

51Assert.Equal("\"e tag\"", etag.ToString()); 54Assert.Equal("W/\"e tag\"", etag.ToString()); 57Assert.Equal("\"\"", etag.ToString());

HeaderUtilitiesTest.cs (3)

21Assert.Equal(expected, actual); 106Assert.Equal(value.ToString(CultureInfo.InvariantCulture), HeaderUtilities.FormatNonNegativeInt64(value)); 128Assert.Equal(value.ToString(CultureInfo.InvariantCulture), HeaderUtilities.FormatInt64(value));

MediaTypeHeaderValueTest.cs (4)

330Assert.Equal("text/plain", mediaType.ToString()); 333Assert.Equal("text/plain; charset=utf-8", mediaType.ToString()); 336Assert.Equal("text/plain; charset=utf-8; custom=\"custom value\"", mediaType.ToString()); 339Assert.Equal("text/plain; custom=\"custom value\"", mediaType.ToString());

NameValueHeaderValueTest.cs (4)

153Assert.Equal("text=token", nameValue.ToString()); 156Assert.Equal("text=\"quoted string\"", nameValue.ToString()); 159Assert.Equal("text", nameValue.ToString()); 162Assert.Equal("text", nameValue.ToString());

RangeConditionHeaderValueTest.cs (2)

42Assert.Equal("\"x\"", rangeCondition.ToString()); 45Assert.Equal("Thu, 15 Jul 2010 12:33:57 GMT", rangeCondition.ToString());

RangeHeaderValueTest.cs (2)

34Assert.Equal("myunit=1-3", range.ToString()); 38Assert.Equal("myunit=1-3, 5-, -17", range.ToString());

RangeItemHeaderValueTest.cs (3)

45Assert.Equal("1000000000-2000000000", rangeItem.ToString()); 48Assert.Equal("5-", rangeItem.ToString()); 51Assert.Equal("-10", rangeItem.ToString());

SetCookieHeaderValueTest.cs (4)

350Assert.Equal(expectedValue, input.ToString()); 361Assert.Equal(expectedValue, builder.ToString()); 371Assert.Equal(expectedValue, header.ToString()); 381Assert.Equal(expectedValue, header!.ToString());

StringWithQualityHeaderValueTest.cs (5)

39Assert.Equal("token", value.ToString()); 42Assert.Equal("token; q=0.1", value.ToString()); 45Assert.Equal("token; q=0.0", value.ToString()); 48Assert.Equal("token; q=1.0", value.ToString()); 52Assert.Equal("token; q=0.568", value.ToString());

Microsoft\VisualBasic\ApplicationServices\ApplicationBaseTests.cs (4)

18Assert.Equal("en-US", app.Culture.Name); 36Assert.Equal("en-US", app.UICulture.Name); 50Assert.Equal(value, app.GetEnvironmentVariable(key)); 82Assert.Equal(assemblyName.Name, app.Info.AssemblyName);

Microsoft\VisualBasic\ApplicationServices\AssemblyInfoTests.cs (8)

22Assert.Equal(assemblyName.Name, assemblyInfo.AssemblyName); 23Assert.Equal(Path.GetDirectoryName(assembly.Location), assemblyInfo.DirectoryPath); 24Assert.Equal(GetAttributeValue<AssemblyCompanyAttribute>(assembly, attr => attr.Company), assemblyInfo.CompanyName); 25Assert.Equal(GetAttributeValue<AssemblyCopyrightAttribute>(assembly, attr => attr.Copyright), assemblyInfo.Copyright); 26Assert.Equal(GetAttributeValue<AssemblyDescriptionAttribute>(assembly, attr => attr.Description), assemblyInfo.Description); 27Assert.Equal(GetAttributeValue<AssemblyProductAttribute>(assembly, attr => attr.Product), assemblyInfo.ProductName); 28Assert.Equal(GetAttributeValue<AssemblyTitleAttribute>(assembly, attr => attr.Title), assemblyInfo.Title); 29Assert.Equal(GetAttributeValue<AssemblyTrademarkAttribute>(assembly, attr => attr.Trademark), assemblyInfo.Trademark);

Microsoft\VisualBasic\ApplicationServices\UserTests.cs (1)

15Assert.Equal(System.Threading.Thread.CurrentPrincipal.Identity.Name, user.Name);

Microsoft\VisualBasic\ApplicationServices\WindowsFormsApplicationBaseTests.cs (4)

23Assert.Equal(expectedId, GetAppID(assembly)); 42Assert.Equal($"{guid}1.2", GetUniqueIDFromAssembly(guid, new Version(1, 2, 3, 4))); 49Assert.Equal($"{guid}0.0", GetUniqueIDFromAssembly(guid, new Version())); 56Assert.Equal($"{guid}0.0", GetUniqueIDFromAssembly(guid, version: null));

Microsoft\VisualBasic\Devices\ComputerInfoTests.cs (3)

13Assert.Equal(System.Environment.OSVersion.Platform.ToString(), info.OSPlatform); 14Assert.Equal(System.Environment.OSVersion.Version.ToString(), info.OSVersion); 43Assert.Equal(System.Runtime.InteropServices.RuntimeInformation.OSDescription, fullName);

Microsoft\VisualBasic\Devices\ServerComputerTests.cs (1)

13Assert.Equal(System.Environment.MachineName, computer.Name);

Microsoft\VisualBasic\MyServices\FileSystemProxyTests.cs (19)

Microsoft\VisualBasic\MyServices\Internal\ContextValueTests.cs (2)

41Assert.Equal("World", context.Value); 45Assert.Equal("Hello", context.Value);

Microsoft\VisualBasic\MyServices\SpecialDirectoriesProxyTests.cs (1)

38Assert.Equal(expected, actual);

CodeModel\FileCodeClassTests.cs (2)

71Assert.Equal("Goo", parentClass.FullName); 90Assert.Equal("Goo", parentClass.FullName);

CodeModel\FileCodeFunctionTests.cs (16)

138Assert.Equal("A.MethodD", testObject.FullName); 210Assert.Equal("MethodC", testObject.Name); 228Assert.Equal("A", ((CodeClass)testObject.Parent).FullName); 236Assert.Equal("System.Int32", testObject.Type.AsFullName); 246Assert.Equal(expected, testObject.Comment); 256Assert.Equal(expected, testObject.DocComment); 474Assert.Equal("dynamic", returnType.AsFullName); 475Assert.Equal("dynamic", returnType.AsString); 476Assert.Equal("System.Object", returnType.CodeType.FullName); 486Assert.Equal("dynamic", returnType.AsFullName); 487Assert.Equal("dynamic", returnType.AsString); 488Assert.Equal("System.Object", returnType.CodeType.FullName); 502Assert.Equal("DynamicMethod", element.Name); 518Assert.Equal("A", element.Name); 525Assert.Equal("operator +", functionObject.Name); 533Assert.Equal("implicit operator Ref<T>", element.Name);

CodeModel\FileCodeImportTests.cs (2)

58Assert.Equal("System", import.Namespace); 66Assert.Equal("Goo", import.Alias);

CodeModel\FileCodeNamespaceTests.cs (4)

77Assert.Equal(outer.Name, ((CodeNamespace)inner.Parent).Name); 93Assert.Equal("Goo", testObject.Name); 101Assert.Equal("A.B", testObject.Name); 294Assert.Equal(CodeModelLanguageConstants.vsCMLanguageCSharp, testObject.Language);

CodeModel\FileCodeVariableManipulationTests.cs (1)

31Assert.Equal(@"class Goo

CodeModel\FileCodeVariableTests.cs (4)

96Assert.Equal("This is a comment.\r\n", testObject.Comment); 106Assert.Equal(expected, testObject.DocComment); 180Assert.Equal("A", testObjectParent.Name); 188Assert.Equal("System.Int32", testObject.Type.AsFullName);

Interactive\Commands\InteractiveCommandHandlerTests.cs (1)

168Assert.Equal(expectedBufferText, workspace.WindowCurrentLanguageBuffer.CurrentSnapshot.GetText());

PersistentStorage\AbstractPersistentStorageTests.cs (38)

ProjectSystemShim\CPS\AdditionalPropertiesTests.cs (1)

35Assert.Equal(rootNamespace, DefaultNamespaceOfSingleProject(environment));

ProjectSystemShim\CPS\CSharpCompilerOptionsTests.cs (5)

146Assert.Equal("Test", project.DisplayName); 152Assert.Equal(newProjectDisplayName, project.DisplayName); 153Assert.Equal(initialProjectFilePath, project.ProjectFilePath); 172Assert.Equal(newFilePath, project.ProjectFilePath); 173Assert.Equal(initialProjectDisplayName, project.DisplayName);

ProjectSystemShim\LegacyProject\CSharpCompilerOptionsTests.cs (11)

110Assert.Equal(initialPath, project.GetOutputFileName()); 115Assert.Equal(initialPath, getCurrentCompilationOutputAssemblyPath()); 120Assert.Equal(newPath, project.GetOutputFileName()); 122Assert.Equal(newPath, getCurrentCompilationOutputAssemblyPath()); 127Assert.Equal(newPath, project.GetOutputFileName()); 129Assert.Equal(newPath, getCurrentCompilationOutputAssemblyPath()); 134Assert.Equal(newPath, project.GetOutputFileName()); 136Assert.Equal(newPath, getCurrentCompilationOutputAssemblyPath()); 157Assert.Equal(@"C:\a\2.dll", getCurrentCompilationOutputAssemblyPath()); 161Assert.Equal(@"C:\a\3.dll", getCurrentCompilationOutputAssemblyPath()); 165Assert.Equal(@"C:\a\3.dll", getCurrentCompilationOutputAssemblyPath());

ProjectSystemShim\VisualStudioCompilationOutputFilesTests.cs (2)

63Assert.Equal("lib", mdReader.GetString(mdReader.GetAssemblyDefinition().Name)); 102Assert.Equal("lib", mdReader.GetString(mdReader.GetAssemblyDefinition().Name));

UnifiedSettings\CSharpUnifiedSettingsTests.cs (2)

110Assert.Equal("C#", actual: categoriesTitle.ToString()); 112Assert.Equal(Guids.CSharpOptionPageIntelliSenseIdString, optionPageId!.ToString());

InsertOrAppendAttributeTests.cs (24)

TopLevelParameterNameAnalyzerTest.cs (4)

442Assert.Equal("testModelName", name); 467Assert.Equal("param", name); 491Assert.Equal("param", name); 515Assert.Equal("name1", name);

ApiActionsDoNotRequireExplicitModelValidationCheckAnalyzerIntegrationTest.cs (1)

77Assert.Equal(descriptor.Id, diagnostic.Id);

ApiConventionAnalyzerIntegrationTest.cs (2)

293Assert.Equal(descriptor.Id, diagnostic.Id); 296Assert.Equal(string.Format(CultureInfo.InvariantCulture, descriptor.MessageFormat.ToString(CultureInfo.InvariantCulture), args), diagnostic.GetMessage(CultureInfo.InvariantCulture));

Reader\MockSymUnmanagedReader.cs (1)

61Assert.Equal("MD2", name);

Reader\PdbValidation.cs (2)

578Assert.Equal(pdbPath, codeViewData.Path); 612Assert.Equal(hashAlgorithm.Name, pdbChecksumData.AlgorithmName);

Remote\SnapshotSerializationTests.cs (2)

627Assert.Equal(sourceText.ToString(), newText.GetText(CancellationToken.None).ToString()); 645Assert.Equal(sourceText.ToString(), newText.GetText(CancellationToken.None).ToString());

Services\ServiceHubServicesTests.cs (18)

Services\SolutionServiceTests.cs (7)

268Assert.Equal("Name" + version, project.Name); 269Assert.Equal("AssemblyName" + version, project.AssemblyName); 270Assert.Equal("FilePath" + version, project.FilePath); 271Assert.Equal("OutputFilePath" + version, project.OutputFilePath); 272Assert.Equal("OutputRefFilePath" + version, project.OutputRefFilePath); 273Assert.Equal("AssemblyPath" + version, project.CompilationOutputInfo.AssemblyPath); 274Assert.Equal("DefaultNamespace" + version, project.DefaultNamespace);

Https\HttpsTests.4.1.0.cs (5)

258Assert.Equal(testString, result); 299Assert.Equal(testString, result); 387Assert.Equal(testString, result); 497Assert.Equal(testString, result); 561Assert.Equal(testString, result);

Https\HttpsTests.4.1.1.cs (3)

51Assert.Equal(testString, result); 160Assert.Equal(testString, result); 205Assert.Equal(testString, result);

Negotiate\NegotiateStream_Http_Tests.4.1.0.cs (7)

93Assert.Equal(testString, result); 145Assert.Equal(testString, result); 197Assert.Equal(testString, result); 245Assert.Equal(testString, result); 289Assert.Equal(testString, result); 345Assert.Equal(testString, result); 395Assert.Equal(testString, result);

Negotiate\NegotiateStream_Tcp_Tests.4.1.0.cs (6)

79Assert.Equal(testString, result); 128Assert.Equal(testString, result); 173Assert.Equal(testString, result); 214Assert.Equal(testString, result); 269Assert.Equal(testString, result); 316Assert.Equal(testString, result);

Tcp\ClientCredentialTypeCertificateCanonicalNameTests.4.1.0.cs (3)

55Assert.Equal(testString, result); 131Assert.Equal(testString, result); 217Assert.Equal(testString, result);

Tcp\ClientCredentialTypeTests.4.1.0.cs (3)

51Assert.Equal(testString, result); 104Assert.Equal(testString, result); 146Assert.Equal(testString, result);

Tcp\ClientCredentialTypeTests.4.1.1.cs (3)

51Assert.Equal(testString, result); 158Assert.Equal(testString, result); 205Assert.Equal(testString, result);

Tcp\ClientCredentialTypeTests.OSX.cs (1)

78Assert.Equal(testString, result);

Tcp\IdentityTests.4.1.0.cs (1)

37Assert.Equal(testString, result);

Tcp\IdentityTests.4.1.1.cs (1)

39Assert.Equal(testString, result);

Tcp\StreamingTests.4.1.0.cs (4)

48Assert.Equal(testString, result); 89Assert.Equal(testString, result); 131Assert.Equal(testString, result); 182Assert.Equal(testString, result);

HelloWorldTest.cs (4)

74Assert.Equal($"Hello World {expectedName}", responseText); 88Assert.Equal("Microsoft-HTTPAPI/2.0", serverHeader); 94Assert.Equal("Kestrel", serverHeader); 100Assert.Equal("Kestrel", serverHeader);

NtlmAuthenticationTest.cs (3)

59Assert.Equal("Hello World", responseText); 64Assert.Equal("Anonymous?True", responseText); 93Assert.Equal("Authenticated", responseText);

ResponseCompressionTests.cs (5)

150Assert.Equal("Running", responseText); 173Assert.Equal(HelloWorldBody, responseText); 174Assert.Equal(HelloWorldBody.Length.ToString(CultureInfo.InvariantCulture), GetContentLength(response)); 206Assert.Equal(HelloWorldBody, responseText); 208Assert.Equal("gzip", response.Content.Headers.ContentEncoding.First());

ResponseTests.cs (8)

112Assert.Equal("Running", responseText); 138Assert.Equal("Content Length", responseText); 141Assert.Equal("14", GetContentLength(response)); 158Assert.Equal("Connnection Close", responseText); 183Assert.Equal("Connnection Close", responseText); 208Assert.Equal("Chunked", responseText); 233Assert.Equal("Manually Chunked", responseText); 253Assert.Equal("Manually Chunked and Close", responseText);

Data.Validation\LengthAttributeTests.cs (2)

396Assert.Equal("My custom message for 'CustomMessage'.", results.Single().ErrorMessage); 416Assert.Equal("The field DefaultMessage length must be greater or equal than 5.", results.Single().ErrorMessage);

Throw\DoubleTests.cs (18)

Throw\IntegerTests.cs (26)

Throw\LongTests.cs (26)

Throw\ThrowTest.cs (35)

src\Servers\Kestrel\shared\test\StreamBackedTestConnection.cs (2)

126Assert.Equal(expected, actualText); 135Assert.Equal("", text);

src\Servers\Kestrel\test\BindTests\AddressRegistrationTests.cs (21)

217Assert.Equal(uri.ToString(), response); 264Assert.Equal(expectedUrl, response); 337Assert.Equal(new Uri(testUrlWithPort).ToString(), response); 392Assert.Equal(new Uri(testUrl).ToString(), response); 439Assert.Equal(new Uri(testUrl).ToString(), response); 526Assert.Equal(new Uri(address).ToString(), await HttpClientSlim.GetStringAsync(address, validateCertificate: false)); 558Assert.Equal(expectedMessage, exception.Message); 593Assert.Equal(expectedMessage, exception.Message); 635Assert.Equal(serverAddresses.First(), useUrlsAddressWithPort); 641Assert.Equal(new Uri(useUrlsAddressWithPort).ToString(), await HttpClientSlim.GetStringAsync(useUrlsAddressWithPort)); 680Assert.Equal(serverAddresses.First(), endPointAddress); 686Assert.Equal(new Uri(endPointAddress).ToString(), await HttpClientSlim.GetStringAsync(endPointAddress, validateCertificate: false)); 720Assert.Equal(serverAddresses.First(), endPointAddress); 722Assert.Equal(new Uri(endPointAddress).ToString(), await HttpClientSlim.GetStringAsync(endPointAddress, validateCertificate: false)); 811Assert.Equal(endPointAddress, await HttpClientSlim.GetStringAsync(endPointAddress)); 831Assert.Equal(endPointAddress, await HttpClientSlim.GetStringAsync(endPointAddress)); 862Assert.Equal(ipv4endPointAddress, await HttpClientSlim.GetStringAsync(ipv4endPointAddress)); 863Assert.Equal(ipv6endPointAddress, await HttpClientSlim.GetStringAsync(ipv6endPointAddress)); 884Assert.Equal(ipv4endPointAddress, await HttpClientSlim.GetStringAsync(ipv4endPointAddress)); 885Assert.Equal(ipv6endPointAddress, await HttpClientSlim.GetStringAsync(ipv6endPointAddress)); 986Assert.Equal(CoreStrings.FormatEndpointAlreadyInUse(thisAddressString), exception.Message);

src\Servers\Kestrel\shared\test\MetricsAssert.cs (1)

14Assert.Equal(KestrelMetrics.GetErrorType(expectedReason), errorType);

src\Servers\Kestrel\shared\test\StreamBackedTestConnection.cs (2)

126Assert.Equal(expected, actualText); 135Assert.Equal("", text);

src\Servers\Kestrel\test\FunctionalTests\Http2\HandshakeTests.cs (3)

61Assert.Equal("HTTP/2 over TLS is not supported on Windows 7 due to missing ALPN support.", ex.Message); 88Assert.Equal("hello world HTTP/2", result); 116Assert.Equal("hello world HTTP/2", result);

src\Servers\Kestrel\test\FunctionalTests\Http2\ShutdownTests.cs (2)

93Assert.Equal("hello world HTTP/2", response); 154Assert.Equal("hello world HTTP/2", await requestTask);

src\Servers\Kestrel\test\FunctionalTests\RequestTests.cs (1)

1130Assert.Equal(expectAddress, facts["RemoteIPAddress"].Value<string>());

src\Servers\Kestrel\test\FunctionalTests\ResponseTests.cs (1)

139Assert.Equal(headers.GetValues(headerName).Single(), expectedValue);

Design\CategoryNameCollectionTests.cs (1)

35Assert.Equal(expectedValue, sourceCollection[i]);

mono\System.Drawing\BitmapTests.cs (7)

451Assert.Equal("7256C44FB1450981DADD4CA7D0B8E94E8EC8A76D1D6F1839A8B5DB237DDD852D", RotateBmp(bmp, RotateFlipType.Rotate90FlipNone)); 452Assert.Equal("D90EDBC221EF524E98D23B8E2B32AECBCEF14FCE5E402E602AFCCBAF0DC581B1", RotateBmp(bmp, RotateFlipType.Rotate180FlipNone)); 453Assert.Equal("9110140D17122EC778F5861ED186C28E839FA218955BFA088A5801DDFDF420DE", RotateBmp(bmp, RotateFlipType.Rotate270FlipNone)); 454Assert.Equal("29B195F4387B399930BAA50399B0F98EEA8115147FF47A4088E9DA7D29B48DF1", RotateBmp(bmp, RotateFlipType.RotateNoneFlipX)); 455Assert.Equal("27D1EA173316A50C9F4186BBA03F4EFE78C1D5FEBC4D973EB9ED87620930AB89", RotateBmp(bmp, RotateFlipType.Rotate90FlipX)); 456Assert.Equal("1687AFD5202BCF470B91AFA2E6A43793FA316679B0CE4EB1BC956B230A063A5C", RotateBmp(bmp, RotateFlipType.Rotate180FlipX)); 457Assert.Equal("297D4E905D773277CEA86276B15AC70EB02BE4B7FE06120330DABBE92D1DF4E2", RotateBmp(bmp, RotateFlipType.Rotate270FlipX));

mono\System.Drawing\GraphicsTests.cs (1)

352Assert.Equal("image", argumentException.ParamName);

System\Drawing\ColorTranslatorTests.cs (2)

212Assert.Equal("htmlColor", argumentException.ParamName); 258Assert.Equal(expected, ColorTranslator.ToHtml(color));

System\Drawing\FontConverterTests.cs (4)

20Assert.Equal("Times New Roman", converter.ConvertFrom("Times") as string); 24Assert.Equal("Times", converter.ConvertFrom("Times") as string); 52Assert.Equal(expectedName, font.Name); 124Assert.Equal(font.Name, newFont.Name);

System\Drawing\FontFamilyTests.cs (9)

20Assert.Equal(expectedName, fontFamily.Name); 31Assert.Equal(expectedName, fontFamily.Name); 41Assert.Equal("Code New Roman", fontFamily.Name); 108Assert.Equal(families[i].Name, familiesWithGraphics[i].Name); 114Assert.Equal(fontFamily.Name, copy.Name); 125Assert.Equal("Courier New", fontFamily2.Name); 134Assert.Equal("Microsoft Sans Serif", fontFamily2.Name); 143Assert.Equal("Times New Roman", fontFamily2.Name); 225Assert.Equal(expectedName, fontFamily.GetName(languageCode));

System\Drawing\FontTests.cs (9)

301Assert.Equal(family.Name, font.Name); 302Assert.Equal($"@{family.Name}", font.OriginalFontName); 320Assert.Equal(family.Name, copy.Name); 399Assert.Equal(font.Name, clone.FontFamily.Name); 722Assert.Equal($"{expectedNamePrefix}{family.Name}", logFont.lfFaceName); 756Assert.Equal(family.Name, logFont.lfFaceName); 820Assert.Equal(font.Name, newFont.Name); 853Assert.Equal($"[Font: Name={family.Name}, Size=10, Units=4, GdiCharSet=10, GdiVerticalFont=True]", font.ToString()); 858Assert.Equal(expectedName, font.Name);

System\Drawing\GraphicsTests.cs (1)

270Assert.Equal("image", argumentException.ParamName);

System\Drawing\IconConverterTests.cs (8)

135Assert.Equal(_iconStr, (string)_icoConv.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(string))); 136Assert.Equal(_iconStr, (string)_icoConv.ConvertTo(_icon, typeof(string))); 152Assert.Equal(_iconStr, (string)_icoConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(string))); 153Assert.Equal(_iconStr, (string)_icoConvFrmTD.ConvertTo(_icon, typeof(string))); 171Assert.Equal("(none)", (string)_icoConv.ConvertTo(null, typeof(string))); 172Assert.Equal("(none)", (string)_icoConv.ConvertTo(null, CultureInfo.CreateSpecificCulture("ru-RU"), null, typeof(string))); 174Assert.Equal("(none)", (string)_icoConvFrmTD.ConvertTo(null, typeof(string))); 175Assert.Equal("(none)", (string)_icoConvFrmTD.ConvertTo(null, CultureInfo.CreateSpecificCulture("de-DE"), null, typeof(string)));

System\Drawing\ImageConverterTests.cs (8)

157Assert.Equal(_imageStr, (string)_imgConv.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(string))); 158Assert.Equal(_imageStr, (string)_imgConv.ConvertTo(_image, typeof(string))); 159Assert.Equal(_imageStr, (string)_imgConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(string))); 160Assert.Equal(_imageStr, (string)_imgConvFrmTD.ConvertTo(_image, typeof(string))); 164Assert.Equal("(none)", (string)_imgConv.ConvertTo(null, typeof(string))); 165Assert.Equal("(none)", (string)_imgConv.ConvertTo(null, CultureInfo.CreateSpecificCulture("ru-RU"), null, typeof(string))); 167Assert.Equal("(none)", (string)_imgConvFrmTD.ConvertTo(null, typeof(string))); 168Assert.Equal("(none)", (string)_imgConvFrmTD.ConvertTo(null, CultureInfo.CreateSpecificCulture("de-DE"), null, typeof(string)));

System\Drawing\ImageFormatConverterTests.cs (8)

System\Drawing\ImageTests.cs (17)

System\Drawing\Imaging\FrameDimensionTests.cs (1)

74Assert.Equal(expected, imageFormat.ToString());

System\Drawing\Imaging\ImageCodecInfoTests.cs (4)

98Assert.Equal(DllName, codecInfo.DllName); 107Assert.Equal(mask, BitConverter.ToString(codecInfo.SignatureMasks[i])); 111Assert.Equal(pattern, BitConverter.ToString(codecInfo.SignaturePatterns[0])); 113Assert.Equal(pattern2, BitConverter.ToString(codecInfo.SignaturePatterns[1]));

System\Drawing\Imaging\ImageFormatTests.cs (2)

99Assert.Equal(expected, imageFormat.ToString()); 107Assert.Equal(expected, img.RawFormat.ToString());

System\Drawing\Printing\MarginsConverterTests.cs (2)

143Assert.Equal(string.Empty, (string)mc.ConvertTo(null, typeof(string))); 144Assert.Equal(string.Empty, (string)mc.ConvertTo(context, CultureInfo.CreateSpecificCulture("ru-RU"), null, typeof(string)));

System\Drawing\Printing\MarginsTests.cs (1)

137Assert.Equal(expected, margins.ToString());

System\Drawing\Printing\PageSettingsTests.cs (2)

52Assert.Equal(ps.PaperSize.PaperName, clone.PaperSize.PaperName); 64Assert.Equal(ps.PaperSource.SourceName, clone.PaperSource.SourceName);

System\Drawing\Printing\PaperSizeTests.cs (4)

53Assert.Equal(name, size.PaperName); 138Assert.Equal(value, size.PaperName); 142Assert.Equal(value, size.PaperName); 228Assert.Equal(expected, size.ToString());

System\Drawing\Printing\PaperSourceTests.cs (2)

86Assert.Equal(value, source.SourceName); 90Assert.Equal(value, source.SourceName);

System\Drawing\Printing\PrintDocumentTests.cs (4)

42Assert.Equal("document", document.DocumentName); 73Assert.Equal(documentName, document.DocumentName); 81Assert.Equal(string.Empty, document.DocumentName); 229Assert.Equal(expected, document.ToString());

System\Drawing\Printing\PrinterResolutionTests.cs (1)

97Assert.Equal(expected, resolution.ToString());

System\Drawing\Printing\PrinterSettingsTests.cs (4)

272Assert.Equal(printFileName, printerSettings.PrintFileName); 351Assert.Equal(printerName, printerSettings.PrinterName); 597Assert.Equal(newPrinterSettings.PrinterName, printerSettings.PrinterName); 616Assert.Equal(expected, printerSettings.ToString());

System\Drawing\StringFormatTests.cs (1)

423Assert.Equal("[StringFormat, FormatFlags=DirectionVertical]", format.ToString());

System\Drawing\SystemFontsTests.cs (3)

31Assert.Equal(font.Name, otherFont.Name); 84Assert.Equal(systemFontName, font.SystemFontName); 89Assert.Equal(windowsFontName, font.Name);

System\Drawing\Text\PrivateFontCollectionTests.cs (6)

31Assert.Equal("Code New Roman", fontFamily.Name); 48Assert.Equal("Code New Roman", fontFamily.Name); 65Assert.Equal("Code New Roman", fontFamily.Name); 85Assert.Equal("Code New Roman", fontFamily.Name); 86Assert.Equal("Bonjour", fontFamily.GetName(FrenchLCID)); 147Assert.Equal("Code New Roman", font.Name);

WSTrustChannelSecurityTokenProviderTest.cs (5)

67Assert.Equal(claims.Dialect, trustRequest.Claims.Dialect); 70Assert.Equal(claimUri, ctype.Uri); 71Assert.Equal(claimValue, ctype.Value); 74Assert.Equal(eln1, trustRequest.AdditionalXmlElements[0].Name); 75Assert.Equal(eln2, trustRequest.AdditionalXmlElements[1].Name);

Channels\HttpRequestMessagePropertyTest.cs (8)

19Assert.Equal("POST", requestMsgProperty.Method); 20Assert.Equal(string.Empty, requestMsgProperty.QueryString); 41Assert.Equal(original.QueryString, copy.QueryString); 42Assert.Equal(original.Method, copy.Method); 45Assert.Equal(original.Headers[testKeyName], copy.Headers[testKeyName]); 51Assert.Equal("httpRequest", HttpRequestMessageProperty.Name); 60Assert.Equal(newMethod, requestMsgProperty.Method); 76Assert.Equal(newQueryString, requestMsgProperty.QueryString);

ServiceModel\BasicHttpBindingTest.cs (14)

23Assert.Equal("BasicHttpBinding", binding.Name); 24Assert.Equal("http://tempuri.org/", binding.Namespace); 25Assert.Equal("http", binding.Scheme); 27Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 48Assert.Equal("BasicHttpBinding", binding.Name); 49Assert.Equal("http://tempuri.org/", binding.Namespace); 50Assert.Equal("https", binding.Scheme); 52Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 72Assert.Equal("BasicHttpBinding", binding.Name); 73Assert.Equal("http://tempuri.org/", binding.Namespace); 74Assert.Equal("http", binding.Scheme); 76Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 168Assert.Equal(value, binding.Name); 188Assert.Equal(value, binding.Namespace);

ServiceModel\BasicHttpsBindingTest.cs (10)

21Assert.Equal("BasicHttpsBinding", binding.Name); 22Assert.Equal("http://tempuri.org/", binding.Namespace); 23Assert.Equal("https", binding.Scheme); 25Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 46Assert.Equal("BasicHttpsBinding", binding.Name); 47Assert.Equal("http://tempuri.org/", binding.Namespace); 48Assert.Equal("https", binding.Scheme); 50Assert.Equal(Encoding.GetEncoding("utf-8").WebName, binding.TextEncoding.WebName); 156Assert.Equal(value, binding.Name); 176Assert.Equal(value, binding.Namespace);

Channels\TcpConnectionPoolSettingsTest.cs (1)

23Assert.Equal(groupName, settings.GroupName);

ServiceModel\NetTcpBindingTest.cs (1)

25Assert.Equal("net.tcp", binding.Scheme);

Channels\CustomBindingTest.cs (1)

47Assert.Equal(bindingName, actualBindingName);

Channels\MessageTest.cs (11)

29Assert.Equal(s_action, message.Headers.Action); 41Assert.Equal(s_action, message.Headers.Action); 47Assert.Equal(content, messageBody); 56Assert.Equal(s_action, message.Headers.Action); 62Assert.Equal(string.Empty, messageBody); 78Assert.Equal(expected, actual); 91Assert.Equal(s_action, message.Headers.Action); 96Assert.Equal(faultReason, msgFault.Reason.GetMatchingTranslation().Text); 101Assert.Equal(s_action, message.Headers.Action); 106Assert.Equal(faultReason, msgFault.Reason.GetMatchingTranslation().Text); 110Assert.Equal(((FaultDetail)faultDetail).Message, msgFDetail.Message);

Description\ContractDescriptionTest.cs (2)

202Assert.Equal(typeof(IDescriptionTestsService).Name, contractDescription.ContractType.Name); 203Assert.Equal("http://tempuri.org/", contractDescription.Namespace);

Description\OperationBehaviorTest.cs (3)

84Assert.Equal("Rpc", serializerBehavior.XmlSerializerFormatAttribute.Style.ToString()); 88Assert.Equal("Document", serializerBehavior.XmlSerializerFormatAttribute.Style.ToString()); 119Assert.Equal(obj.Members[i].Name, deserialized.Members[i].Name);

IdentityModel\SecurityTokenProviderTest.cs (27)

Security\SecurityNegotiationExceptionTest.cs (2)

24Assert.Equal(exceptionMessage, exception2.Message); 27Assert.Equal(exceptionMessage, exception3.InnerException.Message);

Security\SecurityTokenRequirementTest.cs (2)

20Assert.Equal(NetValue, tokenrequirement.TokenType); 30Assert.Equal(value, tokenrequirement.TokenType);

ServiceModel\ChannelFactoryTest.cs (3)

49Assert.Equal(toStringExpected, toStringResult); 106Assert.Equal(toStringExpected, toStringResult); 159Assert.Equal(toStringExpected, toStringResult);

ServiceModel\DuplexChannelFactoryTest.cs (1)

239Assert.Equal(toStringExpected, toStringResult);

ServiceModel\FaultExceptionTest.cs (22)

50Assert.Equal(netfxBsl, sr.ReadToEnd()); 54Assert.Equal("Fault Message", faultException.Detail.Message); 71Assert.Equal(netfxBsl, sr.ReadToEnd()); 74Assert.Equal("The creator of this fault did not specify a Reason.", faultException.Message); 77Assert.Equal("Sender", faultException.Code.Name); 78Assert.Equal(string.Empty, faultException.Code.Namespace); 84Assert.Equal(CultureInfo.CurrentCulture.Name, faultReasonText.XmlLang); 85Assert.Equal("The creator of this fault did not specify a Reason.", faultReasonText.Text); 98Assert.Equal(reason, exception.Reason.ToString()); 112Assert.Equal(detail.Message, exception.Detail.Message); 114Assert.Equal(reason.ToString(), exception.Message); 137Assert.Equal(reason, exception.Reason.ToString()); 138Assert.Equal(reason, exception.Message); 146Assert.Equal(string.Empty, exception.Reason.ToString()); 147Assert.Equal(string.Empty, exception.Message); 163Assert.Equal(reason, exception.Reason.ToString()); 164Assert.Equal(reason, exception.Message); 192Assert.Equal(reason, exception.Reason.ToString()); 193Assert.Equal(reason, exception.Message); 195Assert.Equal(action, exception.Action); 203Assert.Equal(string.Empty, exception.Reason.ToString()); 204Assert.Equal(string.Empty, exception.Message);

ServiceModel\MessageContractTest.cs (2)

44Assert.Equal(wrapperName, messageCA.WrapperName); 73Assert.Equal(wrapperNamespace, messageCA.WrapperNamespace);

ServiceModel\UnixDomainSocketBindingTest.cs (1)

26Assert.Equal("net.uds", binding.Scheme);

Generators\ApplicationConfigurationInitializeBuilderTests.cs (1)

43Assert.Equal(expected, output);

CodeDomHelpers.cs (1)

17Assert.Equal(GetConstructionString(expected[i]), GetConstructionString(actual[i]));

Serialization\PrimitiveCodeDomSerializerTests.cs (1)

48Assert.Equal(typeof(byte).ToString(), cast.TargetType.BaseType);

System\ComponentModel\Design\ArrayEditorTests.cs (3)

32Assert.Equal("net.ComponentModel.CollectionEditor", editor.HelpTopic); 44Assert.Equal("net.ComponentModel.CollectionEditor", editor.HelpTopic); 123Assert.Equal(expected, editor.GetDisplayText(value));

System\ComponentModel\Design\ByteViewerTests.cs (5)

103Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 805Assert.Equal(expected, textBox.Text); 812Assert.Equal("123", textBox.Text); 835Assert.Equal(expected, textBox.Text); 842Assert.Equal("123", textBox.Text);

System\ComponentModel\Design\CollectionEditorTests.cs (3)

35Assert.Equal("net.ComponentModel.CollectionEditor", editor.HelpTopic); 47Assert.Equal("net.ComponentModel.CollectionEditor", editor.HelpTopic); 805Assert.Equal(expected, editor.GetDisplayText(value));

System\ComponentModel\Design\ComponentDesignerTests.cs (31)

System\ComponentModel\Design\DesignerActionHeaderItemTests.cs (4)

18Assert.Equal(expectedDisplayName, item.DisplayName); 19Assert.Equal(category, item.Category); 36Assert.Equal(expectedDisplayName, item.DisplayName); 37Assert.Equal(displayName, item.Category);

System\ComponentModel\Design\DesignerActionItemTests.cs (3)

18Assert.Equal(expectedDisplayName, item.DisplayName); 19Assert.Equal(category, item.Category); 20Assert.Equal(description, item.Description);

System\ComponentModel\Design\DesignerActionListTests.cs (20)

73Assert.Equal("AnnotatedMethod", item1.MemberName); 74Assert.Equal("DisplayName", item1.DisplayName); 75Assert.Equal("Description", item1.Description); 76Assert.Equal("Category", item1.Category); 79Assert.Equal("AnnotatedProperty", item2.MemberName); 80Assert.Equal("DisplayName", item2.DisplayName); 81Assert.Equal("Description", item2.Description); 82Assert.Equal("Category", item2.Category); 85Assert.Equal("EmptyAnnotatedMethod", item3.MemberName); 86Assert.Equal("EmptyAnnotatedMethod", item3.DisplayName); 91Assert.Equal("EmptyAnnotatedProperty", item4.MemberName); 92Assert.Equal("EmptyAnnotatedProperty", item4.DisplayName); 97Assert.Equal("NullAnnotatedMethod", item5.MemberName); 98Assert.Equal("NullAnnotatedMethod", item5.DisplayName); 103Assert.Equal("NullAnnotatedProperty", item6.MemberName); 104Assert.Equal("NullAnnotatedProperty", item6.DisplayName); 109Assert.Equal("PublicMethod", item7.MemberName); 110Assert.Equal("PublicMethod", item7.DisplayName); 115Assert.Equal("PublicProperty", item8.MemberName); 116Assert.Equal("PublicProperty", item8.DisplayName);

System\ComponentModel\Design\DesignerActionMethodItemTests.cs (20)

System\ComponentModel\Design\DesignerActionPropertyItemTests.cs (9)

18Assert.Equal(memberName, item.MemberName); 19Assert.Equal(expectedDisplayName, item.DisplayName); 20Assert.Equal(category, item.Category); 21Assert.Equal(description, item.Description); 38Assert.Equal(memberName, item.MemberName); 39Assert.Equal(expectedDisplayName, item.DisplayName); 40Assert.Equal(category, item.Category); 58Assert.Equal(memberName, item.MemberName); 59Assert.Equal(expectedDisplayName, item.DisplayName);

System\ComponentModel\Design\DesignerActionServiceTests.cs (1)

505Assert.Equal("Verbs", actionItem.Category);

System\ComponentModel\Design\DesignerActionTextItemTests.cs (2)

18Assert.Equal(expectedDisplayName, item.DisplayName); 19Assert.Equal(category, item.Category);

System\ComponentModel\Design\DesignerHostTests.cs (59)

System\ComponentModel\Design\DesignSurfaceTests.cs (13)

System\ComponentModel\Design\ProjectTargetFrameworkAttributeTests.cs (1)

13Assert.Equal(targetFrameworkMoniker, attribute.TargetFrameworkMoniker);

System\ComponentModel\Design\Serialization\CodeDomComponentSerializationServiceTests.cs (15)

System\ComponentModel\Design\Serialization\DesignerSerializationManagerTests.cs (9)

210Assert.Equal("Category", property.Category); 213Assert.Equal("Description", property.Description); 215Assert.Equal("DisplayName", property.DisplayName); 219Assert.Equal("Value", property.Name); 306Assert.Equal(nameof(PropertyProvider.Value), property.Name); 314Assert.Equal(nameof(OtherPropertyProvider.OtherValue), otherProperty.Name); 1927Assert.Equal("OtherName", iManager.GetName(instance2)); 1958Assert.Equal(name, iManager.GetName(instance)); 1972Assert.Equal(name, iManager.GetName(instance));

System\ComponentModel\Design\SiteNestedContainerTests.cs (11)

80Assert.Equal(expectedFullName, nestedSite.FullName); 84Assert.Equal(componentName, host.RootComponentClassName); 96Assert.Equal(componentName, component1.Site.Name); 240Assert.Equal("name1", host.RootComponentClassName); 246Assert.Equal("name1", component1.Site.Name); 252Assert.Equal("name1", host.RootComponentClassName); 257Assert.Equal("name2", component2.Site.Name); 263Assert.Equal("name1", host.RootComponentClassName); 274Assert.Equal("name1", host.RootComponentClassName); 436Assert.Equal("name", component.Site.Name); 584Assert.Equal(component.GetType().FullName, host.RootComponentClassName);

System\ComponentModel\Design\UndoUnitTests.cs (1)

38Assert.Equal(expectedName, unit.Name);

System\Drawing\Design\BitmapEditorTests.cs (1)

58Assert.Equal("Bitmap files", editor.GetFileDialogDescription());

System\Drawing\Design\ImageEditorTests.cs (3)

34Assert.Equal(expected, SubImageEditor.CreateExtensionsString(extensions, sep)); 44Assert.Equal("CustomGetImageExtendersEditor(*.PublicImageEditor,*.PrivateImageEditor)|*.PublicImageEditor;*.PrivateImageEditor", SubImageEditor.CreateFilterEntry(editor)); 105Assert.Equal("All image files", editor.GetFileDialogDescription());

System\Drawing\Design\MetafileEditorTests.cs (1)

41Assert.Equal("Metafiles", editor.GetFileDialogDescription());

System\Drawing\Design\ToolboxItemTests.cs (32)

System\Resources\Tools\StronglyTypedResourceBuilderTests.cs (12)

233Assert.Equal("TestValue", (string)nameProperty.GetValue(obj: null)); 264Assert.Equal("TestValue", (string)nameProperty.GetValue(obj: null)); 293Assert.Equal("TestValue", (string)nameProperty.GetValue(obj: null)); 565Assert.Equal(key, result); 573Assert.Equal("Invalid_Resource_", result); 581Assert.Equal("Resource_Name", result); 589Assert.Equal("_1_name", result); 597Assert.Equal(expectedResult, result); 643Assert.Equal(changedUrl, mediaPlayer.URL); 646Assert.Equal(expectedUrl, mediaPlayer.URL); 691Assert.Equal("hello test\r\n!", resourceTxtFileContents); 705Assert.Equal("HELLO", Encoding.UTF8.GetString(contents));

System\Windows\Forms\Design\Behavior\SnapLineTests.cs (3)

33Assert.Equal(DefaultFilter, snapLine.Filter); 55Assert.Equal(DefaultFilter, snapLine.Filter); 237Assert.Equal(expected, snapLine.ToString());

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

49Assert.Equal("All Files(*.*)|*.*", openFileDialog.Filter); 50Assert.Equal("Open File", openFileDialog.Title);

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

62Assert.Equal(expected, browser.Description); 66Assert.Equal(expected, browser.Description);

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

34Assert.Equal("DesignerOptions", childCollection.Name); 58Assert.Equal("DesignerOptions", childCollection.Name); 75Assert.Equal("DesignerOptions", childCollection.Name); 82Assert.Equal("DesignerOptions", otherChildCollection.Name); 98Assert.Equal("DesignerOptions", childCollection.Name);

AccessibleObjectTests.cs (1)

729Assert.Equal(getter.Name, $"get_{member.Name}");

PropertyGridTests.cs (2)

38Assert.Equal("Error From StandardErrorInfoUsageTest", ex.Message); 69Assert.Equal("Error From RawErrorInfoUsageTest", ex.Message);

RichTextBoxTests.cs (2)

83Assert.Equal("Fine Text", Marshal.PtrToStringUni((IntPtr)value.lpstrText)); 159Assert.Equal("Fine Text", Marshal.PtrToStringAnsi(value.lpstrText));

Interop\ComCtl32\LVITEMWTests.cs (2)

37Assert.Equal(expected, text); 68Assert.Equal("012345", text);

Interop\Ole32\CALPOLESTRTests.cs (1)

18Assert.Equal("Swizzle", values[0]);

Interop\Oleaut32\ITypeInfoTests.cs (3)

92Assert.Equal("Width", name.ToString()); 198Assert.Equal("Width", rgszNames[0].ToString()); 199Assert.Equal("Name2", rgszNames[1].ToString());

Interop\User32\GetWindowTextTests.cs (1)

40Assert.Equal(longText, result);

Interop\User32\SystemParametersInfoWTests.cs (1)

35Assert.Equal(expected.Name, actual.Name);

System\Windows\Forms\Automation\UiaTextRangeTests.cs (2)

878Assert.Equal(expected, actual.ToString()); 1185Assert.Equal(faceName ?? "", actual);

System\Windows\Forms\FileDialogCustomPlaceTests.cs (1)

91Assert.Equal(expected, place.ToString());

System\Windows\Forms\Internals\ArgumentValidationTests.cs (22)

Windows\Win32\System\Com\SafeArrayScopeTests.cs (3)

74Assert.Equal(message, e.Message); 79Assert.Equal(message, e.Message); 94Assert.Equal("Wanted SafeArrayScope<System.String> but got SAFEARRAY with VarType=VT_INT", e.Message);

Extensions\AssertExtensions.cs (8)

30Assert.Equal(expectedMessage, Assert.Throws<T>(action).Message); 54Assert.Equal(expectedParamName, exception.ParamName); 73Assert.Equal(expectedParamName, exception.ParamName); 81Assert.Equal(expectedParamName, exception.ParamName); 133Assert.Equal(expectedParamName, exception.ParamName); 143Assert.Equal(expectedParamName, exception.ParamName); 159Assert.Equal(expectedParamName, ((ArgumentException)exception).ParamName); 543Assert.Equal(expected, actual);

Metafiles\Validators\TextOutValidator.cs (1)

40Assert.Equal(_text, textOut->emrtext.GetText().ToString());

EnumValidationTests.cs (1)

341Assert.Equal(expected, line);

BindingNavigatorTests.cs (15)

44Assert.Equal("container", ex.ParamName); 60Assert.Equal("bindingNavigatorPositionItem", bn.PositionItem.Name); 61Assert.Equal("bindingNavigatorCountItem", bn.CountItem.Name); 102Assert.Equal(itemNames[i], item.Name.Trim()); 103Assert.Equal(itemTexts[i], item.Text.Trim()); 138Assert.Equal("1", control.PositionItem.Text); 139Assert.Equal($"of {rowsCount}", control.CountItem.Text); 145Assert.Equal("0", control.PositionItem.Text); 146Assert.Equal("of 0", control.CountItem.Text); 174Assert.Equal("1", control.PositionItem.Text); 175Assert.Equal($"of {rowsCount1}", control.CountItem.Text); 180Assert.Equal("1", control.PositionItem.Text); 181Assert.Equal($"of {rowsCount2}", control.CountItem.Text); 190Assert.Equal("1", control.PositionItem.Text); 191Assert.Equal($"of {rowsCount2}", control.CountItem.Text);

CheckedListBoxTests.cs (4)

64Assert.Equal(expected, box.DisplayMember); 157Assert.Equal(expected, box.ValueMember); 260Assert.Equal("index", ex.ParamName); 361Assert.Equal("index", ex.ParamName);

ContextMenuStripTests.cs (1)

28Assert.Equal("container", ex.ParamName);

KeyboardTooltipStateMachineTests.cs (2)

76Assert.Equal("Shown", currentState); 107Assert.Equal(isPersistent && OsVersion.IsWindows11_OrGreater() ? "Hidden" : "Shown", currentState);

misc\CollectionHelperTests.cs (12)

80Assert.Equal("key-one", firstTargetItem.Key); 81Assert.Equal("value-one", firstTargetItem.Value); 85Assert.Equal("key-two", secondTargetItem.Key); 86Assert.Equal("value-two", secondTargetItem.Value); 103Assert.Equal("key-one", (string)firstTargetItem.Key); 104Assert.Equal("value-one", (string)firstTargetItem.Value); 108Assert.Equal("key-two", (string)secondTargetItem.Key); 109Assert.Equal("value-two", (string)secondTargetItem.Value); 125Assert.Equal("key-one", (string)firstTargetItem.Key); 126Assert.Equal("value-one", (string)firstTargetItem.Value); 129Assert.Equal("key-two", (string)secondTargetItem.Key); 130Assert.Equal("value-two", (string)secondTargetItem.Value);

NumericUpDownTests.cs (1)

17Assert.Equal("0", nud.Text);

SerializableTypesTests.cs (18)

56Assert.Equal(licenseKey, result.LicenseKey); 57Assert.Equal(licenseKey, state.LicenseKey); 65Assert.Equal(payload, Encoding.UTF8.GetString(buffer)); 145Assert.Equal("Header", result.Header); 148Assert.Equal("GroupName", result.Name); 151Assert.Equal("Item", item.Text); 183Assert.Equal("Item1", result.Text); 187Assert.Equal("Item1", item.Text); 191Assert.Equal(FontFamily.GenericSansSerif.Name, result.Font.FontFamily.Name); 232Assert.Equal("SubItem1", result.Text); 239Assert.Equal(FontFamily.GenericSansSerif.Name, result.Font.FontFamily.Name); 368Assert.Equal("node1", result.Text); 370Assert.Equal("key", result.SelectedImageKey); 372Assert.Equal("node2", result.FirstNode.Text); 373Assert.Equal("node3", result.LastNode.Text); 374Assert.Equal("tool tip text", result.ToolTipText); 375Assert.Equal("node1", result.Name); 380Assert.Equal(FontFamily.GenericSansSerif.Name, result.NodeFont.FontFamily.Name);

System\Resources\ResxDataNodeTests.cs (1)

22Assert.Equal(nodeName, dataNode.Name);

System\Resources\ResXFileRef.ConverterTests.cs (4)

58Assert.Equal(expected, result); 70Assert.Equal(expected, result); 82Assert.Equal(expected, Encoding.Default.GetString(result)); 94Assert.Equal(expected, Encoding.Default.GetString(result.ToArray()));

System\Resources\ResXFileRefTests.cs (4)

19Assert.Equal(fileName, fileRef.FileName); 20Assert.Equal(typeName, fileRef.TypeName); 33Assert.Equal(fileName, fileRef.FileName); 34Assert.Equal(typeName, fileRef.TypeName);

System\Resources\ResXResourceReaderTests.cs (1)

30Assert.Equal("axWindowsMediaPlayer1.OcxState", key);

System\Resources\ResXResourceSetTests.cs (2)

26Assert.Equal(expected, strResXValue); 47Assert.Equal(expected, strResXValue);

System\Windows\Forms\AccessibleObjects\AccessibleObjectTests.cs (19)

System\Windows\Forms\AccessibleObjects\ButtonBase.ButtonBaseAccessibleObjectTests.cs (1)

243Assert.Equal(expected, ((BSTR)actual).ToString());

System\Windows\Forms\AccessibleObjects\CategoryGridEntryAccessibleObjectTests.cs (2)

157Assert.Equal(expected, ((BSTR)accessibilityObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_LocalizedControlTypePropertyId)).ToStringAndFree()); 184Assert.Equal("Collapse", ((BSTR)accessibilityObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_LegacyIAccessibleDefaultActionPropertyId)).ToStringAndFree());

System\Windows\Forms\AccessibleObjects\CheckBox.CheckBoxAccessibleObjectTests.cs (3)

186Assert.Equal("TestDescription", checkBoxAccessibleObject.Description); 201Assert.Equal("TestName", checkBoxAccessibleObject.Name); 303Assert.Equal(checkBox.AccessibilityObject.DefaultAction, ((BSTR)checkBox.AccessibilityObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_LegacyIAccessibleDefaultActionPropertyId)).ToStringAndFree());

System\Windows\Forms\AccessibleObjects\CheckedListBoxItemAccessibleObjectTests.cs (6)

48Assert.Equal(testName, checkedListBox.AccessibilityObject.GetChild(0).Name); 170Assert.Equal(string.Empty, checkedListBox.AccessibilityObject.GetChild(0).DefaultAction); 189Assert.Equal(expected, checkedListBox.AccessibilityObject.GetChild(0).DefaultAction); 202Assert.Equal(expected, ((BSTR)checkedListBox.AccessibilityObject.GetChild(0).GetPropertyValue(UIA_PROPERTY_ID.UIA_LegacyIAccessibleDefaultActionPropertyId)).ToStringAndFree()); 215Assert.Equal(isChecked.ToString(), checkedListBox.AccessibilityObject.GetChild(0).Value); 265Assert.Equal(checkValue.ToString(), ((BSTR)checkedListBox.AccessibilityObject.GetChild(0).GetPropertyValue(UIA_PROPERTY_ID.UIA_ValueValuePropertyId)).ToStringAndFree());

System\Windows\Forms\AccessibleObjects\ColumnHeader.ListViewColumnHeaderAccessibleObjectTests.cs (2)

36Assert.Equal(testText, ((BSTR)accessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_NamePropertyId)).ToStringAndFree()); 37Assert.Equal(testText, ((BSTR)accessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_LegacyIAccessibleNamePropertyId)).ToStringAndFree());

System\Windows\Forms\AccessibleObjects\ComboBox.ChildAccessibleObjectTests.cs (1)

38Assert.Equal(testName, accessibleObject.Name);

System\Windows\Forms\AccessibleObjects\ComboBox.ComboBoxAccessibleObjectTests.cs (5)

119Assert.Equal(name, ((BSTR)comboBox.AccessibilityObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_NamePropertyId)).ToStringAndFree()); 120Assert.Equal(name, ((BSTR)comboBox.AccessibilityObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_LegacyIAccessibleNamePropertyId)).ToStringAndFree()); 311Assert.Equal(comboBox.AccessibleDefaultActionDescription, comboBox.AccessibilityObject.DefaultAction); 351Assert.Equal(expectedAction, comboBox.AccessibilityObject.DefaultAction); 362Assert.Equal(expectedAction, ((BSTR)comboBox.AccessibilityObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_LegacyIAccessibleDefaultActionPropertyId)).ToStringAndFree());

System\Windows\Forms\AccessibleObjects\ComboBox.ComboBoxItemAccessibleObjectTests.cs (7)

76Assert.Equal(person.Name, itemAccessibleObject.Name); 99Assert.Equal("aaa", comboBoxItem1.Name); 106Assert.Equal("aaa", comboBoxItem2.Name); 114Assert.Equal("aaa", comboBoxItem3.Name); 139Assert.Equal("aaa", comboBoxItem3.Name); 147Assert.Equal("aaa", comboBoxItem2.Name); 155Assert.Equal("aaa", comboBoxItem1.Name);

System\Windows\Forms\AccessibleObjects\Control.ControlAccessibleObjectTests.cs (41)

System\Windows\Forms\AccessibleObjects\DataGridView.DataGridViewEditingPanelAccessibleObjectTests.cs (1)

116Assert.Equal(string.Empty, ((BSTR)editingPanel.AccessibilityObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_HelpTextPropertyId)).ToStringAndFree());

System\Windows\Forms\AccessibleObjects\DataGridViewAccessibleObjectTests.cs (1)

42Assert.Equal(expectedStatus, itemStatus);

System\Windows\Forms\AccessibleObjects\DataGridViewCellAccessibleObjectTests.cs (15)

System\Windows\Forms\AccessibleObjects\DataGridViewCheckBoxCellAccessibleObjectTests.cs (3)

118Assert.Equal(string.Empty, cell.AccessibilityObject.DefaultAction); 147Assert.Equal(expected, accessibleObject.DefaultAction); 171Assert.Equal(expected, ((BSTR)accessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_LegacyIAccessibleDefaultActionPropertyId)).ToStringAndFree());

System\Windows\Forms\AccessibleObjects\DataGridViewColumnHeaderCellAccessibleObjectTests.cs (3)

53Assert.Equal(testHeaderName, accessibleObject.Name); 66Assert.Equal(testHeaderName, accessibleObject.Value); 149Assert.Equal("Header text 1", ((BSTR)accessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_ValueValuePropertyId)).ToStringAndFree());

System\Windows\Forms\AccessibleObjects\DataGridViewImageCellAccessibleObjectTests.cs (2)

24Assert.Equal(string.Empty, accessibleObject.DefaultAction); 85Assert.Equal(testDescription, cell.AccessibilityObject.Description);

System\Windows\Forms\AccessibleObjects\DataGridViewRowAccessibleObjectTests.cs (18)

System\Windows\Forms\AccessibleObjects\DataGridViewRowHeaderCellAccessibleObjectTests.cs (3)

41Assert.Equal(string.Empty, accessibleObject.Value); 58Assert.Equal(row.AccessibilityObject.Name, row.HeaderCell.AccessibilityObject.Name); 79Assert.Equal(expected, accessibleObject.DefaultAction);

System\Windows\Forms\AccessibleObjects\DataGridViewSelectedCellsAccessibleObjectTests.cs (1)

205Assert.Equal("Selected Cells", ((BSTR)accessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_ValueValuePropertyId)).ToStringAndFree());

System\Windows\Forms\AccessibleObjects\DataGridViewSelectedRowCellsAccessibleObjectTests.cs (1)

214Assert.Equal("Selected Row Cells", ((BSTR)accessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_ValueValuePropertyId)).ToStringAndFree());

System\Windows\Forms\AccessibleObjects\DataGridViewTopLeftHeaderCellAccessibleObjectTests.cs (4)

76Assert.Equal(expected, cell.AccessibilityObject.DefaultAction); 85Assert.Equal(string.Empty, cell.AccessibilityObject.Value); 128Assert.Equal(expected, cell.AccessibilityObject.Name); 141Assert.Equal(string.Empty, cell.AccessibilityObject.Name);

System\Windows\Forms\AccessibleObjects\DataGridViewTopRowAccessibleObjectTests.cs (2)

1241Assert.Equal(string.Empty, ((BSTR)topRowAccessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_HelpTextPropertyId)).ToStringAndFree()); 1244Assert.Equal("Top Row", ((BSTR)topRowAccessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_ValueValuePropertyId)).ToStringAndFree());

System\Windows\Forms\AccessibleObjects\DateTimePicker.DateTimePickerAccessibleObjectTests.cs (6)

56Assert.Equal(expected, actual); 115Assert.Equal(dt.ToLongDateString(), ((BSTR)accessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_ValueValuePropertyId)).ToStringAndFree()); 282Assert.Equal(string.Empty, dateTimePicker.AccessibilityObject.Name); 292Assert.Equal(testAccessibleName, dateTimePicker.AccessibilityObject.Name); 317Assert.Equal(expected, accessibleObject.DefaultAction); 374Assert.Equal("Alt+d", keyboardShortcut);

System\Windows\Forms\AccessibleObjects\ErrorProvider.ControlItem.ControlItemAccessibleObjectTests.cs (1)

126Assert.Equal(testError, accessibleObject.Name);

System\Windows\Forms\AccessibleObjects\ErrorProviderAccessibleObjectTests.cs (4)

96Assert.Equal(expected, actual); 99Assert.Equal(expected, actual); 104Assert.Equal(expected, actual); 107Assert.Equal(expected, actual);

System\Windows\Forms\AccessibleObjects\GroupBoxAccessibleObjectTests.cs (4)

25Assert.Equal(testAccName, ((BSTR)groupBoxAccessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_NamePropertyId)).ToStringAndFree()); 26Assert.Equal(testAccName, ((BSTR)groupBoxAccessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_LegacyIAccessibleNamePropertyId)).ToStringAndFree()); 80Assert.Equal(testAccDescription, groupBoxAccessibleObject.Description); 129Assert.Equal(expected, actual);

System\Windows\Forms\AccessibleObjects\HScrollBar.HScrollBarAccessibleObjectTests.cs (2)

50Assert.Equal(accessibleDescription, accessibleObject.Description); 65Assert.Equal(accessibleName, accessibleObject.Name);

System\Windows\Forms\AccessibleObjects\HScrollBar.ScrollBarThumbAccessibleObjectTests.cs (1)

44Assert.Equal(string.Empty, accessibleObject.DefaultAction);

System\Windows\Forms\AccessibleObjects\LabelAccessibleObjectTests.cs (2)

27Assert.Equal(expected, value); 81Assert.Equal(testAccDescription, labelAccessibleObject.Description);

System\Windows\Forms\AccessibleObjects\LinkLabel.Link.LinkAccessibleObjectTests.cs (3)

202Assert.Equal(testName, actual); 224Assert.Equal(names[index], actual); 238Assert.Equal(accessibleObject.Help ?? string.Empty, actual);

System\Windows\Forms\AccessibleObjects\ListBox.ListBoxItemAccessibleObjectTests.cs (3)

42Assert.Equal(person.Name, itemAccessibleObject.Name); 65Assert.Equal(itemAccessibleObject.Name, ((BSTR)actual).ToStringAndFree()); 116Assert.Equal(itemAccessibleObject.Help ?? string.Empty, actual);

System\Windows\Forms\AccessibleObjects\ListVIew.ListViewAccessibleObjectTests.cs (3)

72Assert.Equal(((int)(listView.View)).ToString(), accessibleObject.GetMultiViewProviderViewName((int)View.Details)); 212Assert.Equal("ListView", accessibleName); 215Assert.Equal("List", automationId);

System\Windows\Forms\AccessibleObjects\ListViewGroup.ListViewGroupAccessibleObjectTests.cs (8)

61Assert.Equal("Group1", accessibleName); 64Assert.Equal("ListViewGroup-0", automationId); 93Assert.Equal("Group1", ((BSTR)groupAccessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_NamePropertyId)).ToStringAndFree()); 94Assert.Equal("Group1", ((BSTR)groupAccessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_LegacyIAccessibleNamePropertyId)).ToStringAndFree()); 96Assert.Equal("ListViewGroup-0", ((BSTR)defaultGroupAccessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_AutomationIdPropertyId)).ToStringAndFree()); 97Assert.Equal("ListViewGroup-1", ((BSTR)groupAccessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_AutomationIdPropertyId)).ToStringAndFree()); 107Assert.Equal("WinForm", ((BSTR)groupAccessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_FrameworkIdPropertyId)).ToStringAndFree()); 125Assert.Equal($"{name}. {subtitle}", accessibleName);

System\Windows\Forms\AccessibleObjects\ListViewItem.ListViewItemAccessibleObjectTests.cs (2)

100Assert.Equal("ListItem", accessibleName); 104Assert.Equal("ListViewItem-0", automationId);

System\Windows\Forms\AccessibleObjects\ListViewItem.ListViewItemBaseAccessibleObjectTests.cs (2)

262Assert.Equal("WinForm", ((BSTR)actual).ToString()); 398Assert.Equal(expected, ((BSTR)accessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_AutomationIdPropertyId)).ToStringAndFree());

System\Windows\Forms\AccessibleObjects\ListViewItem.ListViewItemDetailsAccessibleObjectTests.cs (4)

198Assert.Equal("sub1", listItemAccessibleObject.GetChild(2).Name); 202Assert.Equal("sub2", listItemAccessibleObject.GetChild(2).Name); 222Assert.Equal("sub1", listItemAccessibleObject.GetChild(1).Name); 226Assert.Equal("sub2", listItemAccessibleObject.GetChild(1).Name);

System\Windows\Forms\AccessibleObjects\ListViewItem.ListViewSubItem.ListViewSubItemAccessibleObjectTests.cs (3)

81Assert.Equal($"Test {childId + 1}", accessibleName); 84Assert.Equal($"ListViewSubItem-{childId}", automationId); 87Assert.Equal("WinForm", frameworkId);

System\Windows\Forms\AccessibleObjects\ListViewLabelEditAccessibleObjectTests.cs (3)

29Assert.Equal(accessibilityObject.Name, ((BSTR)accessibilityObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_NamePropertyId)).ToStringAndFree()); 35Assert.Equal("1", ((BSTR)accessibilityObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_AutomationIdPropertyId)).ToStringAndFree()); 116Assert.Equal(listView.Items[0].Text, accessibilityObject.Name);

System\Windows\Forms\AccessibleObjects\MaskedTextBox.MaskedTextBoxAccessibleObjectTests.cs (3)

91Assert.Equal(expectedAccessibleName, ((BSTR)actual).ToStringAndFree()); 109Assert.Equal(expectedAccessibleName, actual); 124Assert.Equal(maskedTextBox.WindowText, actual);

System\Windows\Forms\AccessibleObjects\MenuStrip.MenuStripAccessibleObjectTests.cs (2)

24Assert.Equal("Test Name", ((BSTR)accessibleName).ToStringAndFree()); 83Assert.Equal("Test Description", accessibleObjectDescription);

System\Windows\Forms\AccessibleObjects\MonthCalendar.CalendarAccessibleObjectTests.cs (2)

23Assert.Equal(name, calendar.Name); 247Assert.Equal(initName, calendar.Name);

System\Windows\Forms\AccessibleObjects\MonthCalendar.CalendarBodyAccessibleObjectTests.cs (1)

153Assert.Equal(expected, calendarBody.Name);

System\Windows\Forms\AccessibleObjects\MonthCalendar.CalendarCellAccessibleObjectTests.cs (1)

157Assert.Equal(expected, cellAccessibleObject.Name);

System\Windows\Forms\AccessibleObjects\MonthCalendar.CalendarTodayLinkAccessibleObjectTests.cs (1)

83Assert.Equal(expected, actual);

System\Windows\Forms\AccessibleObjects\MonthCalendar.MonthCalendarAccessibleObjectTests.cs (1)

84Assert.Equal(dt.ToLongDateString(), ((BSTR)monthCalendar.AccessibilityObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_ValueValuePropertyId)).ToStringAndFree());

System\Windows\Forms\AccessibleObjects\Panel.PanelAccessibleObjectTests.cs (2)

40Assert.Equal(expected, panelAccessibleObject.Description); 56Assert.Equal(expected, panelAccessibleObject.Name);

System\Windows\Forms\AccessibleObjects\PictureBox.PictureBoxAccessibleObjectTests.cs (2)

39Assert.Equal("TestDescription", pictureBoxAccessibleObject.Description); 54Assert.Equal("TestName", pictureBoxAccessibleObject.Name);

System\Windows\Forms\AccessibleObjects\ProgressBarAccessibleObjectTests.cs (4)

34Assert.Equal("5%", accessibilityObject.Value); 59Assert.Equal(string.Empty, accessibilityObject.Value); 88Assert.Equal(expectedValue, accessibilityObject.Value); 93Assert.Equal(expectedValue, accessibilityObject.Value);

System\Windows\Forms\AccessibleObjects\PropertyGridView.GridViewListBoxItemAccessibleObjectTests.cs (1)

54Assert.Equal(itemEntry.ToString(), accessibleObject.Name);

System\Windows\Forms\AccessibleObjects\PropertyGridView.PropertyGridViewAccessibleObjectTests.cs (1)

313Assert.Equal(name, listAccessibleName);

System\Windows\Forms\AccessibleObjects\RadioButton.RadioButtonAccessibleObjectTests.cs (4)

40Assert.Equal("TestActionDescription", radioButtonAccessibleObject.DefaultAction); 54Assert.Equal("TestActionDescription", ((BSTR)radioButtonAccessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_LegacyIAccessibleDefaultActionPropertyId)).ToStringAndFree()); 69Assert.Equal("TestDescription", radioButtonAccessibleObject.Description); 84Assert.Equal("TestName", radioButtonAccessibleObject.Name);

System\Windows\Forms\AccessibleObjects\SplitContainer.SplitContainerAccessibleObjectTests.cs (1)

89Assert.Equal(expected, value);

System\Windows\Forms\AccessibleObjects\Splitter.SplitterAccessibleObjectTests.cs (2)

39Assert.Equal("TestDescription", splitterAccessibleObject.Description); 54Assert.Equal("TestName", splitterAccessibleObject.Name);

System\Windows\Forms\AccessibleObjects\StatusStrip.StatusStripAccessibleObjectTests.cs (2)

24Assert.Equal("Test Name", ((BSTR)accessibleName).ToStringAndFree()); 63Assert.Equal("Test Description", accessibleObjectDescription);

System\Windows\Forms\AccessibleObjects\TabControl.TabControlAccessibleObjectTests.cs (7)

559Assert.Equal(accessibleName, accessibleObject.Name); 574Assert.Equal(accessibleDescription, accessibleObject.Description); 589Assert.Equal(accessibleDefaultActionDescription, accessibleObject.DefaultAction); 609Assert.Equal(accessibleDefaultActionDescription, ((BSTR)actual).ToStringAndFree()); 701Assert.Equal(expectedKeyboardShortcut, accessibleObject.KeyboardShortcut); 721Assert.Equal(expectedKeyboardShortcut, ((BSTR)accessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_AccessKeyPropertyId)).ToStringAndFree()); 765Assert.Equal(expected, actual);

System\Windows\Forms\AccessibleObjects\TabPage.TabAccessibleObjectTests.cs (1)

63Assert.Equal(expectedText, accessibleObject.Name);

System\Windows\Forms\AccessibleObjects\TabPage.TabPageAccessibleObjectTests.cs (6)

115Assert.Equal(expectedName, accessibleObject.Name); 130Assert.Equal(accessibleDescription, accessibleObject.Description); 162Assert.Equal(accessibleDefaultActionDescription, accessibleObject.DefaultAction); 457Assert.Equal(expectedKeyboardShortcut, accessibleObject.KeyboardShortcut); 477Assert.Equal(expectedKeyboardShortcut, ((BSTR)accessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_AccessKeyPropertyId)).ToStringAndFree()); 494Assert.Equal(expected, actual);

System\Windows\Forms\AccessibleObjects\TextBoxAccessibleObjectTests.cs (1)

131Assert.Equal(expectedHelpText, helpText);

System\Windows\Forms\AccessibleObjects\TextBoxBaseAccessibleObjectTests.cs (2)

62Assert.Equal(text, textBoxBase.Text); 96Assert.Equal(textBoxBase.Text, accessibleObject.Value);

System\Windows\Forms\AccessibleObjects\ToolStripAccessibleObjectTests.cs (2)

34Assert.Equal("Test Name", ((BSTR)accessibleName).ToStringAndFree()); 73Assert.Equal("Test Description", accessibleObjectDescription);

System\Windows\Forms\AccessibleObjects\ToolStripContainer.ToolStripContainerAccessibleObjectTests.cs (1)

34Assert.Equal(expected, value);

System\Windows\Forms\AccessibleObjects\ToolStripControlHost.ToolStripControlHostAccessibleObjectTests.cs (1)

36Assert.Equal(string.Empty, accessibleObject.DefaultAction);

System\Windows\Forms\AccessibleObjects\ToolStripItemAccessibleObjectTests.cs (6)

26Assert.Equal("DefaultActionDescription", accessibleObject.DefaultAction); 27Assert.Equal("Description", accessibleObject.Description); 30Assert.Equal("Name", accessibleObject.Name); 85Assert.Equal("Test Accessible Description", accessibleObjectDescription); 99Assert.Equal(string.Empty, ((BSTR)result).ToString()); 107Assert.Equal("Test Name", ((BSTR)accessibleName).ToString());

System\Windows\Forms\AccessibleObjects\ToolStripScrollButton.ToolStripScrollButtonAccessibleObjectTests.cs (4)

150Assert.Equal(expectedUpButtonName, upScrollButtonAccessibleObject.Name); 151Assert.Equal(expectedDefaultAction, upScrollButtonAccessibleObject.DefaultAction); 154Assert.Equal(expectedDownButtonName, downScrollButtonAccessibleObject.Name); 155Assert.Equal(expectedDefaultAction, downScrollButtonAccessibleObject.DefaultAction);

System\Windows\Forms\AccessibleObjects\ToolStripTextBox.ToolStripTextBoxAccessibleObjectTests.cs (2)

22Assert.Equal("Test Name", ((BSTR)accessibleName).ToStringAndFree()); 61Assert.Equal("Test Description", accessibleObjectDescription);

System\Windows\Forms\AccessibleObjects\TrackBar.TrackBarAccessibleObjectTests.cs (9)

37Assert.Equal("50", accessibilityObject.Value); 60Assert.Equal(string.Empty, accessibilityObject.Value); 92Assert.Equal(expectedValueString, accessibilityObject.Value); 98Assert.Equal(expectedValueString, accessibilityObject.Value); 117Assert.Equal("50", accessibilityObject.Value); 135Assert.Equal(string.Empty, accessibilityObject.Value); 317Assert.Equal(defaultAction, trackBar.AccessibilityObject.DefaultAction); 335Assert.Equal(defaultAction, ((BSTR)actual).ToStringAndFree()); 437Assert.Equal(expected, value);

System\Windows\Forms\AccessibleObjects\TreeNode.TreeNodeAccessibleObjectTests.cs (2)

484Assert.Equal("Node2", control.SelectedNode?.Text); 487Assert.Equal("Node4", control.SelectedNode?.Text);

System\Windows\Forms\AccessibleObjects\TreeViewLabelEditAccessibleObjectTests.cs (3)

28Assert.Equal(accessibilityObject.Name, ((BSTR)accessibilityObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_NamePropertyId)).ToStringAndFree()); 34Assert.Equal(((BSTR)accessibilityObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_NamePropertyId)).ToStringAndFree(), ((BSTR)accessibilityObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_AutomationIdPropertyId)).ToStringAndFree()); 115Assert.Equal(treeView.Nodes[0].Text, accessibilityObject.Name);

System\Windows\Forms\AccessibleObjects\UpDownBase.UpDownButtons.UpDownButtonsAccessibleObjectTests.cs (1)

92Assert.Equal(name, actual);

System\Windows\Forms\AccessibleObjects\UpDownBase.UpDownEdit.UpDownEditAccessibleObjectTests.cs (2)

55Assert.Equal(name, accessibleObject.Name); 99Assert.Equal(upDown.AccessibilityObject.KeyboardShortcut, accessibleObject.KeyboardShortcut);

System\Windows\Forms\AccessibleObjects\VScrollBar.ScrollBarThumbAccessibleObjectTests.cs (1)

44Assert.Equal(string.Empty, accessibleObject.DefaultAction);

System\Windows\Forms\AccessibleObjects\VScrollBar.VScrollBarAccessibleObjectTests.cs (2)

49Assert.Equal(accessibleDescription, accessibleObject.Description); 64Assert.Equal(accessibleName, accessibleObject.Name);

System\Windows\Forms\AccessibleObjects\WebBrowser.WebBrowserAccessibleObjectTests.cs (1)

35Assert.Equal(expected, value);

System\Windows\Forms\ApplicationTests.cs (1)

641Assert.Equal(expected.Name, actual.Name);

System\Windows\Forms\AutoCompleteStringCollectionTests.cs (1)

160Assert.Equal(s, collection[0]);

System\Windows\Forms\AxHost.AxPropertyDescriptorTests.cs (18)

System\Windows\Forms\AxHost.PropertyBagStreamTests.cs (1)

40Assert.Equal(obj.Name, ((NameClass)dispatch.ToObject()).Name);

System\Windows\Forms\AxHostTests.cs (20)

96Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 190Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 888Assert.Equal(expected, control.Text); 893Assert.Equal(expected, control.Text); 911Assert.Equal(expected, control.Text); 919Assert.Equal(expected, control.Text); 1460Assert.Equal(font.Name, result.Name); 1466Assert.Equal(font.Name, result.Name); 1489Assert.Equal(font.Name, result.Name); 1495Assert.Equal(font.Name, result.Name); 1535Assert.Equal(font.Name, result.Name); 1556Assert.Equal(font.Name, result.Name); 2496Assert.Equal(nameof(AxHost.Enter), eventDescriptor.Name); 2501Assert.Equal(nameof(AxHost.Enter), eventDescriptor.Name); 2519Assert.Equal(nameof(AxHost.Enter), eventDescriptor.Name); 2527Assert.Equal(nameof(AxHost.Enter), eventDescriptor.Name); 2540Assert.Equal(nameof(AxHost.Text), propertyDescriptor.Name); 2545Assert.Equal(nameof(AxHost.Text), propertyDescriptor.Name); 2563Assert.Equal(nameof(AxHost.Text), propertyDescriptor.Name); 2571Assert.Equal(nameof(AxHost.Text), propertyDescriptor.Name);

System\Windows\Forms\BindingCompleteEventArgsTests.cs (3)

42Assert.Equal(errorText ?? "", e.ErrorText); 61Assert.Equal(errorText ?? "", e.ErrorText); 80Assert.Equal(errorText ?? "", e.ErrorText);

System\Windows\Forms\BindingMemberInfoTests.cs (3)

30Assert.Equal(expectedPath, info.BindingPath); 31Assert.Equal(expectedField, info.BindingField); 32Assert.Equal(expectedMember, info.BindingMember);

System\Windows\Forms\BindingTests.cs (2)

269Assert.Equal(expected, binding.FormatString); 273Assert.Equal(expected, binding.FormatString);

System\Windows\Forms\ButtonBaseTests.cs (41)

System\Windows\Forms\ButtonTests.cs (26)

95Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 129Assert.Equal("Button", createParams.ClassName); 153Assert.Equal("Button", createParams.ClassName); 186Assert.Equal("Button", createParams.ClassName); 256Assert.Equal("Button", createParams.ClassName); 309Assert.Equal("AutoSize", e.AffectedProperty); 358Assert.Equal("AutoSize", e.AffectedProperty); 457Assert.Equal("AutoSize", e.AffectedProperty); 530Assert.Equal("AutoSize", e.AffectedProperty); 769Assert.Equal(expected, control.Text); 775Assert.Equal(expected, control.Text); 804Assert.Equal("Text", e.AffectedProperty); 813Assert.Equal(expected, control.Text); 821Assert.Equal(expected, control.Text); 860Assert.Equal(expected, control.Text); 868Assert.Equal(expected, control.Text); 907Assert.Equal("Text", e.AffectedProperty); 916Assert.Equal(expected, control.Text); 927Assert.Equal(expected, control.Text); 975Assert.Equal("text", control.Text); 980Assert.Equal("text", control.Text); 991Assert.Equal("text", control.Text); 2935Assert.Equal("Text", e.AffectedProperty); 3045Assert.Equal("Text", e.AffectedProperty); 3315Assert.Equal("System.Windows.Forms.Button, Text: ", control.ToString()); 3357Assert.Equal("System.Windows.Forms.Button, Text: Text", control.ToString());

System\Windows\Forms\CheckBoxTests.cs (3)

96Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 132Assert.Equal("Button", createParams.ClassName); 629Assert.Equal(expected, actual);

System\Windows\Forms\ColorDialogTests.cs (1)

360Assert.Equal("System.Windows.Forms.Tests.ColorDialogTests+SubColorDialog, Color: Color [Black]", dialog.ToString());

System\Windows\Forms\ColumnHeaderCollectionTests.cs (24)

System\Windows\Forms\ColumnHeaderTests.cs (51)

System\Windows\Forms\ColumnStyleTests.cs (2)

76Assert.Equal("Style", e.AffectedProperty); 113Assert.Equal("Style", e.AffectedProperty);

System\Windows\Forms\ComboBox.ComboBoxChildEditUiaProviderTests.cs (2)

169Assert.Equal(comboBox.AccessibleName, ((BSTR)accessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_NamePropertyId)).ToStringAndFree()); 170Assert.Equal(comboBox.AccessibleName, ((BSTR)accessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_LegacyIAccessibleNamePropertyId)).ToStringAndFree());

System\Windows\Forms\ComboBox.ComboBoxUiaTextProviderTests.cs (3)

632Assert.Equal(expected, actual); 650Assert.Equal(string.Empty, actual); 1086Assert.Equal("Segoe UI", actual);

System\Windows\Forms\ComboBoxTests.cs (12)

106Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 141Assert.Equal("ComboBox", createParams.ClassName); 1333Assert.Equal(expectedText, control.Text); 1339Assert.Equal(expectedText, control.Text); 1358Assert.Equal(expectedText, control.Text); 1364Assert.Equal(expectedText, control.Text); 1732Assert.Equal("", control.Text); 1742Assert.Equal(expected, control.Text); 1756Assert.Equal(expected, control.Text); 1767Assert.Equal("12-9", control.Text); 2269Assert.Equal(selectedIndex.ToString(), comboBox.Text); 2691Assert.Equal(string.Empty, control.Text);

System\Windows\Forms\ComponentModel\Com2Interop\COM2FontConverterTests.cs (1)

48Assert.Equal("Arial", font.Name);

System\Windows\Forms\ComponentModel\Com2Interop\ComNativeDescriptorTests.cs (9)

50Assert.Equal("Misc", handleProperty.Category); 52Assert.Equal("Windows.Win32.System.Com.IDispatch+Interface", handleProperty.ComponentType.FullName); 55Assert.Equal("System.Int32", handleProperty.PropertyType.FullName); 68Assert.Equal("Misc", typeProperty.Category); 70Assert.Equal("Windows.Win32.System.Com.IDispatch+Interface", typeProperty.ComponentType.FullName); 72Assert.Equal("System.Int16", typeProperty.PropertyType.FullName); 133Assert.Equal("Misc", urlProperty.Category); 135Assert.Equal("Windows.Win32.System.Com.IDispatch+Interface", urlProperty.ComponentType.FullName); 137Assert.Equal("System.String", urlProperty.PropertyType.FullName);

System\Windows\Forms\ContainerControlTests.cs (3)

101Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 1331Assert.Equal("Hidden", currentState); 1356Assert.Equal("Hidden", currentState);

System\Windows\Forms\Control.ActiveXFontMarshallerTests.cs (2)

27Assert.Equal(font.Name, name.ToString()); 31Assert.Equal(font.Name, outFont.Name);

System\Windows\Forms\ControlBindingsCollectionTests.cs (8)

129Assert.Equal(nameof(Control.Text), binding.PropertyName); 146Assert.Equal(nameof(Control.Text), binding.PropertyName); 163Assert.Equal(nameof(Control.Text), binding.PropertyName); 180Assert.Equal(nameof(Control.Text), binding.PropertyName); 197Assert.Equal(nameof(Control.Text), binding.PropertyName); 202Assert.Equal("formatString", binding.FormatString); 214Assert.Equal(nameof(Control.Text), binding.PropertyName); 219Assert.Equal("formatString", binding.FormatString);

System\Windows\Forms\ControlTests.ControlCollection.cs (21)

System\Windows\Forms\ControlTests.cs (7)

79Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 168Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 180Assert.Equal(expectedText, control.Text); 264Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 276Assert.Equal(expectedText, control.Text); 360Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 456Assert.Equal("Microsoft\u00AE .NET", control.ProductName);

System\Windows\Forms\ControlTests.Handlers.cs (9)

2256Assert.Equal(expectedText, control.Text); 2264Assert.Equal(expectedText, control.Text); 2404Assert.Equal(expectedText, control.Text); 2412Assert.Equal(expectedText, control.Text); 2537Assert.Equal(expectedText, control.Text); 2545Assert.Equal(expectedText, control.Text); 4752Assert.Equal(longString, control.Text); 4850Assert.Equal("Bounds", e.AffectedProperty); 4895Assert.Equal("Bounds", e.AffectedProperty);

System\Windows\Forms\ControlTests.Methods.cs (67)

System\Windows\Forms\ControlTests.Properties.cs (106)

System\Windows\Forms\CreateParamsTests.cs (3)

19Assert.Equal(value, createParams.ClassName); 30Assert.Equal(value, createParams.Caption); 148Assert.Equal("CreateParams {'className', 'caption', 0xa, 0xb, {12, 13, 14, 15}}", createParams.ToString());

System\Windows\Forms\CursorTests.cs (2)

494Assert.Equal("[Cursor: AppStarting]", cursor.ToString()); 501Assert.Equal("[Cursor: System.Windows.Forms.Cursor]", cursor.ToString());

System\Windows\Forms\DataFormatsTests.ClipboardTests.cs (1)

26Assert.Equal(expectedName, result.Name);

System\Windows\Forms\DataFormatsTests.cs (5)

40Assert.Equal(expected, value); 69Assert.Equal(expectedName, result.Name); 93Assert.Equal(expectedName, result.Name); 154Assert.Equal(expectedName, result.Name); 165Assert.Equal(name, format.Name);

System\Windows\Forms\DataGridViewCellErrorTextNeededEventArgsTests.cs (1)

24Assert.Equal(value, e.ErrorText);

System\Windows\Forms\DataGridViewCellPaintingEventArgsTests.cs (1)

34Assert.Equal(errorText, e.ErrorText);

System\Windows\Forms\DataGridViewCellStyleTests.cs (9)

65Assert.Equal("format", style.Format); 325Assert.Equal(expected, style.Format); 329Assert.Equal(expected, style.Format); 341Assert.Equal(expected, style.Format); 644Assert.Equal("format", style.Format); 686Assert.Equal("format", style.Format); 734Assert.Equal("format", style.Format); 801Assert.Equal("format", style.Format); 1150Assert.Equal(expected, style.ToString());

System\Windows\Forms\DataGridViewCellTests.cs (84)

System\Windows\Forms\DataGridViewColumnTests.cs (9)

666Assert.Equal(expected, column.DataPropertyName); 670Assert.Equal(expected, column.DataPropertyName); 686Assert.Equal(expected, column.DataPropertyName); 691Assert.Equal(expected, column.DataPropertyName); 716Assert.Equal("text", column.DataPropertyName); 721Assert.Equal("text", column.DataPropertyName); 732Assert.Equal("text", column.DataPropertyName); 1789Assert.Equal("DataGridViewColumn { Name=, Index=-1 }", column.ToString()); 1799Assert.Equal("DataGridViewColumn { Name=name, Index=-1 }", column.ToString());

System\Windows\Forms\DataGridViewHeaderCellTests.cs (8)

2048Assert.Equal("errorText", cell.ErrorText); 2062Assert.Equal("toolTipText", cell.ToolTipText); 2134Assert.Equal("errorText", cell.ErrorText); 2148Assert.Equal("toolTipText", cell.ToolTipText); 4630Assert.Equal("DataGridViewHeaderCell { ColumnIndex=-1, RowIndex=-1 }", cell.ToString()); 4639Assert.Equal("DataGridViewHeaderCell { ColumnIndex=-1, RowIndex=-1 }", cell.ToString()); 4648Assert.Equal("DataGridViewColumnHeaderCell { ColumnIndex=-1 }", cell.ToString()); 4662Assert.Equal("DataGridViewHeaderCell { ColumnIndex=0, RowIndex=0 }", cell.ToString());

System\Windows\Forms\DataGridViewRowErrorTextNeededEventArgsTests.cs (1)

24Assert.Equal(value, e.ErrorText);

System\Windows\Forms\DataGridViewRowPostPaintEventArgsTests.cs (1)

31Assert.Equal(errorText, e.ErrorText);

System\Windows\Forms\DataGridViewRowPrePaintEventArgsTests.cs (1)

30Assert.Equal(errorText, e.ErrorText);

System\Windows\Forms\DataGridViewRowTests.cs (22)

919Assert.Equal("errorText1", e.ErrorText); 954Assert.Equal("errorText1", e.ErrorText); 958Assert.Equal("errorText2", row.ErrorText); 963Assert.Equal("errorText1", row.ErrorText); 987Assert.Equal(expected, row.ErrorText); 991Assert.Equal(expected, row.ErrorText); 1004Assert.Equal(expected, row.ErrorText); 1008Assert.Equal(expected, row.ErrorText); 1023Assert.Equal(expected, row.ErrorText); 1028Assert.Equal(expected, row.ErrorText); 1045Assert.Equal(expected, row.ErrorText); 1050Assert.Equal(expected, row.ErrorText); 1075Assert.Equal("errorText", row.ErrorText); 1080Assert.Equal("errorText", row.ErrorText); 1090Assert.Equal("other", row.ErrorText); 1096Assert.Equal("errorText", row.ErrorText); 3948Assert.Equal("errorText", row.ErrorText); 3991Assert.Equal("errorText", row.ErrorText); 4040Assert.Equal("errorText", row.ErrorText); 4395Assert.Equal("ErrorText", row.GetErrorText(rowIndex)); 4473Assert.Equal("ErrorText2", row.GetErrorText(0)); 4478Assert.Equal("ErrorText1", row.GetErrorText(0));

System\Windows\Forms\DataGridViewTests.cs (4)

128Assert.Equal("ColumnHeadersHeight", e.AffectedProperty); 275Assert.Equal("ColumnHeadersHeight", e.AffectedProperty); 1045Assert.Equal("RowHeadersWidth", e.AffectedProperty); 1199Assert.Equal("RowHeadersWidth", e.AffectedProperty);

System\Windows\Forms\DataGridViewTextBoxEditingControlTests.cs (26)

System\Windows\Forms\DateTimePickerTests.cs (10)

97Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 115Assert.Equal(string.Empty, control.Text); 132Assert.Equal("SysDateTimePick32", createParams.ClassName); 921Assert.Equal(dt.ToLongDateString(), dateTimePicker.Text); 934Assert.Equal(dt.ToShortDateString(), dateTimePicker.Text); 947Assert.Equal(dt.ToLongTimeString(), dateTimePicker.Text); 961Assert.Equal(dt.ToLongDateString(), dateTimePicker.Text); 975Assert.Equal(dt.ToShortDateString(), dateTimePicker.Text); 989Assert.Equal(dt.ToLongTimeString(), dateTimePicker.Text); 1003Assert.Equal(dt.ToShortTimeString(), dateTimePicker.Text);

System\Windows\Forms\Design\ComponentEditorFormTests.cs (3)

132Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 151Assert.Equal("Properties", control.Text); 174Assert.Equal("Properties", createParams.Caption);

System\Windows\Forms\Design\ComponentEditorPageTests.cs (15)

103Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 384Assert.Equal(expected, control.Text); 385Assert.Equal(expected, control.Title); 390Assert.Equal(expected, control.Text); 391Assert.Equal(expected, control.Title); 409Assert.Equal(expected, control.Text); 410Assert.Equal(expected, control.Title); 418Assert.Equal(expected, control.Text); 419Assert.Equal(expected, control.Title); 441Assert.Equal("text", control.Text); 442Assert.Equal("text", control.Title); 447Assert.Equal("text", control.Text); 448Assert.Equal("text", control.Title); 460Assert.Equal("text", control.Text); 461Assert.Equal("text", control.Title);

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

20Assert.Equal("Events", tab.HelpKeyword); 21Assert.Equal("Events", tab.TabName);

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

20Assert.Equal("TabName", tab.HelpKeyword); 131Assert.Equal("Value", tab.GetDefaultProperty(new ClassWithDefaultProperty()).Name);

System\Windows\Forms\DockPaddingEdgesConverterTests.cs (5)

17Assert.Equal(nameof(ScrollableControl.DockPaddingEdges.All), properties[0].Name); 18Assert.Equal(nameof(ScrollableControl.DockPaddingEdges.Left), properties[1].Name); 19Assert.Equal(nameof(ScrollableControl.DockPaddingEdges.Top), properties[2].Name); 20Assert.Equal(nameof(ScrollableControl.DockPaddingEdges.Right), properties[3].Name); 21Assert.Equal(nameof(ScrollableControl.DockPaddingEdges.Bottom), properties[4].Name);

System\Windows\Forms\DockPaddingEdgesTests.cs (2)

365Assert.Equal("{Left=1,Top=2,Right=3,Bottom=4}", padding.ToString()); 377Assert.Equal("{Left=1,Top=2,Right=3,Bottom=4}", padding.ToString());

System\Windows\Forms\DragDropHelperTests.cs (6)

190Assert.Equal(string.Empty, szMessage); 191Assert.Equal(string.Empty, szInsert); 273Assert.Equal(e.Message, szMessage); 274Assert.Equal(e.MessageReplacementToken, szInsert); 300Assert.Equal(message, szMessage); 301Assert.Equal(messageReplacementToken, szInsert);

System\Windows\Forms\DragEventArgsTests.cs (4)

47Assert.Equal(message, e.Message); 48Assert.Equal(messageReplacementToken, e.MessageReplacementToken); 84Assert.Equal(value, e.Message); 96Assert.Equal(value, e.MessageReplacementToken);

System\Windows\Forms\DrawToolTipEventArgsTests.cs (1)

29Assert.Equal(toolTipText, e.ToolTipText);

System\Windows\Forms\ErrorProviderTests.cs (19)

System\Windows\Forms\FileDialogTests.cs (11)

System\Windows\Forms\FlowLayoutPanelTests.cs (4)

95Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 154Assert.Equal("FlowDirection", e.AffectedProperty); 189Assert.Equal("WrapContents", e.AffectedProperty); 369Assert.Equal("FlowBreak", eventArgs.AffectedProperty);

System\Windows\Forms\FlowLayoutSettingsTests.cs (3)

26Assert.Equal("FlowDirection", e.AffectedProperty); 70Assert.Equal("WrapContents", e.AffectedProperty); 188Assert.Equal("FlowBreak", eventArgs.AffectedProperty);

System\Windows\Forms\FolderBrowserDialogTests.cs (8)

78Assert.Equal(value ?? string.Empty, dialog.Description); 82Assert.Equal(value ?? string.Empty, dialog.Description); 147Assert.Equal(value ?? string.Empty, dialog.InitialDirectory); 151Assert.Equal(value ?? string.Empty, dialog.InitialDirectory); 164Assert.Equal(value ?? string.Empty, dialog.SelectedPath); 169Assert.Equal(dialog.SelectedPath, dialog.SelectedPaths[0]); 179Assert.Equal(value ?? string.Empty, dialog.SelectedPath); 183Assert.Equal(dialog.SelectedPath, dialog.SelectedPaths[0]);

System\Windows\Forms\FontDialogTests.cs (1)

749Assert.Equal($"System.Windows.Forms.Tests.FontDialogTests+SubFontDialog, Font: {Control.DefaultFont}", dialog.ToString());

System\Windows\Forms\FormTests.cs (1)

134Assert.Equal("Microsoft\u00AE .NET", control.ProductName);

System\Windows\Forms\GroupBoxTests.cs (21)

System\Windows\Forms\HelpProviderTests.cs (21)

System\Windows\Forms\HScrollBarTests.cs (2)

94Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 126Assert.Equal("ScrollBar", createParams.ClassName);

System\Windows\Forms\HtmlDocumentTests.cs (71)

System\Windows\Forms\HtmlElementTests.cs (181)

System\Windows\Forms\HtmlToClrEventProxyTest.cs (5)

24Assert.Equal("OnHtmlEvent", onHtmlEvent.ToString()); 30Assert.Equal("EventName", eventName.ToString()); 36Assert.Equal("get_EventName", getEventName.ToString()); 83Assert.Equal(eventName, (string)result.ToObject()); 90Assert.Equal(eventName, (string)result.ToObject());

System\Windows\Forms\InputLanguageTests.cs (3)

187Assert.Equal(languageTag, language.Culture.Name); 188Assert.Equal(layoutId, language.LayoutId); 189Assert.Equal(layoutName, language.LayoutName);

System\Windows\Forms\KeysConverterTests.cs (2)

69Assert.Equal(expectedResult, result); 82Assert.Equal(expectedLocalizedKeyName, result);

System\Windows\Forms\LabelEditEventArgsTests.cs (1)

29Assert.Equal(label, e.Label);

System\Windows\Forms\LabelTests.cs (9)

87Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 123Assert.Equal("Static", createParams.ClassName); 189Assert.Equal(string.Empty, control.ImageKey); 195Assert.Equal(string.Empty, control.ImageKey); 205Assert.Equal(key, control.ImageKey); 211Assert.Equal(key, control.ImageKey); 659Assert.Equal("key1", label.ImageKey); 663Assert.Equal("key2", label.ImageKey); 667Assert.Equal("nonexistent", label.ImageKey);

System\Windows\Forms\Layout\TableLayoutSettingsTests.cs (16)

58Assert.Equal("Columns", e.AffectedProperty); 95Assert.Equal("GrowStyle", e.AffectedProperty); 132Assert.Equal("Rows", e.AffectedProperty); 513Assert.Equal("TableIndex", eventArgs.AffectedProperty); 586Assert.Equal("TableIndex", eventArgs.AffectedProperty); 732Assert.Equal("TableIndex", eventArgs.AffectedProperty); 967Assert.Equal("ColumnSpan", eventArgs.AffectedProperty); 1208Assert.Equal("TableIndex", eventArgs.AffectedProperty); 1443Assert.Equal("RowSpan", eventArgs.AffectedProperty); 1637Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", info.GetString("SerializedString")); 1650Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", info.GetString("SerializedString")); 1682Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles=""Percent,1"" /><Rows Styles=""Percent,2"" /></TableLayoutSettings>", info.GetString("SerializedString")); 1689Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls><Control Name=""name"" Row=""4"" RowSpan=""2"" Column=""3"" ColumnSpan=""1"" /><Control Name="""" Row=""-1"" RowSpan=""1"" Column=""-1"" ColumnSpan=""1"" /></Controls><Columns Styles=""Percent,1"" /><Rows Styles=""Percent,2"" /></TableLayoutSettings>", info.GetString("SerializedString")); 1718Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls><Control Name=""name"" Row=""4"" RowSpan=""2"" Column=""3"" ColumnSpan=""1"" /><Control Name="""" Row=""1"" RowSpan=""1"" Column=""1"" ColumnSpan=""1"" /></Controls><Columns Styles=""Percent,1"" /><Rows Styles=""Percent,2"" /></TableLayoutSettings>", info.GetString("SerializedString")); 1734Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", info.GetString("SerializedString")); 1748Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", info.GetString("SerializedString"));

System\Windows\Forms\Layout\TableLayoutSettingsTypeConverterTests.cs (6)

167Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", result); 190Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles=""AutoSize,1,Absolute,2"" /><Rows Styles=""AutoSize,1,Absolute,2"" /></TableLayoutSettings>", result); 208Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls><Control Name="""" Row=""4"" RowSpan=""2"" Column=""3"" ColumnSpan=""1"" /></Controls><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", result); 217Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", result); 231Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls><Control Name=""name"" Row=""4"" RowSpan=""2"" Column=""3"" ColumnSpan=""1"" /></Controls><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", result); 253Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", result);

System\Windows\Forms\LayoutEventArgsTests.cs (2)

25Assert.Equal(affectedProperty, e.AffectedProperty); 42Assert.Equal(affectedProperty, e.AffectedProperty);

System\Windows\Forms\LinkAreaConverterTests.cs (2)

206Assert.Equal(nameof(LinkArea.Start), properties[0].Name); 207Assert.Equal(nameof(LinkArea.Length), properties[1].Name);

System\Windows\Forms\LinkAreaTests.cs (1)

92Assert.Equal("{Start=1, Length=2}", area.ToString());

System\Windows\Forms\LinkClickedEventArgsTests.cs (1)

16Assert.Equal(linkText, e.LinkText);

System\Windows\Forms\LinkConverterTests.cs (2)

141Assert.Equal(expectedLink.Description, actualLink.Description); 145Assert.Equal(expectedLink.Name, actualLink.Name);

System\Windows\Forms\LinkTests.cs (2)

136Assert.Equal(expected, link.Name); 140Assert.Equal(expected, link.Name);

System\Windows\Forms\ListBindingHelperTests.cs (1)

497Assert.Equal(expected, ListBindingHelper.GetListName(list, listAccessors));

System\Windows\Forms\ListBox.ObjectCollectionTests.cs (360)

System\Windows\Forms\ListBoxTests.cs (24)

System\Windows\Forms\ListControlTests.cs (95)

System\Windows\Forms\ListViewGroupCollectionTests.cs (2)

510Assert.Equal(key, group.Name); 511Assert.Equal(expectedHeaderText, group.Header);

System\Windows\Forms\ListViewGroupTests.cs (60)

System\Windows\Forms\ListViewItem.IKeyboardToolTipTests.cs (1)

93Assert.Equal(toolTipText, ((IKeyboardToolTip)listViewItem).GetCaptionForTool(toolTip));

System\Windows\Forms\ListViewItemTests.cs (20)

System\Windows\Forms\ListViewSubItemCollectionTests.cs (5)

252Assert.Equal(expectedText, subItem.Text); 382Assert.Equal("text1", collection[0].Text); 383Assert.Equal("text2", collection[1].Text); 403Assert.Equal("text1", collection[0].Text); 407Assert.Equal("text2", collection[1].Text);

System\Windows\Forms\ListViewSubItemTests.cs (12)

System\Windows\Forms\ListViewTests.cs (9)

117Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 162Assert.Equal("SysListView32", createParams.ClassName); 1943Assert.Equal("ListViewGroup", new string(lvgroup1.pszHeader)); 1958Assert.Equal(expectedHeaderText, new string(lvgroup2.pszHeader)); 1959Assert.Equal(expectedFooterText, new string(lvgroup2.pszFooter)); 4841Assert.Equal("Test caption", wrapper.Text); 4843Assert.Equal(string.Empty, new string(wrapper.Info.lpszText)); 5130Assert.Equal(text, actual); 5235Assert.Equal(expectedColumnName, accessibleObject.AnnouncedColumn);

System\Windows\Forms\MdiClientTests.cs (9)

69Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 502Assert.Equal("Bounds", e.AffectedProperty); 597Assert.Equal("Bounds", e.AffectedProperty); 710Assert.Equal("Bounds", e.AffectedProperty); 751Assert.Equal("Bounds", e.AffectedProperty); 862Assert.Equal("Bounds", e.AffectedProperty); 903Assert.Equal("Bounds", e.AffectedProperty); 1024Assert.Equal("Bounds", e.AffectedProperty); 1065Assert.Equal("Bounds", e.AffectedProperty);

System\Windows\Forms\MdiControlStripTests.cs (12)

226Assert.Equal("System", systemItem.Name); 227Assert.Equal("Test1", test1Item.Name); 228Assert.Equal("Test2", test2Item.Name); 229Assert.Equal("Minimize", minimizeItem.Name); 230Assert.Equal("Restore", restoreItem.Name); 231Assert.Equal("Close", closeItem.Name); 272Assert.Equal("Close", closeItem.Name); 273Assert.Equal("Restore", restoreItem.Name); 274Assert.Equal("Minimize", minimizeItem.Name); 275Assert.Equal("Test2", test2Item.Name); 276Assert.Equal("Test1", test1Item.Name); 277Assert.Equal("System", systemItem.Name);

System\Windows\Forms\MenuStripTests.cs (4)

120Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 248Assert.Equal("GripStyle", e.AffectedProperty); 282Assert.Equal("GripStyle", e.AffectedProperty); 451Assert.Equal(text, item.Text);

System\Windows\Forms\MessageTests.cs (1)

506Assert.Equal($"msg=0x{msg:x}{expected} hwnd=0x1 wparam=0x2 lparam=0x3{additionalMsg} result=0x4", message.ToString());

System\Windows\Forms\MonthCalendarTests.cs (11)

106Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 151Assert.Equal("SysMonthCal32", createParams.ClassName); 1734Assert.Equal("RightToLeftLayout", e.AffectedProperty); 1781Assert.Equal("RightToLeftLayout", e.AffectedProperty); 2639Assert.Equal(expected, control.Text); 2644Assert.Equal(expected, control.Text); 2662Assert.Equal(expected, control.Text); 2670Assert.Equal(expected, control.Text); 2692Assert.Equal("text", control.Text); 2697Assert.Equal("text", control.Text); 2708Assert.Equal("text", control.Text);

System\Windows\Forms\NativeWindowTests.cs (1)

153Assert.Equal(expectedCaption, cp.Caption);

System\Windows\Forms\NodeLabelEditEventArgsTests.cs (1)

38Assert.Equal(label, e.Label);

System\Windows\Forms\NotifyIconTests.cs (20)

System\Windows\Forms\OwnerDrawPropertyBagTests.cs (2)

86Assert.Equal(SystemFonts.MenuFont.Name, bag.Font.Name); 125Assert.Equal(SystemFonts.MenuFont.Name, bag.Font.Name);

System\Windows\Forms\PaddingConverterTests.cs (5)

405Assert.Equal(nameof(Padding.All), properties[0].Name); 406Assert.Equal(nameof(Padding.Left), properties[1].Name); 407Assert.Equal(nameof(Padding.Top), properties[2].Name); 408Assert.Equal(nameof(Padding.Right), properties[3].Name); 409Assert.Equal(nameof(Padding.Bottom), properties[4].Name);

System\Windows\Forms\PaddingTests.cs (2)

409Assert.Equal("{Left=1,Top=2,Right=3,Bottom=4}", padding.ToString()); 416Assert.Equal("{Left=1,Top=1,Right=1,Bottom=1}", padding.ToString());

System\Windows\Forms\PanelTests.cs (16)

95Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 267Assert.Equal("AutoSize", e.AffectedProperty); 316Assert.Equal("AutoSize", e.AffectedProperty); 415Assert.Equal("AutoSize", e.AffectedProperty); 488Assert.Equal("AutoSize", e.AffectedProperty); 756Assert.Equal(expected, control.Text); 761Assert.Equal(expected, control.Text); 779Assert.Equal(expected, control.Text); 787Assert.Equal(expected, control.Text); 809Assert.Equal("text", control.Text); 814Assert.Equal("text", control.Text); 825Assert.Equal("text", control.Text); 977Assert.Equal("Bounds", e.AffectedProperty); 1022Assert.Equal("Bounds", e.AffectedProperty); 1104Assert.Equal("Bounds", e.AffectedProperty); 1139Assert.Equal("System.Windows.Forms.Panel, BorderStyle: System.Windows.Forms.BorderStyle.Fixed3D", panel.ToString());

System\Windows\Forms\PictureBoxTests.cs (54)

System\Windows\Forms\ProgressBarTests.cs (13)

112Assert.Equal("msctls_progress32", createParams.ClassName); 151Assert.Equal("msctls_progress32", createParams.ClassName); 180Assert.Equal("msctls_progress32", createParams.ClassName); 1199Assert.Equal("RightToLeftLayout", e.AffectedProperty); 1246Assert.Equal("RightToLeftLayout", e.AffectedProperty); 1613Assert.Equal(expected, control.Text); 1618Assert.Equal(expected, control.Text); 1636Assert.Equal(expected, control.Text); 1644Assert.Equal(expected, control.Text); 1666Assert.Equal("text", control.Text); 1671Assert.Equal("text", control.Text); 1682Assert.Equal("text", control.Text); 2579Assert.Equal("System.Windows.Forms.ProgressBar, Minimum: 0, Maximum: 100, Value: 0", control.ToString());

System\Windows\Forms\PropertyGridInternal\AccessibleObjects\PropertyDescriptorGridEntry.PropertyDescriptorGridEntryAccessibleObjectTests.cs (1)

75Assert.Equal(gridEntry.PropertyName, selectedGridEntry.PropertyName);

System\Windows\Forms\PropertyGridInternal\AccessibleObjects\PropertyGridView.GridViewTextBox.GridViewTextBoxAccessibleObjectTests.cs (5)

32Assert.Equal(gridEntry.PropertyName, selectedGridEntry.PropertyName); 42Assert.Equal("GridViewTextBoxAccessibleObject", editFieldAccessibleObject.GetType().Name); 67Assert.Equal("GridViewTextBoxAccessibleObject", editFieldAccessibleObject.GetType().Name); 77Assert.Equal("DropDownHolderAccessibleObject", dropDownHolderAccessibleObject.GetType().Name); 163Assert.Equal("WinForm", ((BSTR)accessibleObject.GetPropertyValue(UIA_PROPERTY_ID.UIA_FrameworkIdPropertyId)).ToStringAndFree());

System\Windows\Forms\PropertyGridInternal\PropertiesTabTests.cs (3)

19Assert.Equal("vs.properties", tab.HelpKeyword); 35Assert.Equal("Name", tab.GetDefaultProperty(new ClassWithNameProperty()).Name); 42Assert.Equal("Value", tab.GetDefaultProperty(new ClassWithDefaultProperty()).Name);

System\Windows\Forms\PropertyGridInternal\PropertyGridView.DropDownHolderTests.cs (1)

37Assert.Equal("DropDownHolderAccessibleObject", accessibleObject.GetType().Name);

System\Windows\Forms\PropertyGridInternal\PropertyGridView.GridViewListBoxTests.cs (1)

29Assert.Equal("GridViewListBoxAccessibleObject", gridViewListBoxAccessibleObjectType.Name);

System\Windows\Forms\PropertyGridTests.cs (13)

130Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 205Assert.Equal("AutoScroll", e.AffectedProperty); 248Assert.Equal("AutoScroll", e.AffectedProperty); 3008Assert.Equal(expected, control.Text); 3013Assert.Equal(expected, control.Text); 3031Assert.Equal(expected, control.Text); 3039Assert.Equal(expected, control.Text); 3063Assert.Equal("text", control.Text); 3068Assert.Equal("text", control.Text); 3079Assert.Equal("text", control.Text); 3932Assert.Equal("System.Object", selectedItem.Label); 3947Assert.Equal( 3975Assert.Equal("123", myClass.ParentGridEntry.NestedGridEntry);

System\Windows\Forms\PropertyManagerTests.cs (1)

39Assert.Equal("System.Windows.Forms.Tests.PropertyManagerTests+DataSource.", manager.GetListName());

System\Windows\Forms\QueryAccessibilityHelpEventArgsTests.cs (6)

25Assert.Equal(helpNamespace, e.HelpNamespace); 26Assert.Equal(helpString, e.HelpString); 27Assert.Equal(helpKeyword, e.HelpKeyword); 45Assert.Equal(value, e.HelpNamespace); 56Assert.Equal(value, e.HelpString); 67Assert.Equal(value, e.HelpKeyword);

System\Windows\Forms\RadioButtonTests.cs (6)

95Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 129Assert.Equal("Button", createParams.ClassName); 153Assert.Equal("Button", createParams.ClassName); 519Assert.Equal(defaultActionDescription, instance.DefaultAction); 1512Assert.Equal("System.Windows.Forms.RadioButton, Checked: False", control.ToString()); 1522Assert.Equal("System.Windows.Forms.RadioButton, Checked: False", control.ToString());

System\Windows\Forms\RichTextBoxTests.cs (99)

System\Windows\Forms\RowStyleTests.cs (2)

76Assert.Equal("Style", e.AffectedProperty); 113Assert.Equal("Style", e.AffectedProperty);

System\Windows\Forms\ScreenTests.cs (2)

210Assert.Equal($"Screen[Bounds={screen.Bounds} WorkingArea={screen.WorkingArea} Primary=True DeviceName={screen.DeviceName}", screen.ToString()); 219Assert.Equal(screen.DeviceName, screen.DeviceName.Trim('\0'));

System\Windows\Forms\ScrollableControlTests.cs (6)

94Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 249Assert.Equal("AutoScroll", e.AffectedProperty); 292Assert.Equal("AutoScroll", e.AffectedProperty); 798Assert.Equal("Padding", e.AffectedProperty); 1899Assert.Equal("RightToLeft", e.AffectedProperty); 1944Assert.Equal("RightToLeft", e.AffectedProperty);

System\Windows\Forms\ScrollBarTests.cs (11)

83Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 114Assert.Equal("ScrollBar", createParams.ClassName); 1482Assert.Equal(expected, control.Text); 1487Assert.Equal(expected, control.Text); 1505Assert.Equal(expected, control.Text); 1513Assert.Equal(expected, control.Text); 1535Assert.Equal("text", control.Text); 1540Assert.Equal("text", control.Text); 1551Assert.Equal("text", control.Text); 1753Assert.Equal(expectedMessage, ex.Message); 2667Assert.Equal("System.Windows.Forms.Tests.ScrollBarTests+SubScrollBar, Minimum: 0, Maximum: 100, Value: 0", control.ToString());

System\Windows\Forms\SearchForVirtualItemEventArgsTests.cs (1)

27Assert.Equal(text, e.Text);

System\Windows\Forms\SplitterPanelTests.cs (12)

85Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 675Assert.Equal("Bounds", e.AffectedProperty); 701Assert.Equal(expected, control.Name); 706Assert.Equal(expected, control.Name); 793Assert.Equal("Bounds", e.AffectedProperty); 1034Assert.Equal(expected, control.Text); 1039Assert.Equal(expected, control.Text); 1057Assert.Equal(expected, control.Text); 1065Assert.Equal(expected, control.Text); 1087Assert.Equal("text", control.Text); 1092Assert.Equal("text", control.Text); 1103Assert.Equal("text", control.Text);

System\Windows\Forms\SplitterTests.cs (8)

83Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 544Assert.Equal("Dock", e.AffectedProperty); 613Assert.Equal("Dock", e.AffectedProperty); 1559Assert.Equal(expected, control.Text); 1564Assert.Equal(expected, control.Text); 1582Assert.Equal(expected, control.Text); 1590Assert.Equal(expected, control.Text); 2300Assert.Equal("System.Windows.Forms.Splitter, MinExtra: 25, MinSize: 25", control.ToString());

System\Windows\Forms\StatusStripTests.cs (4)

119Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 330Assert.Equal("GripStyle", e.AffectedProperty); 413Assert.Equal("Padding", e.AffectedProperty); 886Assert.Equal(text, button.Text);

System\Windows\Forms\SystemInformationTests.cs (6)

109Assert.Equal(name, name.Trim('\0')); 110Assert.Equal(name, SystemInformation.ComputerName); 727Assert.Equal(Environment.UserDomainName, domainName); 728Assert.Equal(domainName, SystemInformation.UserDomainName); 742Assert.Equal(name, name.Trim('\0')); 743Assert.Equal(name, SystemInformation.UserName);

System\Windows\Forms\TabControl.ControlCollectionTests.cs (78)

System\Windows\Forms\TabControl.TabPageCollectionTests.cs (201)

System\Windows\Forms\TabControlTests.cs (27)

System\Windows\Forms\TableLayoutPanelCellPositionTests.cs (3)

95Assert.Equal("1,2", position.ToString()); 318Assert.Equal(nameof(TableLayoutPanelCellPosition.Column), properties[0].Name); 319Assert.Equal(nameof(TableLayoutPanelCellPosition.Row), properties[1].Name);

System\Windows\Forms\TableLayoutPanelTests.cs (15)

System\Windows\Forms\TableLayoutStyleTests.cs (2)

51Assert.Equal("Style", e.AffectedProperty); 90Assert.Equal("Style", e.AffectedProperty);

System\Windows\Forms\TabPageTests.cs (71)

System\Windows\Forms\TabPageTests.TabPageControlCollection.cs (1)

37Assert.Equal(affectedProperty, e.AffectedProperty);

System\Windows\Forms\TextBoxBase.TextBoxBaseUiaTextProviderTests.cs (3)

528Assert.Equal(expected, actual); 543Assert.Equal(expected, actual); 927Assert.Equal("Segoe UI", actual);

System\Windows\Forms\TimerTests.cs (1)

454Assert.Equal("System.Windows.Forms.Timer, Interval: 100", timer.ToString());

System\Windows\Forms\ToolStripButtonTests.cs (11)

166Assert.Equal(text, item.Text); 170Assert.Equal(text, item.ToolTipText); 343Assert.Equal(text, item.Text); 347Assert.Equal(text, item.ToolTipText); 431Assert.Equal(text, item.Text); 435Assert.Equal(text, item.ToolTipText); 515Assert.Equal(expectedName, item.Name); 529Assert.Equal(text, item.Text); 533Assert.Equal(text, item.ToolTipText); 1315Assert.Equal("Text", e.Text); 1406Assert.Equal("Text", e.Text);

System\Windows\Forms\ToolStripContentPanelTests.cs (6)

97Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 154Assert.Equal("AutoScroll", e.AffectedProperty); 197Assert.Equal("AutoScroll", e.AffectedProperty); 1074Assert.Equal("Bounds", e.AffectedProperty); 1100Assert.Equal(expected, control.Name); 1105Assert.Equal(expected, control.Name);

System\Windows\Forms\ToolStripControlHostTests.cs (31)

System\Windows\Forms\ToolStripDropDownItemTests.cs (4)

174Assert.Equal(text, item.Text); 259Assert.Equal(expectedName, item.Name); 273Assert.Equal(text, item.Text); 381Assert.Equal(text, item.Text);

System\Windows\Forms\ToolStripDropDownTests.cs (16)

128Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 601Assert.Equal("Anchor", e.AffectedProperty); 674Assert.Equal("AutoSize", e.AffectedProperty); 712Assert.Equal("AutoSize", e.AffectedProperty); 1783Assert.Equal("GripStyle", e.AffectedProperty); 2387Assert.Equal("RightToLeft", e.AffectedProperty); 2674Assert.Equal(expected, control.Text); 2679Assert.Equal(expected, control.Text); 2697Assert.Equal(expected, control.Text); 2705Assert.Equal(expected, control.Text); 2727Assert.Equal("text", control.Text); 2732Assert.Equal("text", control.Text); 2743Assert.Equal("text", control.Text); 2760Assert.Equal("TextDirection", e.AffectedProperty); 2796Assert.Equal("TextDirection", e.AffectedProperty); 2963Assert.Equal(text, button.Text);

System\Windows\Forms\ToolStripItemCollectionTests.cs (3)

119Assert.Equal("a", contextMenuStrip.Items[0].Text); 120Assert.Equal("b", contextMenuStrip.Items[1].Text); 121Assert.Equal("c", contextMenuStrip.Items[2].Text);

System\Windows\Forms\ToolStripItemTests.cs (121)

System\Windows\Forms\ToolStripItemTextRenderEventArgsTests.cs (2)

27Assert.Equal(text, e.Text); 53Assert.Equal(text, e.Text);

System\Windows\Forms\ToolStripMenuItemTests.cs (1)

159Assert.Equal(expectedShortcutText, item.GetShortcutText());

System\Windows\Forms\ToolStripPanelTests.cs (1)

97Assert.Equal("Microsoft\u00AE .NET", control.ProductName);

System\Windows\Forms\ToolStripSeparatorTests.cs (11)

499Assert.Equal(expected, item.ImageKey); 505Assert.Equal(expected, item.ImageKey); 580Assert.Equal(value, item.Text); 584Assert.Equal(value, item.Text); 602Assert.Equal("value", item.Text); 607Assert.Equal("value", item.Text); 618Assert.Equal("value", item.Text); 713Assert.Equal(value, item.ToolTipText); 717Assert.Equal(value, item.ToolTipText); 1531Assert.Equal("Bounds", e.AffectedProperty); 1585Assert.Equal("Bounds", e.AffectedProperty);

System\Windows\Forms\ToolStripTests.cs (18)

System\Windows\Forms\ToolTipBufferTests.cs (7)

27Assert.Equal("text", Marshal.PtrToStringUni(memory2)); 53Assert.Equal("text", Marshal.PtrToStringUni(buffer.Buffer)); 59Assert.Equal(longer, Marshal.PtrToStringUni(memory2)); 73Assert.Equal("text", Marshal.PtrToStringUni(buffer.Buffer)); 79Assert.Equal(expected, Marshal.PtrToStringUni(memory2)); 90Assert.Equal("text", Marshal.PtrToStringUni(buffer.Buffer)); 96Assert.Equal(sameLength, Marshal.PtrToStringUni(memory2));

System\Windows\Forms\ToolTipTests.cs (8)

86Assert.Equal("tooltips_class32", createParams.ClassName); 573Assert.Equal(expected, toolTip.ToolTipTitle); 577Assert.Equal(expected, toolTip.ToolTipTitle); 676Assert.Equal(expected, toolTip.GetToolTip(control)); 680Assert.Equal(expected, toolTip.GetToolTip(control)); 697Assert.Equal(expected, toolTip.GetToolTip(control)); 701Assert.Equal(expected, toolTip.GetToolTip(control)); 783Assert.Equal("System.Windows.Forms.ToolTip InitialDelay: 500, ShowAlways: False", toolTip.ToString());

System\Windows\Forms\TreeNode.IKeyboardToolTipTests.cs (1)

89Assert.Equal(toolTipText, ((IKeyboardToolTip)treeNode).GetCaptionForTool(toolTip));

System\Windows\Forms\TreeNodeCollectionTests.cs (2)

28Assert.Equal(expectedText, treeNode.FullPath); 52Assert.Equal(expectedText, treeNode.Text);

System\Windows\Forms\TreeNodeTests.cs (65)

System\Windows\Forms\TreeViewTests.cs (72)

System\Windows\Forms\TypeValidationEventArgsTests.cs (1)

19Assert.Equal(message, e.Message);

System\Windows\Forms\UpDownBaseTests.cs (11)

109Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 1108Assert.Equal("Bounds", e.AffectedProperty); 1152Assert.Equal("Bounds", e.AffectedProperty); 1267Assert.Equal(expected, control.Text); 1276Assert.Equal(expected, control.Text); 1314Assert.Equal(expected, control.Text); 1326Assert.Equal(expected, control.Text); 1353Assert.Equal("text", control.Text); 1358Assert.Equal("text", control.Text); 1369Assert.Equal("text", control.Text); 2717Assert.Equal("Bounds", e.AffectedProperty);

System\Windows\Forms\UserControlTests.cs (19)

101Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 247Assert.Equal("AutoSize", e.AffectedProperty); 289Assert.Equal("AutoSize", e.AffectedProperty); 324Assert.Equal("AutoSize", e.AffectedProperty); 381Assert.Equal("AutoSize", e.AffectedProperty); 431Assert.Equal("AutoSize", e.AffectedProperty); 530Assert.Equal("AutoSize", e.AffectedProperty); 603Assert.Equal("AutoSize", e.AffectedProperty); 799Assert.Equal(expected, control.Text); 804Assert.Equal(expected, control.Text); 822Assert.Equal(expected, control.Text); 830Assert.Equal(expected, control.Text); 853Assert.Equal("text", control.Text); 858Assert.Equal("text", control.Text); 869Assert.Equal("text", control.Text); 1071Assert.Equal("Bounds", e.AffectedProperty); 1111Assert.Equal("Bounds", e.AffectedProperty); 1156Assert.Equal("Bounds", e.AffectedProperty); 1210Assert.Equal("Bounds", e.AffectedProperty);

System\Windows\Forms\VisualStyles\VisualStyleInformationTests.cs (9)

System\Windows\Forms\VisualStyles\VisualStyleRendererTests.cs (4)

29Assert.Equal(element.ClassName, renderer.Class); 63Assert.Equal(element.ClassName, renderer.Class); 517Assert.Equal(element.ClassName, renderer.Class); 538Assert.Equal(element.ClassName, renderer.Class);

System\Windows\Forms\VScrollBarTests.cs (2)

93Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 125Assert.Equal("ScrollBar", createParams.ClassName);

System\Windows\Forms\WebBrowserNavigatingEventArgsTests.cs (1)

18Assert.Equal(targetFrameName, e.TargetFrameName);

System\Windows\Forms\WebBrowserTests.cs (26)

TestAccessorTests.cs (1)

57Assert.Equal("42", list[0]);

TextBoxBaseTests.cs (80)

TextBoxTests.cs (4)

91Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 132Assert.Equal("Edit", createParams.ClassName); 347Assert.Equal(string.Empty, tb.PlaceholderText); 400Assert.Equal(string.Empty, tb.PlaceholderText);

TrackBarTests.cs (16)

85Assert.Equal("Microsoft\u00AE .NET", control.ProductName); 119Assert.Equal("msctls_trackbar32", createParams.ClassName); 147Assert.Equal("msctls_trackbar32", createParams.ClassName); 173Assert.Equal("msctls_trackbar32", createParams.ClassName); 204Assert.Equal("msctls_trackbar32", createParams.ClassName); 1565Assert.Equal("RightToLeftLayout", e.AffectedProperty); 1612Assert.Equal("RightToLeftLayout", e.AffectedProperty); 1779Assert.Equal(expected, control.Text); 1784Assert.Equal(expected, control.Text); 1802Assert.Equal(expected, control.Text); 1810Assert.Equal(expected, control.Text); 1832Assert.Equal("text", control.Text); 1837Assert.Equal("text", control.Text); 1848Assert.Equal("text", control.Text); 2961Assert.Equal("Bounds", e.AffectedProperty); 3112Assert.Equal("System.Windows.Forms.TrackBar, Minimum: 0, Maximum: 10, Value: 0", control.ToString());

WebBrowserBaseTests.cs (2)

40Assert.Equal("Bounds", e.AffectedProperty); 149Assert.Equal("Bounds", e.AffectedProperty);

DragDropTests.cs (14)

120Assert.Equal(button?.Name, ((Button)data).Name); 121Assert.Equal(button?.Text, ((Button)data).Text); 227Assert.Equal(dragAcceptRtfContent, dragDropForm.RichTextBoxDropTarget?.Rtf); 228Assert.Equal(dragAcceptRtfTextContent, dragDropForm.RichTextBoxDropTarget?.Text); 334Assert.Equal(listViewItem?.Name, ((ListViewItem)data).Name); 335Assert.Equal(listViewItem?.Text, ((ListViewItem)data).Text); 365Assert.Equal(message, e.Message); 366Assert.Equal(messageReplacementToken, e.MessageReplacementToken); 372Assert.Equal(message, e.Message); 373Assert.Equal(messageReplacementToken, e.MessageReplacementToken); 444Assert.Equal(dragAcceptRtfContent, form.RichTextBoxDropTarget?.Rtf); 445Assert.Equal(dragAcceptRtfTextContent, form.RichTextBoxDropTarget?.Text); 487Assert.Equal(dragAcceptRtfContent, form.RichTextBoxDropTarget?.Rtf); 488Assert.Equal(dragAcceptRtfTextContent, form.RichTextBoxDropTarget?.Text);

OpenFileDialogTests.cs (1)

45Assert.Equal(tempFile.Path, dialog.FileName);

RichTextBoxTests.cs (6)

56Assert.Equal(result.LinkText, richTextBox.Text.Substring(result.LinkStart, result.LinkLength)); 73Assert.Equal("Click link #2", displayText); 116Assert.Equal(result.LinkText, richTextBox.Text.Substring(result.LinkStart, result.LinkLength)); 131Assert.Equal("#link2#", hiddenText); 177Assert.Equal(result.LinkText, richTextBox.Text.Substring(result.LinkStart, result.LinkLength)); 192Assert.Equal("#link2#", hiddenText);

System\Windows\Markup\ConstructorArgumentAttributeTests.cs (1)

18Assert.Equal(argumentName, attribute.ArgumentName);

System\Windows\Markup\ContentPropertyAttributeTests.cs (1)

26Assert.Equal(name, attribute.Name);

System\Windows\Markup\DateTimeValueSerializerTests.cs (1)

43Assert.Equal(date.ToString(format, CultureInfo.InvariantCulture), serializer.ConvertToString(date, null));

System\Windows\Markup\DependsOnAttributeTests.cs (1)

18Assert.Equal(name, attribute.Name);

System\Windows\Markup\DictionaryKeyPropertyAttributeTests.cs (1)

19Assert.Equal(name, attribute.Name);

System\Windows\Markup\NameScopePropertyAttributeTests.cs (2)

18Assert.Equal(name, attribute.Name); 29Assert.Equal(name, attribute.Name);

System\Windows\Markup\ReferenceTests.cs (1)

28Assert.Equal(name, reference.Name);

System\Windows\Markup\RootNamespaceAttributeTests.cs (1)

18Assert.Equal(nameSpace, attribute.Namespace);

System\Windows\Markup\RuntimeNamePropertyAttributeTests.cs (1)

18Assert.Equal(name, attribute.Name);

System\Windows\Markup\StaticExtensionTests.cs (3)

29Assert.Equal(member, extension.Member); 161Assert.Equal(member, qualifiedTypeName); 175Assert.Equal(value, extension.Member);

System\Windows\Markup\TypeExtensionTests.cs (4)

31Assert.Equal(typeName, extension.TypeName); 72Assert.Equal("Type", qualifiedTypeName); 118Assert.Equal("typeName", qualifiedTypeName); 136Assert.Equal(value, extension.TypeName);

System\Windows\Markup\UidPropertyAttributeTests.cs (1)

18Assert.Equal(name, attribute.Name);

System\Windows\Markup\ValueSerializerTests.cs (1)

165Assert.Equal("1", serializer.ConvertToString(1, null));

System\Windows\Markup\XamlDeferLoadAttributeTests.cs (4)

19Assert.Equal(loaderType.AssemblyQualifiedName, attribute.LoaderTypeName); 21Assert.Equal(contentType.AssemblyQualifiedName, attribute.ContentTypeName); 43Assert.Equal(loaderType, attribute.LoaderTypeName); 45Assert.Equal(contentType, attribute.ContentTypeName);

System\Windows\Markup\XamlSetMarkupExtensionAttributeTests.cs (1)

18Assert.Equal(xamlSetMarkupExtensionHandler, attribute.XamlSetMarkupExtensionHandler);

System\Windows\Markup\XamlSetTypeConverterAttributeTests.cs (1)

18Assert.Equal(xamlSetTypeConverterHandler, attribute.XamlSetTypeConverterHandler);

System\Windows\Markup\XDataTests.cs (1)

27Assert.Equal(value, data.Text);

System\Windows\Markup\XmlLangPropertyAttributeTests.cs (1)

18Assert.Equal(name, attribute.Name);

System\Windows\Markup\XmlnsCompatibleWithAttributeTests.cs (2)

17Assert.Equal(oldNamespace, attribute.OldNamespace); 18Assert.Equal(newNamespace, attribute.NewNamespace);

System\Windows\Markup\XmlnsDefinitionAttributeTests.cs (2)

17Assert.Equal(xmlNamespace, attribute.XmlNamespace); 18Assert.Equal(clrNamespace, attribute.ClrNamespace);

System\Windows\Markup\XmlnsPrefixAttributeTests.cs (2)

17Assert.Equal(xmlNamespace, attribute.XmlNamespace); 18Assert.Equal(prefix, attribute.Prefix);

BlazorTemplateTest.cs (2)

121Assert.Equal("Home", (await page.TitleAsync()).Trim()); 174Assert.Equal(appName.Trim(), (await page.TitleAsync()).Trim());

BlazorWebTemplateTest.cs (1)

93Assert.Equal(expectedEncoding, response.Content.Headers.ContentEncoding.Single());

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

148Assert.Equal("stylesheet", styleSheet.Relation);

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

148Assert.Equal("stylesheet", styleSheet.Relation);

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

148Assert.Equal("stylesheet", styleSheet.Relation);

BlazorTemplateTest.cs (1)

112Assert.Equal("/Account/Login?ReturnUrl=%2Fauth", response.RequestMessage.RequestUri.PathAndQuery);

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

148Assert.Equal("stylesheet", styleSheet.Relation);

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

148Assert.Equal("stylesheet", styleSheet.Relation);

AnalyzerConsistencyCheckerTests.cs (1)

152Assert.Equal(mvidAlpha1.Path, mvidAlpha2.Path);

BuildClientTests.cs (11)

229Assert.Equal("pipe", _sessionKey); 234Assert.Equal("1:2", _sessionKey); 239Assert.Equal("1:2", _sessionKey); 250Assert.Equal(CodeAnalysisResources.SharedArgumentMissing, _errorMessage); 276Assert.Equal("100", _keepAlive); 286Assert.Equal(CodeAnalysisResources.MissingKeepAlive, _errorMessage); 289Assert.Equal(CodeAnalysisResources.MissingKeepAlive, _errorMessage); 292Assert.Equal(CodeAnalysisResources.KeepAliveIsTooSmall, _errorMessage); 295Assert.Equal(CodeAnalysisResources.KeepAliveWithoutShared, _errorMessage); 314Assert.Equal("100", _keepAlive); 320Assert.Equal("100", _keepAlive);

CompilerServerTests.cs (34)

TouchedFileLoggingTests.cs (4)

83Assert.Equal(string.Empty, outWriter.ToString().Trim()); 134Assert.Equal(string.Empty, outWriter.ToString().Trim()); 187Assert.Equal(string.Join("\r\n", expected), 191Assert.Equal(string.Join("\r\n", expected),

VBCSCompilerServerTests.cs (2)

430Assert.Equal("test", _pipeName); 446Assert.Equal("test", _pipeName);