Same

ConformanceTests.cs (3)

194Assert.Same(serviceFromFirstScope, serviceFromSecondScope); 195Assert.Same(serviceFromSecondScope, secondServiceFromSecondScope); 199Assert.Same(serviceFromSecondScope, secondServiceFromSecondScope);

Dashboard\DashboardResourceTests.cs (2)

96Assert.Same(container.Resource, dashboard); 416Assert.Same(ManifestPublishingCallbackAnnotation.Ignore, annotation);

EnrichSqlServerTests.cs (1)

169Assert.Same(oldOptionsDescriptor, optionsDescriptor);

ConformanceTests.cs (1)

113Assert.Same(mySqlDataSource, dbDataSource);

EnrichNpgsqlTests.cs (1)

173Assert.Same(oldOptionsDescriptor, optionsDescriptor);

ConformanceTests.cs (1)

115Assert.Same(npgsqlDataSource, dbDataSource);

EnrichOracleDatabaseTests.cs (1)

164Assert.Same(oldOptionsDescriptor, optionsDescriptor);

EnrichMySqlTests.cs (1)

182Assert.Same(oldOptionsDescriptor, optionsDescriptor);

DuplexChannelWithSynchronizationContext.cs (2)

62Assert.Same(syncCtx, callbackSyncContext); 126Assert.Same(syncCtx, callbackSyncContext);

MaxRequestBodySizeTests.cs (2)

362Assert.Same(thrownError, appErrorLog.Exception); 363Assert.Same(thrownError, badRequestLog.Exception);

EventSourceTests.cs (20)

Http2\Http2ConnectionTests.cs (5)

204Assert.Same(contentType1, contentType2); 205Assert.Same(authority1, authority2); 206Assert.Same(path1, path2); 4987Assert.Same(ioException, logMessage.Exception); 5004Assert.Same(exception, logMessage.Exception);

Http3\Http3ConnectionTests.cs (4)

401Assert.Same(streamContext1, streamContext2); 436Assert.Same(contentType1, contentType2); 437Assert.Same(authority1, authority2); 510Assert.Same(first, last);

HttpsTests.cs (1)

728Assert.Same(testCert, authOptions.ServerCertificate);

RequestTests.cs (2)

1312Assert.Same(originalRequestHeaders, requestFeature.Headers); 2119Assert.Same(initialContentTypeValue, contentTypeHeaderValue);

ResponseTests.cs (2)

2470Assert.Same(onStartingException, writeException.InnerException); 2857Assert.Same(originalResponseHeaders, responseFeature.Headers);

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

302Assert.Same(headers, ctx.Features.Get<IHttpRequestFeature>().Headers); 307Assert.Same(body, ctx.Request.Body); 342Assert.Same(headers, ctx.Features.Get<IHttpResponseFeature>().Headers); 348Assert.Same(body, ctx.Response.Body);

Http3\Http3RequestTests.cs (4)

362Assert.Same(contentType1, contentType2); 363Assert.Same(authority1, authority2); 950Assert.Same((string)request2Headers["alt-used"], (string)request3Headers["alt-used"]); 1376Assert.Same(request1HeaderValue, request2HeaderValue);

Components\DisallowNonLiteralSequenceNumbersTest.cs (3)

46Assert.Same(DiagnosticDescriptors.DoNotUseNonLiteralSequenceNumbers, diagnostic.Descriptor); 67Assert.Same(DiagnosticDescriptors.DoNotUseNonLiteralSequenceNumbers, diagnostic.Descriptor); 88Assert.Same(DiagnosticDescriptors.DoNotUseNonLiteralSequenceNumbers, diagnostic.Descriptor);

RouteEmbeddedLanguage\RoutePatternAnalyzerTests.cs (11)

RouteHandlers\DetectMisplacedLambdaAttributeTest.cs (6)

48Assert.Same(DiagnosticDescriptors.DetectMisplacedLambdaAttribute, diagnostic.Descriptor); 70Assert.Same(DiagnosticDescriptors.DetectMisplacedLambdaAttribute, diagnostic.Descriptor); 96Assert.Same(DiagnosticDescriptors.DetectMisplacedLambdaAttribute, diagnostic.Descriptor); 102Assert.Same(DiagnosticDescriptors.DetectMisplacedLambdaAttribute, diagnostic.Descriptor); 129Assert.Same(DiagnosticDescriptors.DetectMisplacedLambdaAttribute, diagnostic.Descriptor); 218Assert.Same(DiagnosticDescriptors.DetectMisplacedLambdaAttribute, diagnostic.Descriptor);

RouteHandlers\DisallowMvcBindArgumentsOnParametersTest.cs (2)

61Assert.Same(DiagnosticDescriptors.DoNotUseModelBindingAttributesOnRouteHandlerParameters, diagnostic.Descriptor); 83Assert.Same(DiagnosticDescriptors.DoNotUseModelBindingAttributesOnRouteHandlerParameters, diagnostic.Descriptor);

RouteHandlers\DisallowReturningActionResultsFromMapMethodsTest.cs (6)

130Assert.Same(DiagnosticDescriptors.DoNotReturnActionResultsFromRouteHandlers, diagnostic.Descriptor); 153Assert.Same(DiagnosticDescriptors.DoNotReturnActionResultsFromRouteHandlers, diagnostic.Descriptor); 181Assert.Same(DiagnosticDescriptors.DoNotReturnActionResultsFromRouteHandlers, diagnostic.Descriptor); 213Assert.Same(DiagnosticDescriptors.DoNotReturnActionResultsFromRouteHandlers, diagnostic.Descriptor); 251Assert.Same(DiagnosticDescriptors.DoNotReturnActionResultsFromRouteHandlers, diagnostic.Descriptor); 289Assert.Same(DiagnosticDescriptors.DoNotReturnActionResultsFromRouteHandlers, diagnostic.Descriptor);

WebApplicationBuilder\DisallowConfigureHostBuilderConfigureWebHostTest.cs (7)

45Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, diagnostic.Descriptor); 66Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, diagnostic.Descriptor); 88Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, diagnostic.Descriptor); 128Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, diagnostic.Descriptor); 156Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, diagnostic.Descriptor); 185Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, diagnostic.Descriptor); 219Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, diagnostic.Descriptor);

WebApplicationBuilder\DisallowConfigureHostLoggingTest.cs (1)

273Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor);

WebApplicationBuilder\DisallowConfigureServicesTest.cs (1)

284Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureServices, diagnostic.Descriptor);

WebApplicationBuilder\DisallowConfigureWebHostBuilderConfigureTest.cs (4)

47Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWithConfigureWebHostBuilder, diagnostic.Descriptor); 68Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWithConfigureWebHostBuilder, diagnostic.Descriptor); 95Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWithConfigureWebHostBuilder, diagnostic.Descriptor); 123Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWithConfigureWebHostBuilder, diagnostic.Descriptor);

WebApplicationBuilder\DisallowConfigureWebHostBuilderUseStartupTest.cs (6)

46Assert.Same(DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder, diagnostic.Descriptor); 67Assert.Same(DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder, diagnostic.Descriptor); 87Assert.Same(DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder, diagnostic.Descriptor); 108Assert.Same(DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder, diagnostic.Descriptor); 135Assert.Same(DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder, diagnostic.Descriptor); 163Assert.Same(DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder, diagnostic.Descriptor);

WebApplicationBuilder\UseTopLevelRouteRegistrationInsteadOfUseEndpointsTest.cs (9)

AuthenticationPropertiesTests.cs (6)

24Assert.Same(items, props.Items); 25Assert.Same(parameters, props.Parameters); 54Assert.Same(items, props.Items); 71Assert.Same(items, props.Items); 72Assert.Same(parameters, props.Parameters); 156Assert.Same(list, props.Parameters["foo"]);

AuthenticationSchemeProviderTests.cs (2)

190Assert.Same(a, b); 191Assert.Same(b, c);

AuthenticationTicketTests.cs (2)

27Assert.Same(items, ticket.Properties.Items); 28Assert.Same(parameters, ticket.Properties.Parameters);

AuthenticationMiddlewareTests.cs (4)

80Assert.Same(context.User, authenticateResultFeature.AuthenticateResult.Principal); 123Assert.Same(context.User, authenticateResultFeature.AuthenticateResult.Principal); 149Assert.Same(context.User, authenticateResultFeature.AuthenticateResult.Principal); 153Assert.Same(context.User, newTicket.Principal);

AuthorizationMiddlewareTests.cs (8)

ComponentInternalUsageDiagnosticsAnalyzerTest.cs (11)

AuthorizeViewTest.cs (1)

472Assert.Same(resource, call.resource);

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

126Assert.Same(action, frame.ElementReferenceCaptureAction); 140Assert.Same(action, frame.ComponentReferenceCaptureAction); 147Assert.Same(mode, frame.ComponentRenderMode);

RazorComponentResultTest.cs (1)

39Assert.Same(paramsDict, result.Parameters);

EditContextDataAnnotationsExtensionsTest.cs (1)

28Assert.Same(editContext, returnValue);

EditContextTest.cs (8)

20Assert.Same(model, editContext.Model); 32Assert.Same(model, fieldIdentifier.Model); 113Assert.Same(editContext, sender); 221Assert.Same(editContext, sender); 286Assert.Same(value1, editContext.Properties[key1]); 287Assert.Same(value2, editContext.Properties[key2]); 312Assert.Same(value1, retrievedValue1); 313Assert.Same(value2, retrievedValue2);

FieldIdentifierTest.cs (12)

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

126Assert.Same(action, frame.ElementReferenceCaptureAction); 140Assert.Same(action, frame.ComponentReferenceCaptureAction); 147Assert.Same(mode, frame.ComponentRenderMode);

ComponentInternalUsageDiagnosticsAnalyzerTest.cs (11)

Circuits\CircuitHostTest.cs (3)

154Assert.Same(componentException, eventArgs.ExceptionObject); 285Assert.Same(ex, aex.InnerExceptions.Single()); 745Assert.Same(Dispatcher, SynchronizationContext.Current);

Circuits\RevalidatingServerAuthenticationStateProviderTest.cs (2)

23Assert.Same(hostAuthStateTask, provider.GetAuthenticationStateAsync()); 28Assert.Same(hostAuthStateTask2, provider.GetAuthenticationStateAsync());

Circuits\ServerAuthenticationStateProviderTest.cs (2)

33Assert.Same(expectedAuthenticationState1, actualAuthenticationState1); 43Assert.Same(expectedAuthenticationState2, actualAuthenticationState2);

CascadingParameterStateTest.cs (5)

85Assert.Same(states[1].Component, match.ValueSupplier); 158Assert.Same(states[0].Component, match.ValueSupplier); 177Assert.Same(states[0].Component, match.ValueSupplier); 211Assert.Same(states[0].Component, match.ValueSupplier); 305Assert.Same(states[0].Component, match.ValueSupplier);

CascadingParameterTest.cs (2)

485Assert.Same(component.GetCascadingParameterValue(), anotherConsumer.GetCascadingParameterValue()); 655Assert.Same(updatedValue, component.GetCascadingParameterValue());

ComponentBaseTest.cs (4)

415Assert.Same(expected, actual); 431Assert.Same(expected, actual); 447Assert.Same(expected, actual); 463Assert.Same(expected, actual);

ComponentFactoryTest.cs (3)

152Assert.Same(resolvedComponent, instance); 202Assert.Same(resolvedComponent, instance); 206Assert.Same(callSiteRenderMode, renderer.SuppliedRenderMode);

DependencyInjectionTest.cs (10)

EventCallbackFactoryTest.cs (64)

ParameterViewTest.Assignment.cs (3)

32Assert.Same(someObject, target.ObjectPropCurrentValue); 109Assert.Same(existingObjectValue, target.ObjectPropCurrentValue); 334Assert.Same(value, target.CaptureUnmatchedValues);

ParameterViewTest.cs (5)

161Assert.Same(myEntryValue, result); 180Assert.Same(myEntryValue, result); 293Assert.Same(entry2Value, entry.Value); 317Assert.Same(myEntryValue, result); 576Assert.Same(expectedValue, parameter.Value);

RendererTest.cs (32)

595Assert.Same(eventArgs, receivedArgs); 618Assert.Same(typeof(DerivedEventArgs), eventArgsType); 641Assert.Same(typeof(EventArgs), eventArgsType); 749Assert.Same(eventArgs, receivedArgs); 818Assert.Same(eventArgs, receivedArgs); 856Assert.Same(eventArgs, receivedArgs); 899Assert.Same(eventArgs, receivedArgs); 996Assert.Same(eventArgs, receivedArgs); 2096Assert.Same(objectThatWillNotChange, childComponentInstance.ObjectProperty); 2105Assert.Same(objectThatWillNotChange, childComponentInstance.ObjectProperty); 2338Assert.Same(exception1, aex); 2461Assert.Same(exception1, aex); 2604Assert.Same(exception1, ex); 2611Assert.Same(exception2, ex); 3678Assert.Same(exception, Assert.Single(renderer.HandledExceptions).GetBaseException()); 3694Assert.Same(exception, Assert.Single(renderer.HandledExceptions).GetBaseException()); 3734Assert.Same(exception, Assert.Single(renderer.HandledExceptions).GetBaseException()); 3901Assert.Same(exception, Assert.Single(renderer.HandledExceptions).GetBaseException()); 3957Assert.Same(exception, Assert.Single(renderer.HandledExceptions).GetBaseException()); 3977Assert.Same(ConstructorThrowingComponent.Exception, Assert.Single(renderer.HandledExceptions).GetBaseException()); 4017Assert.Same(AttachThrowingComponent.Exception, Assert.Single(renderer.HandledExceptions).GetBaseException()); 4286Assert.Same(exception1, handledException); 4319Assert.Same(exception1, handledException); 4487Assert.Same(parameterValue, capturingComponent.SomeParam); 4566component => Assert.Same(exception, component.ReceivedException)); 4602component => Assert.Same(exception, component.ReceivedException)); 4642component => Assert.Same(exception, component.ReceivedException)); 4680component => Assert.Same(exception, component.ReceivedException)); 4724component => Assert.Same(exception, component.ReceivedException)); 4779component => Assert.Same(exception, component.ReceivedException)); 4927Assert.Same(exception1, Assert.Single(renderer.HandledExceptions)); 4935Assert.Same(exception2, renderer.HandledExceptions[1]);

Rendering\ArrayBuilderTest.cs (5)

214Assert.Same(buffer, returnedBuffer); 231Assert.Same(buffer, returnedBuffer); 261Assert.Same(buffer, returnedBuffer); 280Assert.Same(buffer, returnedBuffer); 323Assert.Same(buffer, Assert.Single(ArrayPool.ReturnedBuffers));

Rendering\RendererSynchronizationContextTest.cs (8)

154Assert.Same(CultureInfo.CurrentCulture, capturedCulture); 245Assert.Same(Thread.CurrentThread, capturedThread); 250Assert.Same(Thread.CurrentThread, capturedThread); 287Assert.Same(CultureInfo.CurrentCulture, capturedCulture); 306Assert.Same(thread, capturedThread); 396Assert.Same(CultureInfo.CurrentCulture, capturedCulture); 416Assert.Same(thread, capturedThread); 597Assert.Same(thread, capturedThread);

Rendering\RenderTreeBuilderTest.cs (2)

1708Assert.Same(keyValue, frame.ElementKey); 1734Assert.Same(keyValue, frame.ComponentKey);

RenderTreeDiffBuilderTest.cs (14)

244Assert.Same(oldComponent, newComponents[1]); 281Assert.Same(oldComponents[1], newComponent); 313Assert.Same(oldComponents[1], newComponent); 342Assert.Same(oldComponents[0], newComponents[1]); 1606Assert.Same(testObject, componentInstance.ObjectProperty); 1643Assert.Same(originalFakeComponentInstance, newFrame1.Component); 1644Assert.Same(originalFakeComponent2Instance, newFrame2.Component); 1725Assert.Same(originalComponentInstance, newComponentInstance); 1727Assert.Same(objectWillNotChange, newComponentInstance.ObjectProperty); 1775Assert.Same(originalComponentInstance, newComponentInstance); 1919Assert.Same(capturedInstance1, capturedInstance2); 1932Assert.Same(capturedInstance1, frame.Component); 2055Assert.Same(oldComponents[0], newComponents[1]); 2056Assert.Same(oldComponents[1], newComponents[0]);

Routing\RouteTableFactoryTests.cs (1)

1110Assert.Same(typeof(TestHandler1), context.Handler);

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

126Assert.Same(action, frame.ElementReferenceCaptureAction); 140Assert.Same(action, frame.ComponentReferenceCaptureAction); 147Assert.Same(mode, frame.ComponentRenderMode);

StackObjectPoolTest.cs (3)

54Assert.Same(instance1, instance1b); 55Assert.Same(instance2, instance2b); 84Assert.Same(instance1, instance1b);

Forms\EditFormTest.cs (2)

77Assert.Same(model, returnedEditContext.Model); 97Assert.Same(editContext, returnedEditContext);

Forms\InputBaseTest.cs (1)

72Assert.Same(rootComponent.EditContext, inputComponent.EditContext);

Forms\InputFileChangeEventArgsTest.cs (1)

54Assert.Same(files, instance.GetMultipleFiles());

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

126Assert.Same(action, frame.ElementReferenceCaptureAction); 140Assert.Same(action, frame.ComponentReferenceCaptureAction); 147Assert.Same(mode, frame.ComponentRenderMode);

CorsOptionsTest.cs (3)

22Assert.Same(expectedPolicy, actualPolicy); 38Assert.Same(expectedPolicy, actualPolicy); 61Assert.Same(expectedPolicy, actualPolicy);

CorsPolicyBuilderTests.cs (2)

41Assert.Same(originalPolicy.IsOriginAllowed, corsPolicy.IsOriginAllowed); 186Assert.Same(corsPolicy.IsOriginAllowed, isOriginAllowed);

DefaultCorsPolicyProviderTests.cs (2)

26Assert.Same(policy, actualPolicy); 46Assert.Same(policy, actualPolicy);

WeakReferenceHelpersTests.cs (6)

26Assert.Same(newInstance, target); 27Assert.Same(newInstance, retVal); 44Assert.Same(newInstance, target); 45Assert.Same(newInstance, retVal); 68Assert.Same(instanceThatWillBeCreatedFirst, target); 69Assert.Same(instanceThatWillBeCreatedFirst, retVal);

DataProtectionCommonExtensionsTests.cs (7)

69Assert.Same(finalExpectedProtector, retVal); 89Assert.Same(finalExpectedProtector, retVal); 106Assert.Same(finalExpectedProtector, retVal); 133Assert.Same(expected, actual); 196Assert.Same(finalExpectedProtector, retVal); 220Assert.Same(finalExpectedProtector, retVal); 240Assert.Same(finalExpectedProtector, retVal);

ActivatorTests.cs (2)

29Assert.Same(services, retVal2.Services); 32Assert.Same(services, retVal3.Services);

KeyManagement\CacheableKeyRingTests.cs (1)

54Assert.Same(keyRing, cacheableKeyRing.KeyRing);

KeyManagement\DefaultKeyResolverTests.cs (12)

42Assert.Same(key1, resolution.DefaultKey); 58Assert.Same(key2, resolution.DefaultKey); 73Assert.Same(key1, resolution.DefaultKey); 88Assert.Same(key1, resolution.DefaultKey); 105Assert.Same(key1, resolution.DefaultKey); 152Assert.Same(key1, resolution.DefaultKey); 184Assert.Same(key3, resolution.DefaultKey); 202Assert.Same(key2, resolution.FallbackKey); 220Assert.Same(key2, resolution.FallbackKey); 237Assert.Same(key2, resolution.FallbackKey); 264Assert.Same(key1, resolution.DefaultKey); 291Assert.Same(key2, resolution.DefaultKey);

KeyManagement\DeferredKeyTests.cs (1)

41Assert.Same(mockDescriptor, key.Descriptor);

KeyManagement\KeyRingProviderTests.cs (13)

KeyManagement\KeyRingTests.cs (7)

26Assert.Same(expectedEncryptorInstance, keyRing.DefaultAuthenticatedEncryptor); 28Assert.Same(expectedEncryptorInstance, keyRing.DefaultAuthenticatedEncryptor); 77Assert.Same(expectedEncryptorInstance1, keyRing.GetAuthenticatedEncryptorByKeyId(key1.KeyId, out var isRevoked)); 80Assert.Same(expectedEncryptorInstance1, keyRing.GetAuthenticatedEncryptorByKeyId(key1.KeyId, out isRevoked)); 84Assert.Same(expectedEncryptorInstance2, keyRing.GetAuthenticatedEncryptorByKeyId(key2.KeyId, out isRevoked)); 87Assert.Same(expectedEncryptorInstance2, keyRing.GetAuthenticatedEncryptorByKeyId(key2.KeyId, out isRevoked)); 90Assert.Same(expectedEncryptorInstance2, keyRing.DefaultAuthenticatedEncryptor);

KeyManagement\KeyTests.cs (1)

31Assert.Same(descriptor, key.Descriptor);

KeyManagement\XmlKeyManagerTests.cs (9)

71Assert.Same(expectedXmlEncryptor, keyManager.KeyEncryptor); 133Assert.Same(expectedDescriptor, newKey.Descriptor); 135Assert.Same(expectedAuthenticatedEncryptor, testEncryptorFactory.CreateEncryptorInstance(newKey)); 231Assert.Same(expectedDescriptor, newKey.Descriptor); 233Assert.Same(expectedAuthenticatedEncryptor, testEncryptorFactory.CreateEncryptorInstance(newKey)); 377Assert.Same(descriptorA, keys[0].Descriptor); 383Assert.Same(descriptorB, keys[1].Descriptor); 488Assert.Same(expectedDescriptor, keys[0].Descriptor); 527Assert.Same(expectedDescriptor, keys[0].Descriptor);

HeaderPropagationMiddlewareTest.cs (1)

138Assert.Same(Context, receivedContext);

HostingApplicationTests.cs (2)

63Assert.Same(previousContext, context.HttpContext); 67Assert.Same(previousContext, context.HttpContext);

Http\DefaultHttpContextFactoryTests.cs (3)

26Assert.Same(context, accessor.HttpContext); 44Assert.Same(context, accessor.HttpContext); 80Assert.Same(services.GetRequiredService<IServiceScopeFactory>(), context.ServiceScopeFactory);

WebHostTests.cs (2)

881Assert.Same(httpContext.TraceIdentifier, featuresTraceIdentifier); 902Assert.Same(requestIdentifierFeature, httpContext.Features.Get<IHttpRequestIdentifierFeature>());

HtmlContentBuilderExtensionsTest.cs (2)

57entry => Assert.Same(content, entry), 108entry => Assert.Same(content, entry));

EndpointMetadataCollectionTests.cs (2)

54Assert.Same(Array.Empty<string>(), ordered); 67Assert.Same(ordered1, ordered2);

HttpMethodslTests.cs (1)

41Assert.Same(expectedMethod, canonicalizedValue);

RouteValueDictionaryTests.cs (10)

73Assert.Same(otherStorage, storage); 421Assert.Same(StringComparer.OrdinalIgnoreCase, dict.Comparer); 1610Assert.Same(value, removedValue); 1627Assert.Same(value, removedValue); 1666Assert.Same(value, removedValue); 1686Assert.Same(value, removedValue); 1708Assert.Same(value, removedValue); 1733Assert.Same(value, removedValue); 1758Assert.Same(value, removedValue); 2157Assert.Same(Array.Empty<KeyValuePair<string, object?>>(), value._arrayStorage);

UseMiddlewareTest.cs (1)

219Assert.Same(middlewareFactory.Created, middlewareFactory.Released);

HttpConnectionDispatcherTests.cs (2)

1867Assert.Same(currentUser, connection.User); 1919Assert.Same(currentUser, connection.User);

HttpConnectionManagerTests.cs (9)

153Assert.Same(newConnection, connection); 171Assert.Same(newConnection, connection); 172Assert.Same(transport, newConnection.Transport); 190Assert.Same(newConnection, connection); 191Assert.Same(transport, newConnection.Transport); 212Assert.Same(newConnection, connection); 213Assert.Same(transport, newConnection.Transport); 234Assert.Same(newConnection, connection); 235Assert.Same(transport, newConnection.Transport);

ProblemDetailsServiceCollectionExtensionsTest.cs (2)

82Assert.Same(customService, service.ImplementationInstance); 240Assert.Same(customProblemDetailsResolver.LastProblemDetailsInfo, pdTypeInfo);

RequestDelegateFactoryTests.cs (9)

1209Assert.Same(httpContext, httpContextArgument); 1950Assert.Same(exception, logMessage.Exception); 1983Assert.Same(exception, logMessage.Exception); 2569m => Assert.Same(customMetadata, m), 2882Assert.Same(options.EndpointBuilder.Metadata, result.EndpointMetadata); 3061Assert.Same(initialRequestDelegate, result.RequestDelegate); 3077Assert.Same(options.EndpointBuilder.RequestDelegate, result.RequestDelegate); 3078Assert.Same(options.EndpointBuilder.Metadata, result.EndpointMetadata); 3094Assert.Same(Results.Empty, response);

RequestDelegateGenerator\RequestDelegateCreationTests.Forms.cs (1)

944Assert.Same(ioException, logMessage.Exception);

RequestDelegateGenerator\RequestDelegateCreationTests.JsonBody.cs (6)

239Assert.Same(httpContext.Request.Body, stream); 280Assert.Same(httpContext.Request.Body, stream); 324Assert.Same(httpContext.Request.Body, stream); 325Assert.Same(httpContext.Request.BodyReader, pipeReader); 365Assert.Same(httpContext.Request.Body, stream); 366Assert.Same(httpContext.Request.BodyReader, pipeReader);

RequestDelegateGenerator\RequestDelegateCreationTests.KeyServices.cs (8)

26Assert.Same(myOriginalService, httpContext.Items["arg"]); 74Assert.Same(myOriginalService1, httpContext1.Items["arg"]); 75Assert.Same(myOriginalService2, httpContext2.Items["arg"]); 92Assert.Same(myOriginalService, httpContext.Items["arg"]); 112Assert.Same(myOriginalService, httpContext.Items["arg"]); 169Assert.Same(myOriginalService1, httpContext.Items["arg1"]); 198Assert.Same(myOriginalService1, httpContext.Items["arg1"]); 200Assert.Same(myOriginalService2, httpContext.Items["arg3"]);

RequestDelegateGenerator\RequestDelegateCreationTests.Logging.cs (3)

495Assert.Same(ioException, logMessage.Exception); 533Assert.Same(jsonException, logMessage.Exception); 576Assert.Same(jsonException, badHttpRequestException.InnerException);

RequestDelegateGenerator\RequestDelegateCreationTests.SpecialTypes.cs (6)

40Assert.Same(httpContext, httpContext.Items["arg"]); 84Assert.Same(user, httpContext.Items["arg"]); 147Assert.Same(httpContext, httpContext.Items["input"]); 148Assert.Same(httpContext.User, httpContext.Items["user"]); 149Assert.Same(httpContext.Request, httpContext.Items["request"]); 150Assert.Same(httpContext.Response, httpContext.Items["response"]);

CreatedOfTResultTests.cs (1)

42Assert.Same(location, result.Location);

CreatedResultTests.cs (1)

27Assert.Same(location, result.Location);

LocalRedirectResultTests.cs (3)

24Assert.Same(url, result.Url); 39Assert.Same(url, result.Url); 54Assert.Same(url, result.Url);

RedirectResultTests.cs (1)

22Assert.Same(url, result.Url);

DefaultHttpContextTests.cs (13)

40Assert.Same(session, context.Session); 56Assert.Same(session, context.Session); 115Assert.Same(items, context.Items); 118Assert.Same(item, context.Items["foo"]); 129Assert.Same(traceIdentifier, context.TraceIdentifier); 132Assert.Same("Hello", context.TraceIdentifier); 143Assert.Same(items, context.Items); 146Assert.Same(item, context.Items["foo"]); 200Assert.Same(serviceProvider, context.RequestServices); 379Assert.Same(features, field.GetValue(value)); 384Assert.Same(features[field.FieldType], v); 397Assert.Same(features, property.GetValue(value)); 404Assert.Same(features[property.PropertyType], v);

Features\FormFeatureTests.cs (17)

HeaderDictionaryTests.cs (3)

126Assert.Same(Array.Empty<string>(), (string[])emptyHeaders["Header1"]); 129Assert.Same(Array.Empty<string>(), (string[])asIHeaderDictionary["Header1"]); 130Assert.Same(Array.Empty<string>(), (string[])asIHeaderDictionary.Host);

HttpContextAccessorTests.cs (4)

19Assert.Same(context, accessor.HttpContext); 45Assert.Same(context, accessor.HttpContext); 90Assert.Same(context, accessor.HttpContext); 116Assert.Same(context2, accessor.HttpContext);

Internal\DefaultHttpRequestTests.cs (1)

158Assert.Same(query2, request.Query);

Internal\DefaultHttpResponseTests.cs (5)

85Assert.Same(originalStream, context.Response.Body); 86Assert.Same(responseBodyMock.Object, context.Features.Get<IHttpResponseBodyFeature>()); 90Assert.Same(replacementStream, context.Response.Body); 95Assert.Same(originalStream, context.Response.Body); 96Assert.Same(responseBodyMock.Object, context.Features.Get<IHttpResponseBodyFeature>());

QueryCollectionTests.cs (2)

17Assert.Same(Array.Empty<string>(), (string[])query["query1"]); 20Assert.Same(Array.Empty<string>(), (string[])QueryCollection.Empty["query1"]);

SignInManagerTest.cs (4)

1153Assert.Same(SignInResult.Failed, result); 1208Assert.Same(SignInResult.Failed, result); 1242Assert.Same(expectedSignInResult, result); 1274Assert.Same(expectedSignInResult, result);

UserManagerTest.cs (3)

44Assert.Same(provider.GetRequiredService<UserManager<PocoUser>>(), 46Assert.Same(provider.GetRequiredService<RoleManager<PocoRole>>(), 1772Assert.Same(describer, manager.ErrorDescriber);

AssemblyTestLogTests.cs (1)

32Assert.Same(

LoggedTestXunitTests.cs (1)

114Assert.Same(loggerFactory, serviceCollection.BuildServiceProvider().GetRequiredService<ILoggerFactory>());

IntegrationTests\ListIntegrationTest.cs (2)

339Assert.Same(simpleObject2, targetObject.SimpleObjectList[0]); 340Assert.Same(simpleObject1, targetObject.SimpleObjectList[1]);

IntegrationTests\NestedObjectIntegrationTest.cs (1)

329Assert.Same(iDto, targetObject.SimpleObject);

Internal\ObjectVisitorTest.cs (5)

56Assert.Same(expectedTargetObject, targetObject); 89Assert.Same(expectedTargetObject, targetObject); 119Assert.Same(expectedTargetObject, targetObject); 120Assert.Same(typeof(DictionaryAdapter<string, object>), adapter.GetType()); 151Assert.Same(expectedTargetObject, targetObject);

RequestLocalizationOptionsExtensionsTest.cs (1)

21Assert.Same(provider, options.RequestCultureProviders[0]);

Filters\FilterContextTest.cs (1)

89Assert.Same(filters.Last(), result);

ModelBinding\BindingInfoTest.cs (14)

26Assert.Same("Test", bindingInfo.BinderModelName); 27Assert.Same(BindingSource.Query, bindingInfo.BindingSource); 45Assert.Same(bindAttribute, bindingInfo.PropertyFilterProvider); 79Assert.Same("PropertyPrefix", bindingInfo.BinderModelName); 119Assert.Same(typeof(ComplexObjectModelBinder), bindingInfo.BinderType); 120Assert.Same("Test", bindingInfo.BinderModelName); 168Assert.Same(typeof(ComplexObjectModelBinder), bindingInfo.BinderType); 169Assert.Same("Different", bindingInfo.BinderModelName); 170Assert.Same(BindingSource.Custom, bindingInfo.BindingSource); 191Assert.Same(typeof(ComplexObjectModelBinder), bindingInfo.BinderType); 217Assert.Same(BindingSource.Services, bindingInfo.BindingSource); 244Assert.Same(propertyFilterProvider, bindingInfo.PropertyFilterProvider); 309Assert.Same(BindingSource.Services, bindingInfo.BindingSource); 310Assert.Same(key, bindingInfo.ServiceKey);

ModelBinding\ModelStateDictionaryTest.cs (4)

299Assert.Same(exception, error.Exception); 339Assert.Same(exception, kvp.Value.Errors[1].Exception); 970Assert.Same(exception, error.Exception); 1083Assert.Same(exception, error.Exception);

DefaultApiDescriptionProviderTest.cs (61)

AcceptedAtActionResultTests.cs (2)

103Assert.Same(value, result.Value); 143Assert.Same(value, actual);

AcceptedAtRouteResultTests.cs (2)

44Assert.Same(value, result.Value); 77Assert.Same(value, actual);

AcceptedResultTests.cs (2)

40Assert.Same(value, result.Value); 63Assert.Same(value, actual);

ActionConstraints\ActionConstraintCacheTest.cs (11)

ActionResultOfTTest.cs (4)

56Assert.Same(expected, result); 72Assert.Same(value, objectResult.Value); 90Assert.Same(value, objectResult.Value); 108Assert.Same(value, objectResult.Value);

ApplicationModels\ActionModelTest.cs (2)

53Assert.Same(action2, action2.Parameters[0].Action); 135Assert.Same(value1, value2);

ApplicationModels\AttributeRouteModelTests.cs (1)

48Assert.Same(value1, value2);

ApplicationModels\ControllerActionDescriptorProviderTests.cs (1)

69Assert.Same(globalFilter, filter1.Filter);

ApplicationModels\ControllerModelTest.cs (3)

55Assert.Same(controller2, controller2.Actions[0].Controller); 57Assert.Same(controller2, controller2.ControllerProperties[0].Controller); 137Assert.Same(value1, value2);

ApplicationModels\DefaultApplicationModelProviderTest.cs (11)

ApplicationModels\InferParameterBindingInfoConventionTest.cs (46)

ApplicationModels\ParameterModelTest.cs (1)

71Assert.Same(value1, value2);

ApplicationModels\PropertyModelTest.cs (1)

62Assert.Same(value1, value2);

ApplicationModels\RouteTokenTransformerConventionTest.cs (1)

28Assert.Same(transformer, model.RouteParameterTransformer);

Authorization\AuthorizeFilterTest.cs (3)

432Assert.Same(authorizeFilter, result); 448Assert.Same(authorizeFilter, result); 507Assert.Same(policyProvider, actual.PolicyProvider);

ControllerBaseTest.cs (50)

Controllers\ControllerActivatorProviderTest.cs (2)

34Assert.Same(expected, result); 66Assert.Same(expected, actual.TestService);

Controllers\ControllerFactoryProviderTest.cs (5)

34Assert.Same(result, expected); 139Assert.Same(expectedController, actual); 140Assert.Same(expectedProperty1, actual.ActivatedValue1); 141Assert.Same(expectedProperty2, actual.ActivatedValue2); 173Assert.Same(expected, actual);

Controllers\DefaultControllerActivatorTest.cs (1)

144Assert.Same(testService, controller.TestService);

Controllers\DefaultControllerFactoryTest.cs (3)

46Assert.Same(expected, controller); 74Assert.Same(context, controller.ActionContext); 101Assert.Same(context, controller.ControllerContext);

Controllers\ServiceBasedControllerActivatorTest.cs (1)

39Assert.Same(controller, instance);

CreatedResultTests.cs (1)

38Assert.Same(location, result.Location);

DependencyInjection\MvcCoreServiceCollectionExtensionsTest.cs (2)

122Assert.Same(manager, builder.PartManager); 142Assert.Same(manager, builder.PartManager);

Filters\FilterCollectionTest.cs (4)

22Assert.Same(typeFilter, Assert.Single(collection)); 37Assert.Same(typeFilter, Assert.Single(collection)); 93Assert.Same(serviceFilter, Assert.Single(collection)); 108Assert.Same(serviceFilter, Assert.Single(collection));

Filters\FilterFactoryTest.cs (16)

Filters\FilterProviderTest.cs (9)

34Assert.Same(filter, item.Filter); 35Assert.Same(filter, item.Descriptor.Filter); 65Assert.Same(filter, item.Filter); 66Assert.Same(filterFactory.Object, item.Descriptor.Filter); 97Assert.Same(filter, item.Filter); 98Assert.Same(filterFactory.Object, item.Descriptor.Filter); 128Assert.Same(filter.Object, item.Filter); 129Assert.Same(filterFactory.Object, ((IFilterContainer)item.Filter).FilterDefinition); 130Assert.Same(filterFactory.Object, item.Descriptor.Filter);

Filters\MiddlewareFilterBuilderTest.cs (1)

71Assert.Same(pipeline1, pipeline2);

Filters\MiddlewareFilterTest.cs (4)

42Assert.Same(resourceExecutingContext, feature.ResourceExecutingContext); 43Assert.Same(resourceExecutionDelegate, feature.ResourceExecutionDelegate); 365Assert.Same(_controller, controller); 372Assert.Same(_controller, controller);

Formatters\TextOutputFormatterTests.cs (2)

123Assert.Same(firstContentType.Buffer, secondContentType.Buffer); 174Assert.Same(contentType, formatterContext.ContentType.Buffer);

HttpOkObjectResultTest.cs (1)

43Assert.Same(value, result.Value);

Infrastructure\ActionResultTypeMapperTest.cs (3)

24Assert.Same(expected, result); 40Assert.Same(returnValue, httpResult.Result); 71Assert.Same(returnValue, objectResult.Value);

Infrastructure\ActionSelectorTest.cs (14)

62Assert.Collection(candidates, (a) => Assert.Same(actions[0], a)); 105Assert.Collection(candidates, (a) => Assert.Same(actions[0], a)); 352Assert.Same(actions[0], action); 386Assert.Same(actions[0], action); 420Assert.Same(actions[0], action); 454Assert.Same(actions[0], action); 488Assert.Same(actions[0], action); 546Assert.Same(action, actionWithConstraints); 644Assert.Same(action, actionWithConstraints); 670Assert.Same(action, nullConstraint); 700Assert.Same(action, actionWithConstraints); 733Assert.Same(action, best); 770Assert.Same(action, best); 808Assert.Same(action, best);

Infrastructure\AsyncEnumerableReaderTest.cs (2)

79Assert.Same(reader1, reader2); 96Assert.Same(reader1, reader2);

Infrastructure\ClientErrorResultFilterTest.cs (5)

29Assert.Same(actionResult, context.Result); 50Assert.Same(actionResult, context.Result); 66Assert.Same(Result, context.Result); 84Assert.Same(Result, context.Result); 102Assert.Same(actionResult, context.Result);

Infrastructure\ControllerActionInvokerCacheTest.cs (1)

57Assert.Same(cacheEntry, cacheEntry2);

Infrastructure\ControllerActionInvokerTest.cs (16)

224Assert.Same(valueProviderFactory1, controllerContext.ValueProviderFactories[0]); 225Assert.Same(valueProviderFactory2, controllerContext.ValueProviderFactories[1]); 256Assert.Same(valueProviderFactory2, controllerContext.ValueProviderFactories[0]); 285Assert.Same(Result, result); 314Assert.Same(Result, result); 371Assert.Same(context.Result, result.Object); 440Assert.Same(context.Result, result.Object); 554Assert.Same(Exception, context.Exception); 597Assert.Same(exception, context.Exception); 640Assert.Same(exception, context.Exception); 719Assert.Same(expected, context.Result); 757Assert.Same(expected, context.Exception); 758Assert.Same(expected, context.ExceptionDispatchInfo.SourceException); 796Assert.Same(expected, context.Exception); 797Assert.Same(expected, context.ExceptionDispatchInfo.SourceException); 814Assert.Same(Exception, context.Exception);

Infrastructure\DefaultActionDescriptorCollectionProviderTest.cs (9)

36descriptor => Assert.Same(expected1, descriptor), 37descriptor => Assert.Same(expected2, descriptor), 38descriptor => Assert.Same(expected3, descriptor)); 62Assert.Same(collection1, collection2); 116item => Assert.Same(expected1, item)); 135Assert.Same(captured, collection2); 138item => Assert.Same(expected2, item)); 152Assert.Same(captured, collection3); 155item => Assert.Same(expected3, item));

Infrastructure\DefaultOutputFormatterSelectorTest.cs (7)

42Assert.Same(formatters[1], formatter); 72Assert.Same(formatters[1], formatter); 172Assert.Same(formatters[1], formatter); 201Assert.Same(formatters[1], formatter); 231Assert.Same(formatters[0], formatter); 328Assert.Same(formatters[0], formatter); 359Assert.Same(formatters[0], formatter);

Infrastructure\ModelStateInvalidFilterTest.cs (2)

31Assert.Same(expected, context.Result); 69Assert.Same(expected, context.Result);

LocalRedirectResultTest.cs (3)

29Assert.Same(url, result.Url); 44Assert.Same(url, result.Url); 59Assert.Same(url, result.Url);

ModelBinding\Binders\ArrayModelBinderTest.cs (1)

211Assert.Same(model, bindingContext.Result.Model);

ModelBinding\Binders\BodyModelBinderTests.cs (1)

586Assert.Same(canReadFormatter1, bindingContext.Result.Model);

ModelBinding\Binders\CollectionModelBinderTest.cs (3)

117Assert.Same(list, bindingContext.Result.Model); 169Assert.Same(list, bindingContext.Result.Model); 375Assert.Same(list, bindingContext.Result.Model);

ModelBinding\Binders\ComplexObjectModelBinderTest.cs (2)

454Assert.Same(originalModel, bindingContext.Model); 1014Assert.Same(originalCollection, model.ReadOnlyList);

ModelBinding\Binders\ComplexTypeModelBinderTest.cs (3)

330Assert.Same(model, returnedPerson); 610Assert.Same(originalModel, bindingContext.Model); 1176Assert.Same(originalCollection, model.ReadOnlyList);

ModelBinding\Binders\DictionaryModelBinderTest.cs (1)

86Assert.Same(dictionary, bindingContext.Result.Model);

ModelBinding\Binders\HeaderModelBinderProviderTest.cs (4)

66Assert.Same(testBinder, headerModelBinder.InnerModelBinder); 89Assert.Same(testBinder, headerModelBinder.InnerModelBinder); 115Assert.Same(testBinder, headerModelBinder.InnerModelBinder); 159Assert.Same(testBinder, headerModelBinder.InnerModelBinder);

ModelBinding\Binders\HeaderModelBinderTests.cs (2)

248Assert.Same(expectedValueProvider, bindingContext.ValueProvider); 272Assert.Same(testValueProvider.Object, bindingContext.ValueProvider);

ModelBinding\Binders\SimpleTypeModelBinderTest.cs (2)

33Assert.Same(value, bindingContext.Result.Model); 61Assert.Same(value, bindingContext.Result.Model);

ModelBinding\BindingSourceValueProviderTest.cs (1)

72Assert.Same(valueProvider, result);

ModelBinding\CompositeValueProviderTest.cs (1)

134Assert.Same(valueProvider1.Object, filteredProvider);

ModelBinding\DefaultModelBindingContextTest.cs (7)

51Assert.Same(newModelMetadata.BinderModelName, bindingContext.BinderModelName); 52Assert.Same(newModelMetadata.BindingSource, bindingContext.BindingSource); 56Assert.Same(newModelMetadata, bindingContext.ModelMetadata); 58Assert.Same(originalValueProvider, bindingContext.ValueProvider); 82vp => Assert.Same(original[1], vp)); 110vp => Assert.Same(original[1], vp)); 139vp => Assert.Same(original[2], vp));

ModelBinding\EnumerableValueProviderTest.cs (1)

268Assert.Same(result, provider);

ModelBinding\FormFileValueProviderFactoryTest.cs (3)

71Assert.Same(exception, ex.InnerException); 85Assert.Same(exception, ex.InnerException); 99Assert.Same(exception, ex);

ModelBinding\FormValueProviderFactoryTest.cs (3)

59Assert.Same(exception, ex.InnerException); 73Assert.Same(exception, ex.InnerException); 87Assert.Same(exception, ex);

ModelBinding\JQueryFormValueProviderFactoryTest.cs (3)

144Assert.Same(exception, ex.InnerException); 158Assert.Same(exception, ex.InnerException); 172Assert.Same(exception, ex);

ModelBinding\Metadata\DefaultModelMetadataProviderTest.cs (15)

38Assert.Same(metadata1, metadata2); 39Assert.Same(metadata1.Attributes, metadata2.Attributes); 40Assert.Same(metadata1.BindingMetadata, metadata2.BindingMetadata); 41Assert.Same(metadata1.DisplayMetadata, metadata2.DisplayMetadata); 42Assert.Same(metadata1.ValidationMetadata, metadata2.ValidationMetadata); 56Assert.Same(metadata1, metadata2); 129Assert.Same(properties1[i], properties2[i]); 130Assert.Same(properties1[i].Attributes, properties2[i].Attributes); 131Assert.Same(properties1[i].BindingMetadata, properties2[i].BindingMetadata); 132Assert.Same(properties1[i].DisplayMetadata, properties2[i].DisplayMetadata); 133Assert.Same(properties1[i].ValidationMetadata, properties2[i].ValidationMetadata); 148Assert.Same(metadata1.Properties, metadata2.Properties); 261Assert.Same(metadata1, metadata2); 329Assert.Same(metadata1, metadata2); 412Assert.Same(metadata1, metadata2);

ModelBinding\Metadata\DefaultModelMetadataTest.cs (3)

499Assert.Same(expectedProperties[i], properties[i]); 701Assert.Same(SinglePropertiesEvaluation, secondPropertiesEvaluation); 893Assert.Same(value, validationFilter);

ModelBinding\Metadata\DefaultValidationMetadataProviderTest.cs (3)

124Assert.Same(attribute, validatorMetadata); 143Assert.Same(attribute, validatorMetadata); 163Assert.Same(attribute, validatorMetadata);

ModelBinding\Metadata\ModelBinderAttributeTest.cs (2)

36Assert.Same(BindingSource.Custom, source); 49Assert.Same(BindingSource.Custom, source);

ModelBinding\ModelBinderFactoryTest.cs (7)

277Assert.Same(result1, result2); 364Assert.Same(expectedInfo.PropertyFilterProvider, context.BindingInfo.PropertyFilterProvider); 386Assert.Same(modelBinder, result); 410Assert.Same(inner, binder); 472Assert.Same(inner, binder); 565Assert.Same(inner, result2); 629Assert.Same(inner, result2);

ModelBinding\ModelBindingHelperTest.cs (3)

1306element => { Assert.Same(value[0], element); }, 1307element => { Assert.Same(value[1], element); }, 1308element => { Assert.Same(value[2], element); });

ModelBinding\ModelBindingResultTest.cs (1)

19Assert.Same(model, result.Model);

ModelBinding\ParameterBinderTest.cs (4)

345Assert.Same(model, result.Model); 400Assert.Same(model, result.Model); 455Assert.Same(model, result.Model); 509Assert.Same(model, result.Model);

ModelBinding\RouteValueProviderTests.cs (1)

248Assert.Same(result, provider);

ModelBinding\Validation\ClientValidatorCacheTest.cs (2)

32Assert.Same(validators1, validators2); 61Assert.Same(validator1, Assert.Single(validators2.OfType<RequiredAttributeAdapter>())); // cached

ModelBinding\Validation\DefaultCollectionValidationStrategyTest.cs (9)

29Assert.Same(metadata.ElementMetadata, e.Metadata); 35Assert.Same(metadata.ElementMetadata, e.Metadata); 41Assert.Same(metadata.ElementMetadata, e.Metadata); 69Assert.Same(metadata.ElementMetadata, e.Metadata); 75Assert.Same(metadata.ElementMetadata, e.Metadata); 81Assert.Same(metadata.ElementMetadata, e.Metadata); 104Assert.Same(metadata.ElementMetadata, e.Metadata); 110Assert.Same(metadata.ElementMetadata, e.Metadata); 116Assert.Same(metadata.ElementMetadata, e.Metadata);

ModelBinding\Validation\DefaultComplexObjectValidationStrategyTest.cs (12)

ModelBinding\Validation\ExplicitIndexCollectionValidationStrategyTest.cs (13)

ModelBinding\Validation\ShortFormDictionaryValidationStrategyTest.cs (7)

40Assert.Same(valueMetadata, e.Metadata); 46Assert.Same(valueMetadata, e.Metadata); 52Assert.Same(valueMetadata, e.Metadata); 87Assert.Same(valueMetadata, e.Metadata); 93Assert.Same(valueMetadata, e.Metadata); 128Assert.Same(valueMetadata, e.Metadata); 134Assert.Same(valueMetadata, e.Metadata);

ModelBinding\Validation\ValidatorCacheTest.cs (1)

32Assert.Same(validators1, validators2);

ProducesAttributeTests.cs (1)

140Assert.Same(personType, producesAttribute.Type);

ProducesResponseTypeAttributeTests.cs (1)

57Assert.Same(typeof(Person), producesResponseTypeAttribute.Type);

RedirectResultTest.cs (3)

46Assert.Same(url, result.Url); 61Assert.Same(url, result.Url); 76Assert.Same(url, result.Url);

Routing\ActionEndpointDataSourceBaseTest.cs (1)

62Assert.Same(endpoints1, endpoints2);

Routing\ActionEndpointFactoryTest.cs (1)

287Assert.Same(del, endpoint.RequestDelegate);

Routing\AttributeRouteTest.cs (1)

92Assert.Same(actions[1], selected);

Routing\ControllerActionEndpointDataSourceTest.cs (15)

Routing\DynamicControllerEndpointMatcherPolicyTest.cs (6)

189Assert.Same(ControllerEndpoints[0], candidates[0].Endpoint); 267Assert.Same(ControllerEndpoints[0], candidates[0].Endpoint); 288Assert.Same(State, kvp.Value); 388Assert.Same(State, kvp.Value); 433Assert.Same(ControllerEndpoints[1], candidates[0].Endpoint); 434Assert.Same(ControllerEndpoints[2], candidates[1].Endpoint);

Routing\UrlHelperTestBase.cs (8)

637Assert.Same(id, dictionary["ID"]); 638Assert.Same(isprint, dictionary["isprint"]); 682Assert.Same(action, dict["ACTION"]); 683Assert.Same(controller, dict["Controller"]); 684Assert.Same(id, dict["ID"]); 902Assert.Same(expectedUrlHelper, urlHelper); 921Assert.Same(urlHelper, actionContext.HttpContext.Items[typeof(IUrlHelper)] as IUrlHelper); 944Assert.Same(urlHelper, actionContext.HttpContext.Items[typeof(IUrlHelper)] as IUrlHelper);

Routing\ViewEnginePathTest.cs (2)

32Assert.Same(input, result); 47Assert.Same(input, result);

ServiceFilterAttributeTest.cs (1)

26Assert.Same(expected, filter);

TypeFilterAttributeTest.cs (6)

29Assert.Same(value, testFilter.Value); 30Assert.Same(uri, testFilter.Uri); 54Assert.Same(value, testFilter.Value); 55Assert.Same(uri, testFilter.Uri); 79Assert.Same(value, testFilter.Value); 80Assert.Same(uri, testFilter.Uri);

VirtualFileResultTest.cs (2)

61Assert.Same(webHostFileProvider, fileProvider); 78Assert.Same(fileProvider, actual);

CommonResourceInvokerTest.cs (38)

DataAnnotationsClientModelValidatorProviderTest.cs (1)

66Assert.Same(expectedValidatorItem.Validator, validatorItem.Validator);

DataAnnotationsMetadataProviderTest.cs (5)

121Assert.Same(displayFormat.DataFormatString, context.DisplayMetadata.DisplayFormatString); 144Assert.Same(displayFormat.DataFormatString, context.DisplayMetadata.DisplayFormatString); 1534Assert.Same(attribute, validatorMetadata); 1555Assert.Same(attribute, validatorMetadata); 1576Assert.Same(attribute, validatorMetadata);

DataAnnotationsModelValidatorTest.cs (1)

32Assert.Same(attribute, validator.Attribute);

DataTypeClientModelValidatorProviderTest.cs (1)

57Assert.Same(expectedValidatorItem.Validator, validatorItem.Validator);

ModelMetadataProviderTest.cs (2)

637Assert.Same(typeof(ComplexObjectModelBinder), metadata.BinderType); 656Assert.Same(typeof(ComplexObjectModelBinder), metadata.BinderType);

DelegatingEnumerableTest.cs (1)

52Assert.Same(errors[i], errorWrapper.SerializableError);

ProblemDetailsWrapperProviderFactoryTest.cs (2)

36Assert.Same(instance, wrapper.ProblemDetails); 53Assert.Same(instance, wrapper.ProblemDetails);

SerializableErrorWrapperProviderTest.cs (1)

36Assert.Same(serializableError, errorWrapper.SerializableError);

SerializableErrorWrapperTests.cs (1)

38Assert.Same(serializableError, wrapper.SerializableError);

XmlDataContractSerializerOutputFormatterTest.cs (1)

170Assert.Same(writerSettings, formatter.WriterSettings);

TryUpdateModelIntegrationTest.cs (9)

44Assert.Same(oldModel, model); 187Assert.Same(oldModel, model); 269Assert.Same(collection, model.Address); 651Assert.Same(oldModel, model); 787Assert.Same(oldModel, model); 864Assert.Same(collection, model.Address); 1121Assert.Same(oldModel, model); 1189Assert.Same(oldModel, model); 1241Assert.Same(oldModel, model);

MvcLocalizationMvcBuilderExtensionsTest.cs (1)

122Assert.Same(dataAnnotationLocalizerProvider, actualOptions.Value.DataAnnotationLocalizerProvider);

MvcLocalizationMvcCoreBuilderExtensionsTest.cs (1)

122Assert.Same(dataAnnotationLocalizerProvider, actualOptions.Value.DataAnnotationLocalizerProvider);

DependencyInjection\NewtonsoftJsonMvcCoreBuilderExtensionsTest.cs (3)

45Assert.Same(typeof(NewtonsoftJsonHelper), jsonHelper.ImplementationType); 60Assert.Same(typeof(BsonTempDataSerializer), tempDataSerializer.ImplementationType); 75Assert.Same(typeof(NewtonsoftJsonResultExecutor), jsonResultExecutor.ImplementationType);

NewtonsoftJsonInputFormatterTest.cs (2)

148Assert.Same(serializerSettings, formatter.SerializerSettings); 192Assert.Same(settings.ContractResolver, actual.ContractResolver);

NewtonsoftJsonOutputFormatterTest.cs (1)

44Assert.Same(serializerSettings, jsonFormatter.SerializerSettings);

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

79Assert.Same(reader1, reader2); 96Assert.Same(reader1, reader2);

CSharpCompilerTest.cs (2)

31Assert.Same(DependencyContextCompilationOptions.Default, options); 45Assert.Same(DependencyContextCompilationOptions.Default, options);

PageLoaderMatcherPolicyTest.cs (3)

31Assert.Same(compiled.Endpoint, candidateSet[0].Endpoint); 56Assert.Same(compiled.Endpoint, candidateSet[0].Endpoint); 84Assert.Same(compiled.Endpoint, candidateSet[0].Endpoint);

ApplicationParts\RazorCompiledItemFeatureProviderTest.cs (3)

141Assert.Same(item.Item, item1); 145Assert.Same(typeof(TestReloadedPage), item.Item.Type); 146Assert.Same("Item2", item.Item.Identifier);

Compilation\DefaultRazorPageFactoryProviderTest.cs (1)

39Assert.Same(descriptor, result.ViewDescriptor);

Compilation\RazorPagePropertyActivatorTest.cs (2)

190Assert.Same(original, viewDataDictionary); 214Assert.Same(original, viewDataDictionary);

DefaultTagHelperFactoryTest.cs (1)

46Assert.Same(viewDataValue, helper.ViewDataValue);

RazorPageActivatorTest.cs (20)

61Assert.Same(DiagnosticListener, instance.DiagnosticSource); 62Assert.Same(HtmlEncoder, instance.HtmlEncoder); 63Assert.Same(JsonHelper, instance.Json); 64Assert.Same(urlHelper, instance.Url); 65Assert.Same(viewContext.ViewData, instance.ViewData); 78Assert.Same(viewContext, service.ViewContext); 79Assert.Same(viewContext, keyedService.ViewContext); 99Assert.Same(DiagnosticListener, instance.DiagnosticSource); 100Assert.Same(HtmlEncoder, instance.HtmlEncoder); 126Assert.Same(DiagnosticListener, instance.DiagnosticSource); 127Assert.Same(HtmlEncoder, instance.HtmlEncoder); 128Assert.Same(JsonHelper, instance.Json); 129Assert.Same(urlHelper, instance.Url); 130Assert.Same(viewContext.ViewData, instance.ViewData); 150Assert.Same(viewContext, service.ViewContext); 151Assert.Same(viewContext, keyedService.ViewContext); 186Assert.Same(viewContext.ViewData, page.ViewData); 205Assert.Same(result1, result2); 220Assert.Same(result1, result2); 228Assert.Same(result3, result4);

RazorPageCreateModelExpressionTest.cs (2)

40Assert.Same(modelExplorer, modelExpression.ModelExplorer); 65Assert.Same(modelExplorer, modelExpression.ModelExplorer);

RazorPageTest.cs (8)

151Assert.Same(encoder, page.HtmlEncoder); 169Assert.Same(originalEncoder, page.HtmlEncoder); 225Assert.Same(originalWriter, page.Output); 940Assert.Same(HtmlString.Empty, actual); 1275Assert.Same(writer, page.ViewContext.Writer); 1292Assert.Same(writer, page.ViewContext.Writer); 1298Assert.Same(defaultWriter, poppedWriter); 1299Assert.Same(defaultWriter, page.ViewContext.Writer);

RazorViewEngineTest.cs (31)

RazorViewTest.cs (5)

65Assert.Same(viewData, v.ViewContext.ViewData); 82Assert.Same(c, viewContext); 92Assert.Same(expectedWriter, viewContext.Writer); 103Assert.Same(viewData, v.ViewContext.ViewData); 125Assert.Same(c, viewContext);

TagHelpers\TagHelperComponentPropertyActivatorTest.cs (1)

28Assert.Same(viewContext, tagHelperComponent.ViewContext);

ApplicationModels\CompiledPageActionDescriptorBuilderTest.cs (21)

38Assert.Same(actionDescriptor.ActionConstraints, actual.ActionConstraints); 39Assert.Same(actionDescriptor.AttributeRouteInfo, actual.AttributeRouteInfo); 40Assert.Same(actionDescriptor.RelativePath, actual.RelativePath); 41Assert.Same(actionDescriptor.RouteValues, actual.RouteValues); 42Assert.Same(actionDescriptor.ViewEnginePath, actual.ViewEnginePath); 86Assert.Same(pageApplicationModel.PageType, actual.PageTypeInfo); 87Assert.Same(pageApplicationModel.DeclaredModelType, actual.DeclaredModelTypeInfo); 88Assert.Same(pageApplicationModel.ModelType, actual.ModelTypeInfo); 89Assert.Same(pageApplicationModel.HandlerType, actual.HandlerTypeInfo); 90Assert.Same(pageApplicationModel.Properties, actual.Properties); 174Assert.Same(globalFilters[0], filterDescriptor.Filter); 179Assert.Same(pageApplicationModel.Filters[0], filterDescriptor.Filter); 296Assert.Same(parameterModel2.BindingInfo, p.BindingInfo); 336Assert.Same(propertyModel.PropertyName, p.Name); 337Assert.Same(typeof(int), p.ParameterType); 338Assert.Same(propertyModel.PropertyInfo, p.Property); 339Assert.Same(propertyModel.BindingInfo, p.BindingInfo); 385Assert.Same(propertyModel1.PropertyName, p.Name); 386Assert.Same(typeof(int), p.ParameterType); 387Assert.Same(propertyModel1.PropertyInfo, p.Property); 388Assert.Same(propertyModel1.BindingInfo, p.BindingInfo);

ApplicationModels\DefaultPageApplicationModelProviderTest.cs (17)

ApplicationModels\PageRouteTransformerConventionTest.cs (1)

24Assert.Same(transformer, model.RouteParameterTransformer);

DependencyInjection\MvcRazorPagesMvcBuilderExtensionsTest.cs (2)

37convention => Assert.Same(applicationModelConvention, convention), 38convention => Assert.Same(routeModelConvention, convention));

DependencyInjection\PageConventionCollectionExtensionsTest.cs (3)

37model => Assert.Same(filter, Assert.Single(model.Filters)), 38model => Assert.Same(filter, Assert.Single(model.Filters)), 39model => Assert.Same(filter, Assert.Single(model.Filters)));

Filters\AutoValidateAntiforgeryPageApplicationModelProviderTest.cs (2)

60actual => Assert.Same(expected, actual)); 85actual => Assert.Same(expected, actual));

Filters\PageSaveTempDataPropertyFilterFactoryTest.cs (1)

28Assert.Same(lifecycleProperties, pageFilter.Properties);

Filters\PageViewDataAttributeFilterFactoryTest.cs (1)

27Assert.Same(properties, filter.Properties);

Filters\PageViewDataAttributeFilterTest.cs (1)

51Assert.Same(handler, filter.Subject);

Infrastructure\CompiledPageActionDescriptorFactoryTest.cs (9)

24Assert.Same(model, m); 51Assert.Same(model, m); 58Assert.Same(model, m); 90Assert.Same(handlerModel, m); 117Assert.Same(handlerModel, m); 179Assert.Same(parameterModel, m); 210Assert.Same(parameterModel, m); 279Assert.Same(propertyModel, m); 310Assert.Same(propertyModel, m);

Infrastructure\DefaultPageFactoryProviderTest.cs (4)

62Assert.Same(pageContext, testPage.PageContext); 98Assert.Same(urlHelper, testPage.UrlHelper); 99Assert.Same(htmlEncoder, testPage.HtmlEncoder); 242Assert.Same(pageContext.ViewData, testPage.ViewData);

Infrastructure\DefaultPageLoaderTest.cs (6)

60Assert.Same(pageApplicationModel1, c.PageApplicationModel); 69Assert.Same(pageApplicationModel2, c.PageApplicationModel); 77Assert.Same(pageApplicationModel2, c.PageApplicationModel); 269Assert.Same(result1, result2); 351Assert.Same(pageDescriptor, result1); 352Assert.Same(pageDescriptor, result2);

Infrastructure\DefaultPageModelActivatorProviderTest.cs (1)

87Assert.Same(generator, modelWithServices.Generator);

Infrastructure\DefaultPageModelFactoryProviderTest.cs (3)

78Assert.Same(pageContext, testModel.ContextWithAttribute); 101Assert.Same(disposer, actual); 123Assert.Same(disposer, actual);

Infrastructure\DisallowOptionsRequestsPageFilterTest.cs (3)

39Assert.Same(expected, context.Result); 72Assert.Same(expected, context.Result); 106Assert.Same(expected, context.Result);

Infrastructure\DynamicPageEndpointMatcherPolicyTest.cs (6)

205Assert.Same(LoadedEndpoints[0], candidates[0].Endpoint); 246Assert.Same(LoadedEndpoints[0], candidates[0].Endpoint); 262Assert.Same(State, kvp.Value); 389Assert.Same(State, kvp.Value); 433Assert.Same(LoadedEndpoints[0], candidates[0].Endpoint); 434Assert.Same(LoadedEndpoints[1], candidates[1].Endpoint);

Infrastructure\PageActionDescriptorProviderTest.cs (1)

199Assert.Same(expected, actual);

Infrastructure\PageActionEndpointDataSourceTest.cs (5)

88Assert.Same(actions[0], e.Metadata.GetMetadata<ActionDescriptor>()); 158Assert.Same(actions[0], e.Metadata.GetMetadata<ActionDescriptor>()); 165Assert.Same(actions[1], e.Metadata.GetMetadata<ActionDescriptor>()); 208Assert.Same(actions[0], e.Metadata.GetMetadata<ActionDescriptor>()); 256Assert.Same(actions[0], e.Metadata.GetMetadata<ActionDescriptor>());

Infrastructure\PageActionInvokerProviderTest.cs (11)

68Assert.Same(factory, entry.PageFactory); 69Assert.Same(releaser, entry.ReleasePage); 133Assert.Same(factory, entry.PageFactory); 134Assert.Same(releaser, entry.ReleasePage); 135Assert.Same(modelFactory, entry.ModelFactory); 136Assert.Same(modelDisposer, entry.ReleaseModel); 140Assert.Same(compiledPageActionDescriptor, pageContext.ActionDescriptor); 141Assert.Same(context.ActionContext.HttpContext, pageContext.HttpContext); 142Assert.Same(context.ActionContext.ModelState, pageContext.ModelState); 143Assert.Same(context.ActionContext.RouteData, pageContext.RouteData); 241Assert.Same(entry1, entry2);

Infrastructure\PageActionInvokerTest.cs (54)

Infrastructure\PageBinderFactoryTest.cs (6)

45Assert.Same(PageBinderFactory.NullPropertyBinder, factory); 71Assert.Same(PageBinderFactory.NullPropertyBinder, factory); 96Assert.Same(PageBinderFactory.NullPropertyBinder, factory); 122Assert.Same(PageBinderFactory.NullPropertyBinder, factory); 147Assert.Same(PageBinderFactory.NullPropertyBinder, factory); 173Assert.Same(PageBinderFactory.NullPropertyBinder, factory);

Infrastructure\ServiceBasedPageModelActivatorProviderTest.cs (1)

55Assert.Same(simpleModel, instance);

PageModelTest.cs (33)

PageTest.cs (35)

42Assert.Same(pageContext, page.PageContext); 43Assert.Same(viewContext, page.ViewContext); 44Assert.Same(httpContext, page.HttpContext); 45Assert.Same(httpContext.Request, page.Request); 46Assert.Same(httpContext.Response, page.Response); 47Assert.Same(modelState, page.ModelState); 48Assert.Same(tempData, page.TempData); 65Assert.Same(url, result.Url); 82Assert.Same(url, result.Url); 99Assert.Same(url, result.Url); 116Assert.Same(url, result.Url); 163Assert.Same(url, result.Url); 180Assert.Same(url, result.Url); 197Assert.Same(url, result.Url); 214Assert.Same(url, result.Url); 895Assert.Same(routeName, resultTemporary.RouteName); 912Assert.Same(routeName, resultTemporary.RouteName); 929Assert.Same(routeName, resultPermanent.RouteName); 946Assert.Same(routeName, resultPermanent.RouteName); 966Assert.Same(routeName, resultTemporary.RouteName); 987Assert.Same(routeName, resultTemporary.RouteName); 1008Assert.Same(routeName, resultPermanent.RouteName); 1029Assert.Same(routeName, resultPermanent.RouteName); 1316Assert.Same(url, result.PageName); 1336Assert.Same(pageName, resultPermanent.PageName); 1357Assert.Same(routeName, resultPermanent.PageName); 1373Assert.Same(fileContents, result.FileContents); 1390Assert.Same(fileContents, result.FileContents); 1451Assert.Same(fileStream, result.FileStream); 1477Assert.Same(fileStream, result.FileStream); 1597Assert.Same(Encoding.UTF8, MediaType.GetEncoding(actualContentResult.ContentType)); 1778Assert.Same(viewData, result.ViewData); 1800Assert.Same(viewData, result.ViewData); 1825Assert.Same(arguments, result.Arguments); 1826Assert.Same(viewData, result.ViewData);

src\Mvc\Mvc.Core\test\Routing\ActionEndpointDataSourceBaseTest.cs (1)

62Assert.Same(endpoints1, endpoints2);

VirtualPathDataTests.cs (3)

21Assert.Same(router, pathData.Router); 40Assert.Same(router, pathData.Router); 58Assert.Same(router, pathData.Router);

DefaultTagHelperActivatorTest.cs (6)

35Assert.Same(CacheProvider.Cache, scriptTagHelper.Cache); 36Assert.Same(HostingEnvironment, scriptTagHelper.HostingEnvironment); 37Assert.Same(FileVersionProvider, scriptTagHelper.FileVersionProvider); 49Assert.Same(CacheProvider.Cache, linkTagHelper.Cache); 50Assert.Same(HostingEnvironment, linkTagHelper.HostingEnvironment); 51Assert.Same(FileVersionProvider, linkTagHelper.FileVersionProvider);

PartialTagHelperTest.cs (5)

34Assert.Same(expectedModel, model); 82Assert.Same(expectedModel, model); 101Assert.Same(expectedModel, model); 333Assert.Same(expected, actual); 466Assert.Same(model, v.ViewData.Model);

SelectTagHelperTest.cs (2)

623Assert.Same(currentValues, actualCurrentValues.Values); 699Assert.Same(currentValues, actualCurrentValues.Values);

MvcServiceCollectionExtensionsTest.cs (1)

389Assert.Same(manager, descriptor.ImplementationInstance);

CachedExpressionCompilerTest.cs (15)

ControllerTest.cs (33)

ControllerUnitTestabilityTests.cs (18)

32Assert.Same(model, viewResult.Model); 33Assert.Same(model, viewResult.ViewData.Model); 34Assert.Same(controller.ViewData, viewResult.ViewData); 35Assert.Same(controller.TempData, viewResult.TempData); 54Assert.Same(model, viewResult.Model); 55Assert.Same(model, viewResult.ViewData.Model); 56Assert.Same(controller.ViewData, viewResult.ViewData); 57Assert.Same(controller.TempData, viewResult.TempData); 202Assert.Same(model, jsonResult.Value); 234Assert.Same(model, jsonResult.Value); 302Assert.Same(error, httpBadRequest.Value); 337Assert.Same(value, createdAtRouteResult.Value); 373Assert.Same(value, acceptedAtRouteResult.Value); 411Assert.Same(value, createdAtActionResult.Value); 450Assert.Same(value, acceptedAtActionResult.Value); 611Assert.Same(httpContext, controller.HttpContext); 612Assert.Same(routeData, controller.RouteData); 614Assert.Same(actionDescriptor, controllerContext.ActionDescriptor);

CookieTempDataProviderTest.cs (2)

111Assert.Same(Dictionary, actualValues); 310Assert.Same(Dictionary, tempData);

ExpressionHelperTest.cs (2)

387Assert.Same(text1, text2); // cached 417Assert.Same(text1, text2); // cached

ExpressionMetadataProviderTest.cs (2)

109Assert.Same(myModel, metadata.Container.Model); 152Assert.Same(myModel, metadata.Container.Model);

Filters\ControllerSaveTempDataPropertyFilterFactoryTest.cs (1)

24Assert.Same(lifecycleProperties, tempDataFilter.Properties);

Filters\ControllerViewDataAttributeFilterFactoryTest.cs (1)

26Assert.Same(properties, filter.Properties);

Filters\ControllerViewDataAttributeFilterTest.cs (1)

46Assert.Same(controller, filter.Subject);

HtmlAttributePropertyHelperTest.cs (2)

83Assert.Same(helpers1, helpers2); 84Assert.Same(helpers1[0], helpers2[0]);

ModelExplorerTest.cs (3)

54Assert.Same(modelExplorer, baseProperty.Container); 59Assert.Same(modelExplorer, derivedProperty.Container); 78Assert.Same(modelExplorer, baseProperty.Container);

ModelStateDictionaryExtensionsTest.cs (13)

PartialViewResultTest.cs (1)

38Assert.Same(customModel, viewResult.Model);

Rendering\HtmlHelperPartialExtensionsTest.cs (8)

60Assert.Same(htmlContent, result); 86Assert.Same(expected, actual); 134Assert.Same(htmlContent, result); 177Assert.Same(expected, actual); 281Assert.Same(expected, actual); 300Assert.Same(expected, actual); 326Assert.Same(expected, actual); 346Assert.Same(expected, actual);

Rendering\HtmlHelperSelectTest.cs (2)

1338Assert.Same(htmlHelper.SelectListItems, result); // No replacement of the underlying List 1398Assert.Same(htmlHelper.SelectListItems, result); // No replacement of the underlying List

Rendering\HtmlHelperTest.cs (1)

305Assert.Same(helperToContextualize.ViewContext, viewContext);

Rendering\ViewContextTests.cs (13)

SessionStateTempDataProviderTest.cs (1)

70Assert.Same(Dictionary, result);

TempDataDictionaryFactoryTest.cs (1)

43Assert.Same(tempData1, tempData2);

TempDataDictionaryTest.cs (1)

140Assert.Same(item, value);

ViewComponentResultTest.cs (1)

47Assert.Same(customModel, viewResult.Model);

ViewComponents\DefaultViewComponentActivatorTests.cs (2)

35Assert.Same(context, instance.ViewComponentContext); 59Assert.Same(context, instance.ViewComponentContext);

ViewComponents\DefaultViewComponentFactoryTest.cs (2)

31Assert.Same(component, activablePropertiesComponent); 32Assert.Same(component.Context, activablePropertiesComponent.Context);

ViewComponents\DefaultViewComponentHelperTest.cs (1)

112Assert.Same(expectedValue, item.Value);

ViewComponents\DefaultViewComponentSelectorTest.cs (9)

ViewComponents\ViewComponentContextTest.cs (7)

46Assert.Same(tempData, viewComponentContext.TempData); 47Assert.Same(viewContext.View, viewComponentContext.ViewContext.View); 48Assert.Same(viewContext.Writer, viewComponentContext.ViewContext.Writer); 51Assert.Same(viewComponentContext.ViewContext.ViewData, viewComponentContext.ViewData); 52Assert.Same(viewComponentContext.ViewContext.TempData, viewComponentContext.TempData); 53Assert.Same(viewComponentContext.ViewContext.Writer, viewComponentContext.Writer); 57Assert.Same(viewData.ModelMetadata, viewComponentContext.ViewData.ModelMetadata);

ViewComponents\ViewViewComponentResultTest.cs (1)

294Assert.Same(expected, actual);

ViewComponentTests.cs (6)

62Assert.Same(expectedContent, actualResult.Content); 97Assert.Same(model, actualResult.ViewData.Model); 135Assert.Same(model, actualResult.ViewData.Model); 213Assert.Same(model, actualResult.ViewData.Model); 233Assert.Same(viewComponent.ViewData, viewComponent.ViewContext.ViewData); 254Assert.Same(viewComponent.TempData, viewComponent.ViewContext.TempData);

ViewDataDictionaryOfTModelTest.cs (14)

ViewDataDictionaryTest.cs (13)

ViewDataOfTTest.cs (1)

46Assert.Same(value, viewDataOfT.Model);

ViewEngines\CompositeViewEngineTest.cs (6)

89Assert.Same(view, result.View); 123Assert.Same(view2, result.View); 224Assert.Same(view, result.View); 261Assert.Same(view2, result.View); 356Assert.Same(view, result.View); 390Assert.Same(view2, result.View);

ViewResultTest.cs (1)

48Assert.Same(customModel, viewResult.Model);

Transformers\OpenApiOptionsTests.cs (1)

41Assert.Same(transformer, insertedTransformer);

OwinEnvironmentTests.cs (4)

40Assert.Same(Stream.Null, Get<Stream>(env, "owin.RequestBody")); 50Assert.Same(Stream.Null, Get<Stream>(env, "owin.ResponseBody")); 85Assert.Same(Stream.Null, context.Request.Body); 93Assert.Same(Stream.Null, context.Response.Body);

Runtime\TagHelpers\TagHelperExecutionContextTest.cs (6)

186Assert.Same(updatedItems, context.Items); 226Assert.Same(expectedItems, executionContext.Items); 311Assert.Same(encoder, passedEncoder); 562Assert.Same(tagHelper, singleTagHelper); 580Assert.Same(tagHelper1, tagHelpers[0]); 581Assert.Same(tagHelper2, tagHelpers[1]);

Runtime\TagHelpers\TagHelperRunnerTest.cs (1)

203Assert.Same(tagHelper.ContextProcessedWith.Items, executionContext.Items);

Runtime\TagHelpers\TagHelperScopeManagerTest.cs (1)

60Assert.Same(parentComplexObject, executionContextItem.Value);

TagHelpers\TagHelperContextTest.cs (3)

38Assert.Same(expectedItems, context.Items); 62Assert.Same(expectedItems, context.Items); 85Assert.Same(expectedItems, context.Items);

TagHelpers\TagHelperOutputTest.cs (6)

86Assert.Same(content, result); 127Assert.Same(encoder, passedEncoder); 128Assert.Same(content, result); 157Assert.Same(content, result); 202Assert.Same(encoder, passedEncoder); 203Assert.Same(content, result);

CachedResponseBodyTests.cs (1)

20Assert.Same(segments, body.Segments);

Builder\EndpointRoutingApplicationBuilderExtensionsTest.cs (2)

106Assert.Same(endpoint, httpContext.GetEndpoint()); 341Assert.Same(local, global);

Builder\GroupTest.cs (1)

198Assert.Same(serviceProvider, endpointBuilderServiceProvider);

Builder\RequestDelegateEndpointRouteBuilderExtensionsTest.cs (2)

257Assert.Same(Results.Empty, response); 343Assert.Same(initialRequestDelegate, endpoint.RequestDelegate);

CompositeEndpointDataSourceTest.cs (21)

77Assert.Same(ex, Assert.Throws<Exception>(() => compositeDataSource.Endpoints)); 78Assert.Same(ex, Assert.Throws<Exception>(() => compositeDataSource.Endpoints)); 79Assert.Same(ex, Assert.Throws<Exception>(() => compositeDataSource.GetGroupedEndpoints(groupContext))); 80Assert.Same(ex, Assert.Throws<Exception>(() => compositeDataSource.GetGroupedEndpoints(groupContext))); 105(ep) => Assert.Same(endpoint1, ep), 106(ep) => Assert.Same(endpoint2, ep), 107(ep) => Assert.Same(endpoint3, ep), 108(ep) => Assert.Same(endpoint4, ep), 109(ep) => Assert.Same(endpoint5, ep)); 125Assert.Same(endpoint1, endpoint); 136(ep) => Assert.Same(endpoint1, ep), 137(ep) => Assert.Same(endpoint2, ep)); 148(ep) => Assert.Same(endpoint1, ep), 149(ep) => Assert.Same(endpoint2, ep), 150(ep) => Assert.Same(endpoint3, ep)); 307Assert.Same(context, receivedContext); 312m => Assert.Same(metadata, m), 353Assert.Same(context, receivedContext); 408Assert.Same(context, receivedContext); 473receivedContext => Assert.Same(context, receivedContext), 474receivedContext => Assert.Same(context, receivedContext));

DecisionTreeBuilderTest.cs (1)

36Assert.Same(item, Assert.Single(tree.Matches));

DefaultLinkGeneratorTest.cs (1)

578Assert.Same(expected, actual);

DefaultLinkParserTest.cs (2)

133Assert.Same(expected.Matcher, actual.Matcher); 134Assert.Same(expected.Constraints, actual.Constraints);

EndpointNameAddressSchemeTest.cs (3)

31e => Assert.Same(endpoint2, e)); 81Assert.Same(endpoint1, match.Value.Single()); 132Assert.Same(endpoint, Assert.Single(Assert.Single(addressScheme.Entries).Value));

Matching\CandidateSetTest.cs (18)

Matching\DataSourceDependentMatcherTest.cs (2)

51e => Assert.Same(endpoint, e)); 137Assert.Same(endpoint, Assert.Single(inner.Endpoints));

Matching\DefaultEndpointSelectorTest.cs (4)

68Assert.Same(endpoints[0], httpContext.GetEndpoint()); 89Assert.Same(endpoints[1], httpContext.GetEndpoint()); 111Assert.Same(endpoints[1], httpContext.GetEndpoint()); 142Assert.Same(endpoints[4], httpContext.GetEndpoint());

Matching\DfaMatcherBuilderTest.cs (17)

30Assert.Same(endpoint, Assert.Single(root.Matches)); 99Assert.Same(endpoint, Assert.Single(c.Matches)); 123Assert.Same(endpoint, Assert.Single(a.Matches)); 130Assert.Same(endpoint, Assert.Single(catchAll.Matches)); 132Assert.Same(catchAll, catchAll.Parameters); 133Assert.Same(catchAll, catchAll.CatchAll); 149Assert.Same(endpoint, Assert.Single(root.Matches)); 155Assert.Same(endpoint, Assert.Single(catchAll.Matches)); 157Assert.Same(catchAll, catchAll.Parameters); 2526e => Assert.Same(endpoint1, e)); 2580e => Assert.Same(endpoint2, e)); 2621e => Assert.Same(endpoint2, e)); 2988Assert.Same(endpoint, Assert.Single(root.Matches)); 3068Assert.Same(endpoint1, Assert.Single(root.Matches)); 3128Assert.Same(endpoint, Assert.Single(root.Matches)); 3396Assert.Same(constraint1.Value, constraint2.Value); 3419Assert.Same(constraint1.Value, constraint2.Value);

Matching\DfaMatcherTest.cs (17)

Matching\EndpointComparerTest.cs (10)

210e => Assert.Same(endpoint1, e), 211e => Assert.Same(endpoint2, e), 212e => Assert.Same(endpoint3, e), 213e => Assert.Same(endpoint4, e), 214e => Assert.Same(endpoint5, e), 215e => Assert.Same(endpoint6, e), 216e => Assert.Same(endpoint7, e)); 237e => Assert.Same(endpoint1, e), 238e => Assert.Same(endpoint2, e), 239e => Assert.Same(endpoint3, e));

Matching\EndpointMetadataComparerTest.cs (2)

81e => Assert.Same(endpoint1, e), 82e => Assert.Same(endpoint2, e));

Matching\HttpMethodMatcherPolicyIntegrationTestBase.cs (3)

79Assert.Same(HttpMethodMatcherPolicy.Http405EndpointDisplayName, httpContext.GetEndpoint().DisplayName); 199Assert.Same(HttpMethodMatcherPolicy.Http405EndpointDisplayName, httpContext.GetEndpoint().DisplayName); 309Assert.Same(HttpMethodMatcherPolicy.Http405EndpointDisplayName, httpContext.GetEndpoint().DisplayName);

Patterns\DefaultRoutePatternTransformerTest.cs (3)

170Assert.Same(actual.Defaults, original.Defaults); 171Assert.Same(actual.Parameters, original.Parameters); 172Assert.Same(actual.PathSegments, original.PathSegments);

Patterns\RoutePatternFactoryTest.cs (14)

RequestDelegateRouteBuilderExtensionsTest.cs (1)

62Assert.Same(NullHandler, context.Handler);

RouteBuilderTest.cs (3)

28Assert.Same(applicationBuilder, builder.ApplicationBuilder); 29Assert.Same(defaultHandler, builder.DefaultHandler); 30Assert.Same(applicationServices, builder.ServiceProvider);

RouteCollectionTest.cs (8)

53Assert.Same(target.Object, pathData.Router); 81Assert.Same(target.Object, pathData.Router); 119Assert.Same(target.Object, pathData.Router); 148Assert.Same(route, pathData.Router); 183Assert.Same(route1.Object, context.RouteData.Routers[0]); 209Assert.Same(route2.Object, context.RouteData.Routers[0]); 394Assert.Same(route, pathData.Router); 449Assert.Same(expectedRouteToMatch, ((INamedRouter)pathData.Router).Name);

RouteConstraintBuilderTest.cs (1)

50Assert.Same(originalConstraint, kvp.Value);

RouteEndpointBuilderTest.cs (1)

46m => Assert.Same(metadata, m),

RouteOptionsTests.cs (3)

48Assert.Same(endpoint1, result); 55ep => Assert.Same(endpoint1, ep), 56ep => Assert.Same(endpoint2, ep));

RouterMiddlewareTest.cs (1)

47Assert.Same(routingFeature.RouteData, context.GetRouteData());

RouteTest.cs (38)

RouteValuesAddressSchemeTest.cs (15)

28Assert.Same(endpoint2, actual); 47Assert.Same(endpoint2, Assert.IsType<RouteEndpoint>(namedMatches[0].Match.Entry.Data)); 48Assert.Same(endpoint3, Assert.IsType<RouteEndpoint>(namedMatches[1].Match.Entry.Data)); 67Assert.Same(endpoint2, Assert.IsType<RouteEndpoint>(namedMatches[0].Match.Entry.Data)); 68Assert.Same(endpoint3, Assert.IsType<RouteEndpoint>(namedMatches[1].Match.Entry.Data)); 89Assert.Same(endpoint1, actual); 132Assert.Same(endpoint1, actual); 137Assert.Same(endpoint2, actual); 142Assert.Same(endpoint3, actual); 147Assert.Same(endpoint4, actual); 200Assert.Same(endpoint1, actual); 282Assert.Same(expected, actual); 305Assert.Same(expected, actual); 334Assert.Same(expected, actual); 412Assert.Same(endpoint, Assert.Single(allMatches).Entry.Data);

Tree\TreeRouterTest.cs (31)

DelegateTests.cs (1)

32Assert.Same(server, delegationFeature);

ResponseBodyTests.cs (3)

326Assert.Same(state, httpContext); 354Assert.Same(state, httpContext); 382Assert.Same(state, httpContext);

ResponseSendFileTests.cs (1)

286Assert.Same(state, httpContext);

ResponseTests.cs (4)

137Assert.Same(state, httpContext); 143Assert.Same(state, httpContext); 172Assert.Same(state, httpContext); 201Assert.Same(state, httpContext);

BodyControlTests.cs (13)

28Assert.Same(ex, 30Assert.Same(ex, 47Assert.Same(ex, 50Assert.Same(ex, 53Assert.Same(ex, 73Assert.Same(ex, 76Assert.Same(ex, 78Assert.Same(ex, 94Assert.Same(ex, 96Assert.Same(ex, 98Assert.Same(ex, 100Assert.Same(ex, 102Assert.Same(ex,

CertificatePathWatcherTests.cs (1)

62Assert.Same(changeToken, watcher.GetChangeToken());

ConcurrentPipeWriterTests.cs (5)

76Assert.Same(completeEx, mockPipeWriter.CompleteException); 174Assert.Same(completeEx, mockPipeWriter.CompleteException); 258Assert.Same(completeEx, mockPipeWriter.CompleteException); 326Assert.Same(completeEx, mockPipeWriter.CompleteException); 409Assert.Same(completeEx, mockPipeWriter.CompleteException);

Http1\Http1HttpProtocolFeatureCollectionTests.cs (15)

HttpRequestHeadersTests.cs (7)

109Assert.Same(Array.Empty<string>(), (string[])headers["custom"]); 110Assert.Same(Array.Empty<string>(), (string[])headers["host"]); 111Assert.Same(Array.Empty<string>(), (string[])headers["Content-Length"]); 114Assert.Same(Array.Empty<string>(), (string[])headers.Host); 115Assert.Same(Array.Empty<string>(), (string[])headers.AltSvc); 171Assert.Same(enumerator0, enumerator1); 432Assert.Same(values.PrevHeaderValue, values.NextHeaderValue);

HttpRequestPipeReaderTests.cs (1)

42Assert.Same(error, exception);

HttpRequestStreamTests.cs (2)

151Assert.Same(error, exception); 185Assert.Same(error, exception);

HttpUtilitiesTest.cs (1)

134Assert.Same(knownString1, knownString2);

KestrelServerTests.cs (5)

445Assert.Same(customEndpoint, transportEndPoint.BoundEndPoint); 446Assert.Same(customEndpoint, multiplexedTransportEndPoint.BoundEndPoint); 646Assert.Same(unbindException, await Assert.ThrowsAsync<InvalidOperationException>(() => stopTask1.TimeoutAfter(timeout))); 647Assert.Same(unbindException, await Assert.ThrowsAsync<InvalidOperationException>(() => stopTask2.TimeoutAfter(timeout))); 648Assert.Same(unbindException, await Assert.ThrowsAsync<InvalidOperationException>(() => stopTask3.TimeoutAfter(timeout)));

ListenOptionsTests.cs (1)

47Assert.Same(serviceProvider, clone.ApplicationServices);

MessageBodyTests.cs (1)

568Assert.Same(MessageBody.ZeroContentLengthKeepAlive, result);

SniOptionsSelectorTests.cs (14)

StartLineTests.cs (24)

KestrelConfigurationLoaderTests.cs (2)

1497Assert.Same(endpointsToStart[0], serverOptions.ConfigurationBackedListenOptions[1]); 1498Assert.Same(endpointsToStart[1], serverOptions.ConfigurationBackedListenOptions[2]);

AdaptiveCapacityDictionaryTests.cs (7)

83Assert.Same(StringComparer.OrdinalIgnoreCase, dict.Comparer); 890Assert.Same(value, removedValue); 910Assert.Same(value, removedValue); 932Assert.Same(value, removedValue); 957Assert.Same(value, removedValue); 982Assert.Same(value, removedValue); 1319Assert.Same(Array.Empty<KeyValuePair<string, object?>>(), value._arrayStorage);

CopyOnWriteDictionaryHolderTest.cs (1)

36Assert.Same(source, holder.ReadDictionary);

CopyOnWriteDictionaryTest.cs (2)

51Assert.Same(values, copyOnWriteDictionary.Values); 53Assert.Same(enumerator, copyOnWriteDictionary.GetEnumerator());

ObjectMethodExecutorTest.cs (15)

PropertyHelperTest.cs (2)

119Assert.Same(helpers1, helpers2); 120Assert.Same(helpers1[0], helpers2[0]);

HttpConnectionTests.cs (3)

111Assert.Same(clientCertificate, httpClientHandler.ClientCertificates[0]); 113Assert.Same(httpOptions.Proxy, httpClientHandler.Proxy); 114Assert.Same(httpOptions.Credentials, httpClientHandler.Credentials);

HubConnectionBuilderExtensionsTests.cs (2)

72Assert.Same(proxy, value.Proxy); 87Assert.Same(proxy, value.Proxy);

HubConnectionTests.cs (4)

41Assert.Same(exception, actualException); 56Assert.Same(exception, actualException); 799Assert.Same(originalOptions.AccessTokenProvider, accessTokenFactory); 800Assert.Same(resolvedOptions.Headers, originalOptions.Headers);

HubConnectionTests.Reconnect.cs (24)

Internal\Protocol\JsonHubProtocolTestsBase.cs (1)

209Assert.Same(Array.Empty<string>(), (message as InvocationMessage).StreamIds);

RedisProtocolTests.cs (2)

166Assert.Same(_testMessage.Target, invocation.Target); 167Assert.Same(_testMessage.Arguments, invocation.Arguments);

ClientProxyTests.cs (9)

39Assert.Same(data, arg); 60Assert.Same(data, arg); 81Assert.Same(data, arg); 102Assert.Same(data, arg); 123Assert.Same(data, arg); 144Assert.Same(data, arg); 165Assert.Same(data, arg); 186Assert.Same(data, arg); 207Assert.Same(data, arg);

HubConnectionHandlerTestUtils\Hubs.cs (1)

1413Assert.Same(service, service2);

Internal\DefaultHubProtocolResolverTests.cs (2)

84Assert.Same(jsonProtocol2, resolvedProtocol); 100Assert.Same(jsonProtocol2, hubProtocols[0]);

Internal\TypedClientBuilderTests.cs (5)

28Assert.Same(objArg, send.Arguments[2]); 52Assert.Same(objArg, send.Arguments[2]); 79arg3 => Assert.Same(objArg, arg3)); 221arg2 => Assert.Same(objArg, arg2), 222arg3 => Assert.Same("test", arg3));

SerializedHubMessageTests.cs (2)

26actualMessage => Assert.Same(invocation, actualMessage)); 46actualMessage => Assert.Same(invocation, actualMessage));

WebSocketsTransportTests.cs (3)

55Assert.Same(clientCertificate, webSocketsOptions.ClientCertificates[0]); 57Assert.Same(httpOptions.Proxy, webSocketsOptions.Proxy); 58Assert.Same(httpOptions.Credentials, webSocketsOptions.Credentials);

TestClientTests.cs (1)

935Assert.Same(value, capturedValue);

WebApplicationTests.cs (15)

WebSocketMiddlewareTests.cs (1)

728Assert.Same(HeaderNames.Upgrade, context.Request.Headers.Connection.ToString());

Construction\ProjectRootElement_Tests.cs (2)

1315Assert.Same(xml0, xml1); 1316Assert.Same(xml0, xml2);

Definition\ProjectCollection_Tests.cs (6)

1180Assert.Same(collection, sender); 1338Assert.Same(collection, sender); 1339Assert.Same(pre, e.ProjectXml); 1397Assert.Same(collection, sender); 1398Assert.Same(project, e.Project); 1488Assert.Same(collection, sender);

Definition\ProjectItem_Tests.cs (2)

2001Assert.Same(projectItem, project.GetItemsByEvaluatedInclude(projectItem.EvaluatedInclude).Single()); 2007Assert.Same(projectItem, project.GetItemsByEvaluatedInclude(projectItem.EvaluatedInclude).Single());

Instance\ProjectInstance_Tests.cs (1)

139Assert.Same(returned, item);

ObjectModelRemoting\Helpers\ViewValidation.construction.cs (4)

36Assert.Same(c1Where, c1.Get(where)); 65Assert.Same(c1Where, c1.Get(where)); 437Assert.Same(realChild.Parent, realXml); 445Assert.Same(viewChild.Parent, viewXml);

ObjectModelRemoting\Helpers\ViewValidation.evaluation.cs (10)

ObjectModelRemoting\LinkedConstructionModify_Tests.cs (7)

376Assert.Same(choose.View, chooseCreataed.View); 392Assert.Same(otherWise.View, choose.View.OtherwiseElement); 393Assert.Same(otherWise.Real, choose.Real.OtherwiseElement); 501Assert.Same(body.View, usingTaskFile.View.TaskBody); 502Assert.Same(body.Real, usingTaskFile.Real.TaskBody); 506Assert.Same(pg.View, usingTaskFile.View.ParameterGroup); 507Assert.Same(pg.Real, usingTaskFile.Real.ParameterGroup);

ObjectModelRemoting\LinkedProjectCollection_Tests.cs (4)

46Assert.Same(proj1, loadedLocal.FirstOrDefault()); 47Assert.Same(proj2, loadedRemote.FirstOrDefault()); 56Assert.Same(localProj, proj1); 99Assert.Same(proj0local, prj0Coll.First());

BackEnd\BuildManager_Tests.cs (2)

2066Assert.Same(preRoot, ProjectRootElement.TryOpen(rootProjectPath, projectCollection)); // "The root project file should be in the weak cache after a build." 2067Assert.Same(preImported, ProjectRootElement.TryOpen(importedProjectPath, projectCollection)); // "The imported project file should be in the weak cache after a build."

BackEnd\BuildRequestConfiguration_Tests.cs (1)

190Assert.Same(config1.Project, projectInstance);

Evaluation\Evaluator_Tests.cs (1)

1679Assert.Same(metadataElementFromProjectRootElement, metadatum.Predecessor.Xml);

Evaluation\ProjectRootElementCache_Tests.cs (1)

76Assert.Same(projectRootElement, projectRootElement2);

Evaluation\ProjectStringCache_Tests.cs (9)

72Assert.Same(node1.Value, node2.Value); 134Assert.Same(node1.Attributes[0].Value, node2.Attributes[0].Value); 143Assert.Same(node1.Value, node2.Value); 219Assert.Same(node1.Value, node2.Value); 280Assert.Same(return1, return2); 322Assert.Same(return1, return2); 412Assert.Same(return1, return3); 452Assert.Same(return2, return3); 494Assert.Same(return2, return3);

Evaluation\UsedUninitializedProperties_Tests.cs (2)

32Assert.Same(location1, elementLocation); 35Assert.Same(location1, elementLocation);

Globbing\CompositeGlob_Tests.cs (3)

156Assert.Same(glob, composite); 168Assert.Same(glob1, composite.Globs.First()); 169Assert.Same(glob2, composite.Globs.Skip(1).First());

Globbing\MSBuildGlob_Tests.cs (1)

158Assert.Same(glob1.TestOnlyRegex, glob2.TestOnlyRegex);

Instance\HostServices_Tests.cs (4)

49Assert.Same(hostObject, hostServices.GetHostObject("foo.proj", "target", "task")); 50Assert.Same(hostObject2, hostServices.GetHostObject("foo.proj", "target2", "task")); 51Assert.Same(hostObject3, hostServices.GetHostObject("foo.proj", "target", "task2")); 102Assert.Same(hostObject, hostServices.GetHostObject("project", "target", "task"));

OpenApiAddFileTests.cs (1)

97Assert.Same(openApiRefs[0].ParentNode, openApiRefs[1].ParentNode);

EqualityAssertsTests.cs (2)

579 Assert.Same(obj2, obj1.Equals_Other); 2918 Assert.Same(obj2, obj1.Equals_Other);

ExceptionAssertsTests.cs (19)

IdentityAssertsTests.cs (3)

34 Assert.Same(actual, actual); 40 var ex = Record.Exception(() => Assert.Same("bob", "jim")); 55 Assert.Throws<SameException>(() => Assert.Same(0, 0));

TypeAssertsTests.cs (3)

62 Assert.Same(ex, result); 131 Assert.Same(ex, result); 360 Assert.Same(ex, result);

L2Tests.cs (2)

59Assert.Same(s, x); 79Assert.Same(s, x);

StampedeTests.cs (1)

311Assert.Same(first, second);

SqlServerCacheServicesExtensionsTest.cs (1)

60Assert.Same(services, services.AddDistributedSqlServerCache(_ => { }));

CacheServiceExtensionsTests.cs (1)

57Assert.Same(services, services.AddStackExchangeRedisCache(_ => { }));

DefaultHealthCheckServiceTest.cs (3)

112Assert.Same(exception, actual.Value.Exception); 298Assert.Same(thrownException, actual.Value.Exception); 305Assert.Same(faultedException, actual.Value.Exception);

DependencyInjection\HealthChecksBuilderTest.cs (1)

82Assert.Same(instance, registration.Factory(serviceProvider));

Manifest\ManifestEntryTests.cs (2)

47Assert.Same(directory, result); 93Assert.Same(ManifestEntry.UnknownPath, result);

DependencyInjection\PollyHttpClientBuilderExtensionsTest.cs (11)

HttpRequestMessageExtensionsTest.cs (2)

28Assert.Same(expected, actual); 80Assert.Same(expected, actual);

PolicyHttpMessageHandlerTest.cs (12)

53Assert.Same(expected, response); 98Assert.Same(expected, response); 99Assert.Same(expectedRequest, policySelectorRequest); 146Assert.Same(expected, response); 198Assert.Same(expected, response); 268Assert.Same(expected, response); 284Assert.Same(context, req.GetPolicyExecutionContext()); 296Assert.Same(expected, response); 314Assert.Same(c, req.GetPolicyExecutionContext()); 325Assert.Same(expectedContext, context); 326Assert.Same(expectedContext, request.GetPolicyExecutionContext()); // We don't clean up the context if the caller or earlier delegating handlers had supplied it. 327Assert.Same(expected, response);

ResourceManagerStringLocalizerFactoryTest.cs (2)

106Assert.Same(result1, result2); 222Assert.Same(result1, result2);

DefaultObjectPoolTest.cs (3)

24Assert.Same(obj1, obj2); 40Assert.Same(list1, list2); 86Assert.Same(r, p.Get());

DisposableObjectPoolTest.cs (2)

25Assert.Same(obj1, obj2); 41Assert.Same(list1, list2);

EncoderServiceCollectionExtensionsTests.cs (9)

DotNetObjectReferenceTest.cs (3)

12Assert.Same(obj, DotNetObjectReference.Create(obj).Value); 74Assert.Same(objRef, jsRuntime.GetObjectReference(objectId)); 92Assert.Same(objRef, jsRuntime.GetObjectReference(objectId));

Infrastructure\ByteArrayJsonConverterTest.cs (2)

213Assert.Same(byteArray3, deserialized[0]); 214Assert.Same(byteArray2, deserialized[1]);

Infrastructure\DotNetObjectReferenceJsonConverterTest.cs (4)

85Assert.Same(input, deserialized.Value); 105Assert.Same(instance1, deserialized[0].Value); 106Assert.Same(instance2, deserialized[1].Value); 126Assert.Same(input, deserialized.Value);

JSInProcessRuntimeTest.cs (3)

58Assert.Same(obj1, runtime.GetObjectReference(1).Value); 59Assert.Same(obj2, runtime.GetObjectReference(2).Value); 60Assert.Same(obj3, runtime.GetObjectReference(3).Value);

JSRuntimeTest.cs (6)

283Assert.Same(obj1Ref, runtime.GetObjectReference(1)); 284Assert.Same(obj1, obj1Ref.Value); 286Assert.Same(obj2, runtime.GetObjectReference(2).Value); 287Assert.Same(obj3, runtime.GetObjectReference(3).Value); 288Assert.Same(obj1, runtime.GetObjectReference(4).Value); 309Assert.Same(exception, error.InnerException);

MediaTypeHeaderValueTest.cs (11)

132Assert.Same(mediaType0.MediaType.Value, mediaType1.MediaType.Value); 143Assert.Same(mediaType0.MediaType.Value, mediaType1.MediaType.Value); 159Assert.Same(mediaType0.MediaType.Value, mediaType1.MediaType.Value); 165Assert.Same(pair0.Name.Value, pair1.Name.Value); 166Assert.Same(pair0.Value.Value, pair1.Value.Value); 178Assert.Same(mediaType0.MediaType.Value, mediaType1.MediaType.Value); 193Assert.Same(pair0.Name.Value, pair1.Name.Value); 194Assert.Same(pair0.Value.Value, pair1.Value.Value); 206Assert.Same(mediaType2.MediaType.Value, mediaType1.MediaType.Value); 216Assert.Same(pair2.Name.Value, pair1.Name.Value); 217Assert.Same(pair2.Value.Value, pair1.Value.Value);

NameValueHeaderValueTest.cs (8)

63Assert.Same(pair0.Name.Value, pair1.Name.Value); 79Assert.Same(pair0.Name.Value, pair1.Name.Value); 98Assert.Same(pair0.Name.Value, pair1.Name.Value); 99Assert.Same(pair0.Value.Value, pair1.Value.Value); 113Assert.Same(pair0.Name.Value, pair1.Name.Value); 114Assert.Same(pair0.Value.Value, pair1.Value.Value); 132Assert.Same(pair0.Name.Value, pair1.Name.Value); 133Assert.Same(pair0.Value.Value, pair1.Value.Value);

CodeAnalysisExtensionsTest.cs (7)

317Assert.Same(attribute, attributeData.AttributeClass); 322Assert.Same(attribute, attributeData.AttributeClass); 360Assert.Same(attribute, attributeData.AttributeClass); 365Assert.Same(attribute, attributeData.AttributeClass); 370Assert.Same(attribute, attributeData.AttributeClass); 408Assert.Same(attribute, attributeData.AttributeClass); 446Assert.Same(attribute, attributeData.AttributeClass);

ApiActionsDoNotRequireExplicitModelValidationCheckAnalyzerIntegrationTest.cs (1)

78Assert.Same(descriptor, diagnostic.Descriptor);

ApiConventionAnalyzerIntegrationTest.cs (1)

294Assert.Same(descriptor, diagnostic.Descriptor);

SymbolApiResponseMetadataProviderTest.cs (5)

285Assert.Same(method, metadata.AttributeSource); 415Assert.Same(expected, result); 433Assert.Same(expected, result); 451Assert.Same(expected, result); 469Assert.Same(expected, result);

System\Windows\Markup\ArrayExtensionTests.cs (3)

19Assert.Same(extension.Items, extension.Items); 30Assert.Same(extension.Items, extension.Items); 58Assert.Same(extension.Items, extension.Items);

System\Windows\Markup\ContentWrapperAttributeTests.cs (1)

60Assert.Same(attribute, attribute.TypeId);

System\Windows\Markup\DependsOnAttributeTests.cs (1)

25Assert.Same(attribute, attribute.TypeId);

System\Windows\Markup\PropertyDefinitionTests.cs (1)

25Assert.Same(definition.Attributes, definition.Attributes);

System\Windows\Markup\ValueSerializerTests.cs (2)

245Assert.Same(serializer, ValueSerializer.GetSerializerFor(typeof(int), context)); 312Assert.Same(serializer, ValueSerializer.GetSerializerFor(descriptor, context));

System\Windows\Markup\XDataTests.cs (2)

37Assert.Same(data.XmlReader, reader); 57Assert.Same(reader, data.XmlReader);