1289Assert.Same(model, operation.SemanticModel);

31Assert.Same(fallbackResult, propertyAccessor(SyntaxFactory.AccessorList())); 50Assert.Same(fallbackResult, propertyAccessor(new EmptySymbol())); 69Assert.Same(fallbackResult, accessor(SyntaxFactory.AccessorList(), 0));

63Assert.Same(syncCtx, callbackSyncContext); 128Assert.Same(syncCtx, callbackSyncContext);

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

87Assert.Same(KestrelEventSource.Log, connectionStart.EventSource); 95Assert.Same(KestrelEventSource.Log, firstRequestStart.EventSource); 103Assert.Same(KestrelEventSource.Log, firstRequestStop.EventSource); 113Assert.Same(KestrelEventSource.Log, secondRequestStart.EventSource); 121Assert.Same(KestrelEventSource.Log, secondRequestStop.EventSource); 130Assert.Same(KestrelEventSource.Log, connectionStop.EventSource); 211Assert.Same(KestrelEventSource.Log, connectionStart.EventSource); 219Assert.Same(KestrelEventSource.Log, tlsHandshakeStart.EventSource); 228Assert.Same(KestrelEventSource.Log, tlsHandshakeStop.EventSource); 239Assert.Same(KestrelEventSource.Log, requestStart.EventSource); 247Assert.Same(KestrelEventSource.Log, requestStop.EventSource); 257Assert.Same(KestrelEventSource.Log, connectionStop.EventSource); 316Assert.Same(KestrelEventSource.Log, connectionStart.EventSource); 323Assert.Same(KestrelEventSource.Log, tlsHandshakeStart.EventSource); 331Assert.Same(KestrelEventSource.Log, tlsHandshakeFailed.EventSource); 339Assert.Same(KestrelEventSource.Log, tlsHandshakeStop.EventSource); 347Assert.Same(KestrelEventSource.Log, connectionStop.EventSource); 397Assert.Same(KestrelEventSource.Log, connectionStart.EventSource); 404Assert.Same(KestrelEventSource.Log, connectionRejected.EventSource); 412Assert.Same(KestrelEventSource.Log, connectionStop.EventSource);

208Assert.Same(contentType1, contentType2); 209Assert.Same(authority1, authority2); 210Assert.Same(path1, path2); 5328Assert.Same(ioException, logMessage.Exception); 5347Assert.Same(exception, logMessage.Exception);

436Assert.Same(streamContext1, streamContext2); 471Assert.Same(contentType1, contentType2); 472Assert.Same(authority1, authority2); 545Assert.Same(first, last);

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

1318Assert.Same(originalRequestHeaders, requestFeature.Headers); 2125Assert.Same(initialContentTypeValue, contentTypeHeaderValue);

2682Assert.Same(onStartingException, writeException.InnerException); 3085Assert.Same(originalResponseHeaders, responseFeature.Headers);

303Assert.Same(headers, ctx.Features.Get<IHttpRequestFeature>().Headers); 308Assert.Same(body, ctx.Request.Body); 343Assert.Same(headers, ctx.Features.Get<IHttpResponseFeature>().Headers); 349Assert.Same(body, ctx.Response.Body);

364Assert.Same(contentType1, contentType2); 365Assert.Same(authority1, authority2); 953Assert.Same((string)request2Headers["alt-used"], (string)request3Headers["alt-used"]); 1510Assert.Same(request1HeaderValue, request2HeaderValue);

314Assert.Same(ioException, ex.InnerException); 339Assert.Same(exception, ex.InnerException);

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

45Assert.Same(DiagnosticDescriptors.RoutePatternIssue, diagnostic.Descriptor); 77Assert.Same(DiagnosticDescriptors.RoutePatternIssue, diagnostic.Descriptor); 110Assert.Same(DiagnosticDescriptors.RoutePatternIssue, diagnostic.Descriptor); 138Assert.Same(DiagnosticDescriptors.RoutePatternIssue, diagnostic.Descriptor); 166Assert.Same(DiagnosticDescriptors.RoutePatternIssue, diagnostic.Descriptor); 195Assert.Same(DiagnosticDescriptors.RoutePatternIssue, diagnostic.Descriptor); 227Assert.Same(DiagnosticDescriptors.RoutePatternIssue, d.Descriptor); 232Assert.Same(DiagnosticDescriptors.RoutePatternIssue, d.Descriptor); 294Assert.Same(DiagnosticDescriptors.RoutePatternIssue, d.Descriptor); 334Assert.Same(DiagnosticDescriptors.RoutePatternUnusedParameter, d.Descriptor); 488Assert.Same(DiagnosticDescriptors.RoutePatternUnusedParameter, d.Descriptor);

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

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

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

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

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

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

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

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

122Assert.Same(DiagnosticDescriptors.UseTopLevelRouteRegistrationsInsteadOfUseEndpoints, diagnostic.Descriptor); 163Assert.Same(DiagnosticDescriptors.UseTopLevelRouteRegistrationsInsteadOfUseEndpoints, diagnostic1.Descriptor); 167Assert.Same(DiagnosticDescriptors.UseTopLevelRouteRegistrationsInsteadOfUseEndpoints, diagnostic2.Descriptor); 171Assert.Same(DiagnosticDescriptors.UseTopLevelRouteRegistrationsInsteadOfUseEndpoints, diagnostic3.Descriptor); 175Assert.Same(DiagnosticDescriptors.UseTopLevelRouteRegistrationsInsteadOfUseEndpoints, diagnostic2.Descriptor); 207Assert.Same(DiagnosticDescriptors.UseTopLevelRouteRegistrationsInsteadOfUseEndpoints, diagnostic.Descriptor); 233Assert.Same(DiagnosticDescriptors.UseTopLevelRouteRegistrationsInsteadOfUseEndpoints, diagnostic.Descriptor); 263Assert.Same(DiagnosticDescriptors.UseTopLevelRouteRegistrationsInsteadOfUseEndpoints, diagnostic1.Descriptor); 267Assert.Same(DiagnosticDescriptors.UseTopLevelRouteRegistrationsInsteadOfUseEndpoints, diagnostic2.Descriptor);

40Assert.Same(value, stored); 91Assert.Same(value, stored);

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

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

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

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

788Assert.Same(context.User, authenticateResultFeature.AuthenticateResult.Principal); 851Assert.Same(context.User, authenticateResultFeature.AuthenticateResult.Principal); 875Assert.Same(context.User, authenticateResultFeature.AuthenticateResult.Principal); 901Assert.Same(context.User, authenticateResultFeature.AuthenticateResult.Principal); 905Assert.Same(context.User, newTicket.Principal); 943Assert.Same(testAuthenticateResultFeature, authenticateResultFeature); 969Assert.Same(testAuthenticateResultFeature, authenticateResultFeature); 970Assert.Same(authenticateResult, authenticateResultFeature.AuthenticateResult);

34Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 39Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 44Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 49Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 54Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 59Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 78Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 83Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 88Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 93Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 98Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor);

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

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

352Assert.Same(metadata, property.PropertyMetadata); 404Assert.Same(property.PropertyMetadata, subProperty.PropertyMetadata); 442Assert.Same(metadata, property.PropertyMetadata.ElementType); 479Assert.Same(metadata, property.PropertyMetadata.ValueType);

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

28Assert.Same(editContext, returnValue);

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

49Assert.Same(model, fieldIdentifier.Model); 138Assert.Same(model, fieldIdentifier.Model); 174Assert.Same(model, fieldIdentifier.Model); 186Assert.Same(model, fieldIdentifier.Model); 194Assert.Same(this, fieldIdentifier.Model); 203Assert.Same(parentModel.Child, fieldIdentifier.Model); 212Assert.Same(models[1], fieldIdentifier.Model); 221Assert.Same(model, fieldIdentifier.Model); 229Assert.Same(model, fieldIdentifier.Model); 242Assert.Same(Model2, fieldIdentifier.Model); 254Assert.Same(model3, fieldIdentifier.Model); 262Assert.Same(@ÖvrigAnställning, fieldIdentifier.Model);

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

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

34Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 39Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 44Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 49Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 54Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 59Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 78Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 83Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 88Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 93Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor); 98Assert.Same(DiagnosticDescriptors.DoNotUseRenderTreeTypes, diagnostic.Descriptor);

155Assert.Same(componentException, eventArgs.ExceptionObject); 265Assert.Same(circuitHost, sender); 286Assert.Same(ex, aex.InnerExceptions.Single()); 854Assert.Same(Dispatcher, SynchronizationContext.Current);

204Assert.Same(persistedState, circuitPersistenceProvider.State);

32Assert.Same(circuitHost, actual); 52Assert.Same(circuitHost, result); 53Assert.Same(newClient, circuitHost.Client.Client); 54Assert.Same(newConnectionId, circuitHost.Client.ConnectionId); 57Assert.Same(circuitHost, actual); 77Assert.Same(circuitHost, result); 78Assert.Same(newClient, circuitHost.Client.Client); 79Assert.Same(newConnectionId, circuitHost.Client.ConnectionId); 82Assert.Same(circuitHost, actual); 264Assert.Same(circuitHost, actual); 265Assert.Same(client, circuitHost.Client.Client); 403Assert.Same(circuitHost, actual); 404Assert.Same(client, circuitHost.Client.Client); 463Assert.Same(circuitHost, cacheValue); 560Assert.Same(circuitHost, connectedCircuit);

28Assert.Same(persistedState, result); 62Assert.Same(persistedState, firstResult);

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

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

85Assert.Same(states[1].Component, match.ValueSupplier); 108Assert.Same(states[3].Component, match.ValueSupplier); 113Assert.Same(states[1].Component, match.ValueSupplier); 134Assert.Same(states[0].Component, match.ValueSupplier); 139Assert.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); 328Assert.Same(states[2].Component, match.ValueSupplier); 333Assert.Same(states[3].Component, match.ValueSupplier); 354Assert.Same(states[1].Component, match.ValueSupplier);

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

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

152Assert.Same(resolvedComponent, instance); 156Assert.Same(componentActivator, renderer.SuppliedActivator); 202Assert.Same(resolvedComponent, instance); 205Assert.Same(componentActivator, renderer.SuppliedActivator); 206Assert.Same(callSiteRenderMode, renderer.SuppliedRenderMode);

94Assert.Same(serviceInstance, instance.MyService); 108Assert.Same(serviceInstance, instance.MyService); 127Assert.Same(serviceInstance, instance.PublicReadWrite); 128Assert.Same(serviceInstance, instance.PublicReadOnly); 129Assert.Same(serviceInstance, instance.PrivateValue); 130Assert.Same(otherServiceInstance, instance.DifferentServiceType); 131Assert.Same(concreteServiceInstance, instance.ConcreteServiceType); 132Assert.Same(serviceInstance, instance.KeyedService); 146Assert.Same(serviceInstance, instance.MyService); 160Assert.Same(serviceInstance, instance.PrivateMyService);

22Assert.Same(@delegate, callback.Delegate); 23Assert.Same(component, callback.Receiver); 38Assert.Same(@delegate, callback.Delegate); 39Assert.Same(component, callback.Receiver); 56Assert.Same(@delegate, callback.Delegate); 57Assert.Same(component, callback.Receiver); 74Assert.Same(@delegate, callback.Delegate); 75Assert.Same(anotherComponent, callback.Receiver); 90Assert.Same(component, callback.Receiver); 105Assert.Same(@delegate, callback.Delegate); 106Assert.Same(component, callback.Receiver); 123Assert.Same(@delegate, callback.Delegate); 124Assert.Same(component, callback.Receiver); 141Assert.Same(@delegate, callback.Delegate); 142Assert.Same(anotherComponent, callback.Receiver); 157Assert.Same(component, callback.Receiver); 172Assert.Same(@delegate, callback.Delegate); 173Assert.Same(component, callback.Receiver); 190Assert.Same(@delegate, callback.Delegate); 191Assert.Same(component, callback.Receiver); 208Assert.Same(@delegate, callback.Delegate); 209Assert.Same(anotherComponent, callback.Receiver); 224Assert.Same(@delegate, callback.Delegate); 225Assert.Same(component, callback.Receiver); 240Assert.Same(component, callback.Receiver); 257Assert.Same(@delegate, callback.Delegate); 258Assert.Same(component, callback.Receiver); 275Assert.Same(@delegate, callback.Delegate); 276Assert.Same(anotherComponent, callback.Receiver); 291Assert.Same(component, callback.Receiver); 309Assert.Same(@delegate, callback.Delegate); 310Assert.Same(component, callback.Receiver); 325Assert.Same(@delegate, callback.Delegate); 326Assert.Same(component, callback.Receiver); 343Assert.Same(@delegate, callback.Delegate); 344Assert.Same(component, callback.Receiver); 361Assert.Same(@delegate, callback.Delegate); 362Assert.Same(anotherComponent, callback.Receiver); 377Assert.Same(component, callback.Receiver); 392Assert.Same(@delegate, callback.Delegate); 393Assert.Same(component, callback.Receiver); 410Assert.Same(@delegate, callback.Delegate); 411Assert.Same(component, callback.Receiver); 426Assert.Same(component, callback.Receiver); 443Assert.Same(@delegate, callback.Delegate); 444Assert.Same(anotherComponent, callback.Receiver); 459Assert.Same(@delegate, callback.Delegate); 460Assert.Same(component, callback.Receiver); 477Assert.Same(@delegate, callback.Delegate); 478Assert.Same(component, callback.Receiver); 495Assert.Same(@delegate, callback.Delegate); 496Assert.Same(anotherComponent, callback.Receiver); 511Assert.Same(component, callback.Receiver); 526Assert.Same(@delegate, callback.Delegate); 527Assert.Same(component, callback.Receiver); 544Assert.Same(@delegate, callback.Delegate); 545Assert.Same(component, callback.Receiver); 562Assert.Same(@delegate, callback.Delegate); 563Assert.Same(anotherComponent, callback.Receiver); 578Assert.Same(component, callback.Receiver); 593Assert.Same(@delegate, callback.Delegate); 594Assert.Same(component, callback.Receiver); 609Assert.Same(@delegate, callback.Delegate); 610Assert.Same(component, callback.Receiver);

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

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

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

21Assert.Same(builder.Buffer, segment.Array); 40Assert.Same(originalBuffer, segment.Array); 47Assert.Same(builder.Buffer, segment.Array);

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

155Assert.Same(CultureInfo.CurrentCulture, capturedCulture); 156Assert.Same(context, capturedContext); 247Assert.Same(Thread.CurrentThread, capturedThread); 252Assert.Same(Thread.CurrentThread, capturedThread); 289Assert.Same(CultureInfo.CurrentCulture, capturedCulture); 290Assert.Same(context, capturedContext); 308Assert.Same(thread, capturedThread); 398Assert.Same(CultureInfo.CurrentCulture, capturedCulture); 399Assert.Same(context, capturedContext); 418Assert.Same(thread, capturedThread); 508Assert.Same(thread, await task); 599Assert.Same(thread, capturedThread); 690Assert.Same(thread, await task);

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

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); 1780Assert.Same(originalComponentInstance, newComponentInstance); 1924Assert.Same(capturedInstance1, capturedInstance2); 1937Assert.Same(capturedInstance1, frame.Component); 2060Assert.Same(oldComponents[0], newComponents[1]); 2061Assert.Same(oldComponents[1], newComponents[0]);

34Assert.Same(routes1, routes2); 48Assert.Same(routes1, routes2); 1110Assert.Same(typeof(TestHandler1), context.Handler);

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

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

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

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

23Assert.Same(file, instance.File); 54Assert.Same(files, instance.GetMultipleFiles());

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

28Assert.Same(persistenceManager.State, persistentState);

40Assert.Same(eventSource, eventData.EventSource);

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

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

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

113Assert.Same(algorithmHandle, algorithmHandleSecondAttempt); 135Assert.Same(algorithmHandle, algorithmHandleSecondAttempt); 166Assert.Same(algorithmHandle, algorithmHandleSecondAttempt);

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

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

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

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

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); 273Assert.Same(key1, resolution.DefaultKey); 384Assert.Same(key1, resolution.FallbackKey); 444Assert.Same(key, resolution.DefaultKey);

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

593Assert.Same(expectedKeyRing, retVal1); 594Assert.Same(expectedKeyRing, retVal2); 633Assert.Same(expectedKeyRing1, retVal1); 634Assert.Same(expectedKeyRing1, retVal2); 635Assert.Same(expectedKeyRing2, retVal3); 667Assert.Same(expectedKeyRing1, retVal1); 668Assert.Same(expectedKeyRing2, retVal2); 718Assert.Same(expectedKeyRing, foregroundRetVal); 719Assert.Same(expectedKeyRing, backgroundRetVal); 742Assert.Same(originalKeyRing, keyRingProvider.GetCurrentKeyRingCore(originalKeyRingTime)); 745Assert.Same(originalKeyRing, keyRingProvider.GetCurrentKeyRingCore(throwKeyRingTime)); // Seeing the exception didn't clobber the cache 746Assert.Same(updatedKeyRing, keyRingProvider.GetCurrentKeyRingCore(updatedKeyRingTime, forceRefresh: true)); // forceRefresh to wait for updated value 837Assert.Same(expectedKeyRing1, keyRingProvider.GetCurrentKeyRingCore(time1)); // Ensure the cache is populated 873Assert.Same(expectedKeyRing1, updatedKeyRing);

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

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

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

24Assert.Same(original, retVal);

205Assert.Same(value1, value2); 206Assert.Same(value1, value3);

138Assert.Same(Context, receivedContext);

63Assert.Same(previousContext, context.HttpContext); 67Assert.Same(previousContext, context.HttpContext); 120Assert.Same(initialActivity, activityFeature.Activity);

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

44Assert.Same(hostingEventSource, eventData.EventSource); 67Assert.Same(hostingEventSource, eventData.EventSource); 123Assert.Same(hostingEventSource, eventData.EventSource); 151Assert.Same(hostingEventSource, eventData.EventSource); 173Assert.Same(hostingEventSource, eventData.EventSource);

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

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

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

41Assert.Same(expectedMethod, canonicalizedValue);

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

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

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

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

45Assert.Same(httpConnectionsEventSource, eventData.EventSource); 72Assert.Same(httpConnectionsEventSource, eventData.EventSource); 99Assert.Same(httpConnectionsEventSource, eventData.EventSource);

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

1189Assert.Same(myOriginalService, httpContext.Items["service"]); 1209Assert.Same(httpContext, httpContextArgument); 1950Assert.Same(exception, logMessage.Exception); 1983Assert.Same(exception, logMessage.Exception); 2569m => Assert.Same(customMetadata, m), 2891Assert.Same(options.EndpointBuilder.Metadata, result.EndpointMetadata); 3070Assert.Same(initialRequestDelegate, result.RequestDelegate); 3086Assert.Same(options.EndpointBuilder.RequestDelegate, result.RequestDelegate); 3087Assert.Same(options.EndpointBuilder.Metadata, result.EndpointMetadata); 3103Assert.Same(Results.Empty, response);

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

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

28Assert.Same(myOriginalService, httpContext.Items["arg"]); 76Assert.Same(myOriginalService1, httpContext1.Items["arg"]); 77Assert.Same(myOriginalService2, httpContext2.Items["arg"]); 94Assert.Same(myOriginalService, httpContext.Items["arg"]); 114Assert.Same(myOriginalService, httpContext.Items["arg"]); 171Assert.Same(myOriginalService1, httpContext.Items["arg1"]); 200Assert.Same(myOriginalService1, httpContext.Items["arg1"]); 202Assert.Same(myOriginalService2, httpContext.Items["arg3"]);

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

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

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

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

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

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

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

25Assert.Same(FormCollection.Empty, formCollection); 75Assert.Same(formFeature.Form, formCollection); 112Assert.Same(formFeature.Form, formCollection); 219Assert.Same(formCollection, formFeature.Form); 220Assert.Same(formCollection, await context.Request.ReadFormAsync()); 254Assert.Same(formCollection, formFeature.Form); 255Assert.Same(formCollection, await context.Request.ReadFormAsync()); 291Assert.Same(formFeature.Form, formCollection); 292Assert.Same(formCollection, context.Request.Form); 339Assert.Same(formCollection, formFeature.Form); 340Assert.Same(formCollection, await context.Request.ReadFormAsync()); 376Assert.Same(formFeature.Form, formCollection); 377Assert.Same(formCollection, context.Request.Form); 424Assert.Same(formFeature.Form, formCollection); 425Assert.Same(formCollection, context.Request.Form); 573Assert.Same(formFeature.Form, formCollection); 574Assert.Same(formCollection, context.Request.Form);

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

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

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

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

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

467Assert.Same(SignInResult.Success, signInResult); 1540Assert.Same(SignInResult.Failed, result); 1595Assert.Same(SignInResult.Failed, result); 1629Assert.Same(expectedSignInResult, result); 1661Assert.Same(expectedSignInResult, result);

47Assert.Same(provider.GetRequiredService<UserManager<PocoUser>>(), 49Assert.Same(provider.GetRequiredService<RoleManager<PocoRole>>(), 821Assert.Same(passkeys, result); 2172Assert.Same(describer, manager.ErrorDescriber);

32Assert.Same(

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

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

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

56Assert.Same(expectedTargetObject, targetObject); 90Assert.Same(expectedTargetObject, targetObject); 134Assert.Same(expectedTargetObject, targetObject);

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

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

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

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

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

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

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

102Assert.Same(action, description.ActionDescriptor); 1234Assert.Same(formatters[0], apiResponseFormat.Formatter); 1337Assert.Same(formatters[1], format.Formatter); 1356Assert.Same(BindingSource.ModelBinding, parameter.Source); 1360Assert.Same(BindingSource.ModelBinding, parameter.Source); 1364Assert.Same(BindingSource.ModelBinding, parameter.Source); 1381Assert.Same(BindingSource.ModelBinding, parameter.Source); 1401Assert.Same(BindingSource.Path, parameter.Source); 1418Assert.Same(BindingSource.Query, parameter.Source); 1435Assert.Same(BindingSource.Body, parameter.Source); 1454Assert.Same(BindingSource.Form, parameter.Source); 1458Assert.Same(BindingSource.Form, parameter.Source); 1462Assert.Same(BindingSource.Form, parameter.Source); 1484Assert.Same(BindingSource.FormFile, parameter.Source); 1505Assert.Same(BindingSource.Header, parameter.Source); 1551Assert.Same(BindingSource.Custom, parameter.Source); 1570Assert.Same(BindingSource.ModelBinding, parameter.Source); 1574Assert.Same(BindingSource.ModelBinding, parameter.Source); 1578Assert.Same(BindingSource.ModelBinding, parameter.Source); 1597Assert.Same(BindingSource.Path, id.Source); 1601Assert.Same(BindingSource.Body, product.Source); 1605Assert.Same(BindingSource.Header, userId.Source); 1609Assert.Same(BindingSource.ModelBinding, comments.Source); 1628Assert.Same(BindingSource.Query, id.Source); 1647Assert.Same(BindingSource.Query, id.Source); 1666Assert.Same(BindingSource.Query, id.Source); 1685Assert.Same(BindingSource.Query, id.Source); 1704Assert.Same(BindingSource.Query, id.Source); 1723Assert.Same(BindingSource.Query, id.Source); 1742Assert.Same(BindingSource.Query, id.Source); 1761Assert.Same(BindingSource.Query, id.Source); 1765Assert.Same(BindingSource.Query, product.Source); 1785Assert.Same(BindingSource.Path, id.Source); 1789Assert.Same(BindingSource.Body, product.Source); 1793Assert.Same(BindingSource.Header, userId.Source); 1797Assert.Same(BindingSource.Query, comments.Source); 1816Assert.Same(BindingSource.Path, id.Source); 1820Assert.Same(BindingSource.ModelBinding, quantity.Source); 1824Assert.Same(BindingSource.ModelBinding, productId.Source); 1828Assert.Same(BindingSource.Query, price.Source); 1848Assert.Same(BindingSource.Path, id.Source); 1852Assert.Same(BindingSource.Query, quantity.Source); 1856Assert.Same(BindingSource.Query, productId.Source); 1860Assert.Same(BindingSource.Query, productPrice.Source); 1883Assert.Same(BindingSource.Query, id.Source); 1887Assert.Same(BindingSource.Query, name.Source); 1914Assert.Same(BindingSource.Query, id.Source); 1918Assert.Same(BindingSource.Query, name.Source); 1937Assert.Same(BindingSource.Query, c.Source); 1955Assert.Same(BindingSource.Query, products.Source); 1974Assert.Same(BindingSource.ModelBinding, items.Source); 1996Assert.Same(BindingSource.Query, id.Source); 2000Assert.Same(BindingSource.Query, name.Source); 2018Assert.Same(BindingSource.Header, name.Source); 2022Assert.Same(BindingSource.Form, id.Source); 2041Assert.Same(BindingSource.Query, name.Source); 2045Assert.Same(BindingSource.Path, id.Source); 2049Assert.Same(BindingSource.Body, product.Source); 2053Assert.Same(BindingSource.Header, userId.Source); 2057Assert.Same(BindingSource.ModelBinding, comments.Source); 2206Assert.Same(defaultValue, description.DefaultValue);

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

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

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

38a => Assert.Same(action.ActionConstraints[0], a), // Copied by provider 39a => Assert.Same(action.ActionConstraints[1], a)); // Copied by provider 44Assert.Same(actionConstraints1, actionConstraints2); 48a => Assert.Same(actionConstraints1[0], a), // Cached 49a => Assert.Same(actionConstraints1[1], a)); // Cached 76a => Assert.Same(action.ActionConstraints[1], a)); // Copied by provider 81Assert.Same(actionConstraints1, actionConstraints2); 85a => Assert.Same(actionConstraints1[0], a), // Cached 86a => Assert.Same(actionConstraints1[1], a)); // Cached 113a => Assert.Same(action.ActionConstraints[1], a)); // Copied by provider 123a => Assert.Same(actionConstraints1[1], a)); // Cached

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

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

48Assert.Same(value1, value2);

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

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

83Assert.Same(controllerModel, property.Controller); 92Assert.Same(controllerModel, property.Controller); 100Assert.Same(controllerModel, property.Controller); 109Assert.Same(controllerModel, property.Controller); 135Assert.Same(controllerModel, property.Controller); 144Assert.Same(controllerModel, property.Controller); 152Assert.Same(controllerModel, property.Controller); 161Assert.Same(controllerModel, property.Controller); 188Assert.Same(action, parameter.Action); 197Assert.Same(action, parameter.Action); 205Assert.Same(action, parameter.Action); 1364Assert.Same(typeof(ComplexObjectModelBinder), bindingInfo.BinderType); 1379Assert.Same(BindingSource.Path, property.BindingInfo.BindingSource);

31Assert.Same(BindingSource.Custom, parameterModel.BindingInfo.BindingSource); 131Assert.Same(BindingSource.Body, bindingInfo.BindingSource); 165Assert.Same(BindingSource.Body, bindingInfo.BindingSource); 191Assert.Same(BindingSource.Body, bindingInfo.BindingSource); 217Assert.Same(BindingSource.Body, bindingInfo.BindingSource); 238Assert.Same(BindingSource.Query, bindingInfo.BindingSource); 259Assert.Same(BindingSource.Custom, bindingInfo.BindingSource); 280Assert.Same(BindingSource.Custom, bindingInfo.BindingSource); 296Assert.Same(BindingSource.Path, result); 311Assert.Same(BindingSource.Path, result); 326Assert.Same(BindingSource.Path, result); 341Assert.Same(BindingSource.Body, result); 356Assert.Same(BindingSource.Path, result); 371Assert.Same(BindingSource.Path, result); 386Assert.Same(BindingSource.Path, result); 401Assert.Same(BindingSource.Path, result); 416Assert.Same(BindingSource.Path, result); 431Assert.Same(BindingSource.Query, result); 446Assert.Same(BindingSource.Path, result); 461Assert.Same(BindingSource.Path, result); 476Assert.Same(BindingSource.Path, result); 491Assert.Same(BindingSource.Query, result); 506Assert.Same(BindingSource.Body, result); 528Assert.Same(BindingSource.Body, model.BindingInfo.BindingSource); 531Assert.Same(BindingSource.Special, cancellationToken.BindingInfo.BindingSource); 546Assert.Same(BindingSource.Query, result); 561Assert.Same(BindingSource.Body, result); 576Assert.Same(BindingSource.Body, result); 591Assert.Same(BindingSource.Body, result); 606Assert.Same(BindingSource.Body, result); 624Assert.Same(BindingSource.Services, result); 642Assert.Same(BindingSource.Services, result); 662Assert.Same(BindingSource.Query, bindingInfo.BindingSource); 683Assert.Same(BindingSource.Query, bindingInfo.BindingSource); 704Assert.Same(BindingSource.Query, bindingInfo.BindingSource); 724Assert.Same(BindingSource.Query, bindingInfo.BindingSource); 745Assert.Same(BindingSource.Query, bindingInfo.BindingSource); 766Assert.Same(BindingSource.Query, bindingInfo.BindingSource); 787Assert.Same(BindingSource.Query, bindingInfo.BindingSource); 808Assert.Same(BindingSource.Path, bindingInfo.BindingSource); 829Assert.Same(BindingSource.Path, bindingInfo.BindingSource); 850Assert.Same(BindingSource.Path, bindingInfo.BindingSource); 870Assert.Same(BindingSource.Path, bindingInfo.BindingSource); 893Assert.Same(BindingSource.Query, bindingInfo.BindingSource); 894Assert.Same(expectedPredicate, bindingInfo.RequestPredicate); 895Assert.Same(expectedPropertyFilter, bindingInfo.PropertyFilterProvider.PropertyFilter);

71Assert.Same(value1, value2);

62Assert.Same(value1, value2);

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

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

54Assert.Same(url, result.Url); 71Assert.Same(url, result.Url); 88Assert.Same(url, result.Url); 105Assert.Same(url, result.Url); 152Assert.Same(url, result.Url); 169Assert.Same(url, result.Url); 186Assert.Same(url, result.Url); 203Assert.Same(url, result.Url); 884Assert.Same(routeName, resultTemporary.RouteName); 901Assert.Same(routeName, resultTemporary.RouteName); 918Assert.Same(routeName, resultPermanent.RouteName); 935Assert.Same(routeName, resultPermanent.RouteName); 955Assert.Same(routeName, resultTemporary.RouteName); 976Assert.Same(routeName, resultTemporary.RouteName); 997Assert.Same(routeName, resultPermanent.RouteName); 1222Assert.Same(url, result.PageName); 1242Assert.Same(pageName, resultPermanent.PageName); 1263Assert.Same(routeName, resultPermanent.PageName); 1284Assert.Same(routeName, resultPermanent.RouteName); 1301Assert.Same(uri, result.Location); 1438Assert.Same(routeName, result.RouteName); 1479Assert.Same(routeName, result.RouteName); 1510Assert.Same(value, result.Value); 1526Assert.Same(uri, result.Location); 1658Assert.Same(routeName, result.RouteName); 1674Assert.Same(fileContents, result.FileContents); 1692Assert.Same(fileContents, result.FileContents); 1716Assert.Same(fileContents, result.FileContents); 1736Assert.Same(fileContents, result.FileContents); 1760Assert.Same(fileContents, result.FileContents); 1873Assert.Same(fileStream, result.FileStream); 1902Assert.Same(fileStream, result.FileStream); 1926Assert.Same(fileStream, result.FileStream); 1954Assert.Same(fileStream, result.FileStream); 2222Assert.Same(Encoding.UTF8, MediaType.GetEncoding(actualContentResult.ContentType)); 2617Assert.Same(valueProvider, Assert.IsType<CompositeValueProvider>(context.ValueProvider)[0]); 2645Assert.Same(valueProvider, Assert.IsType<CompositeValueProvider>(context.ValueProvider)[0]); 2672Assert.Same(valueProvider, context.ValueProvider); 2728Assert.Same(valueProvider, Assert.IsType<CompositeValueProvider>(context.ValueProvider)[0]); 2761Assert.Same(valueProvider, context.ValueProvider); 2793Assert.Same( 2827Assert.Same(valueProvider.Object, context.ValueProvider); 2857Assert.Same( 2911Assert.Same(valueProvider, context.ValueProvider); 2941Assert.Same(valueProvider, Assert.IsType<CompositeValueProvider>(context.ValueProvider)[0]); 2969Assert.Same(valueProvider, Assert.IsType<CompositeValueProvider>(context.ValueProvider)[0]); 3004Assert.Same(serviceProvider, innerServiceProvider); 3024Assert.Same(request, innerRequest); 3044Assert.Same(response, innerResponse); 3060Assert.Same(routeData, innerRouteData);

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

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

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

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

39Assert.Same(controller, instance);

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

30Assert.Same(result, builder); 55Assert.Same(TestApplicationPartFactory.TestPart, part); 75Assert.Same(result, builder);

27Assert.Same(result, builder); 52Assert.Same(TestApplicationPartFactory.TestPart, part); 72Assert.Same(result, builder);

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

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

72f => Assert.Same(staticFilter1, f), 73f => Assert.Same(staticFilter2, f)); 84f => Assert.Same(staticFilter1, f), 85f => Assert.Same(staticFilter2, f)); 109f => Assert.Same(filter2, f), 110f => Assert.Same(filter3, f), 111f => Assert.Same(filter1, f)); 139f => Assert.Same(filter2, f), 140f => Assert.Same(filter3, f), 141f => Assert.Same(filter1, f)); 163Assert.Same(staticFilter, filters[1]); // Cached and the same statically created filter instance 170Assert.Same(currentFactoryCreatedFilter, cachedFactoryCreatedFilter); // Cached 171Assert.Same(staticFilter, filters[1]); // Cached 198Assert.Same(staticFilter, filters[1]); // Cached 238Assert.Same(staticFilter, filters[1]); // Cached and the same statically created filter instance 250Assert.Same(staticFilter, filters[1]); // Cached and the same statically created filter instance

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

71Assert.Same(pipeline1, pipeline2);

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

45Assert.Same(header, mediaType.MediaType.Buffer);

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

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

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

49Assert.Collection(matches, (a) => Assert.Same(actions[0], a)); 89Assert.Collection(matches, (a) => Assert.Same(actions[0], a)); 129Assert.Collection(matches, (e) => Assert.Same(actions[0], e.Metadata.GetMetadata<ActionDescriptor>())); 423Assert.Same(actions[0], action); 454Assert.Same(actions[0], action); 485Assert.Same(actions[0], action); 514Assert.Same(actions[0], action); 543Assert.Same(actions[0], action);

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

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

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

57Assert.Same(cacheEntry, cacheEntry2);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

72Assert.Same(valueProvider, result);

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

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

268Assert.Same(result, provider);

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

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

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

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); 267Assert.Same(metadata1, metadata2); 335Assert.Same(metadata1, metadata2); 418Assert.Same(metadata1, metadata2);

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

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

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

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

1170Assert.Same(original, outValue); 1283Assert.Same(value, result); 1306element => { Assert.Same(value[0], element); }, 1307element => { Assert.Same(value[1], element); }, 1308element => { Assert.Same(value[2], element); }); 1454Assert.Same(bindingContext.Model, result);

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

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

248Assert.Same(result, provider);

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

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

36Assert.Same(metadata.Properties["Age"], entry.Metadata); 42Assert.Same(metadata.Properties["Id"], entry.Metadata); 48Assert.Same(metadata.Properties["Name"], entry.Metadata); 76Assert.Same(metadata.Properties["Age"], entry.Metadata); 82Assert.Same(metadata.Properties["Id"], entry.Metadata); 88Assert.Same(metadata.Properties["Name"], entry.Metadata); 110Assert.Same(metadata.Properties["Age"], entry.Metadata); 116Assert.Same(metadata.Properties["Id"], entry.Metadata); 122Assert.Same(metadata.Properties["Name"], entry.Metadata); 145Assert.Same(metadata.Properties["Age"], entry.Metadata); 151Assert.Same(metadata.Properties["Id"], entry.Metadata); 157Assert.Same(metadata.Properties["Name"], entry.Metadata);

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); 140Assert.Same(metadata.ElementMetadata, e.Metadata); 146Assert.Same(metadata.ElementMetadata, e.Metadata); 170Assert.Same(metadata.ElementMetadata, e.Metadata); 176Assert.Same(metadata.ElementMetadata, e.Metadata);

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

32Assert.Same(validators1, validators2);

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

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

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

62Assert.Same(endpoints1, endpoints2);

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

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

95Assert.Same(actions[1], e.Metadata.GetMetadata<ActionDescriptor>()); 100Assert.Same(actions[1], e.Metadata.GetMetadata<ActionDescriptor>()); 122Assert.Same(actions[0], e.Metadata.GetMetadata<ActionDescriptor>()); 177Assert.Same(actions[1], e.Metadata.GetMetadata<ActionDescriptor>()); 183Assert.Same(actions[1], e.Metadata.GetMetadata<ActionDescriptor>()); 204Assert.Same(actions[0], e.Metadata.GetMetadata<ActionDescriptor>()); 264Assert.Same(actions[1], e.Metadata.GetMetadata<ActionDescriptor>()); 269Assert.Same(actions[1], e.Metadata.GetMetadata<ActionDescriptor>()); 291Assert.Same(actions[0], e.Metadata.GetMetadata<ActionDescriptor>()); 346Assert.Same(actions[1], e.Metadata.GetMetadata<ActionDescriptor>()); 352Assert.Same(actions[1], e.Metadata.GetMetadata<ActionDescriptor>()); 373Assert.Same(actions[0], e.Metadata.GetMetadata<ActionDescriptor>()); 440Assert.Same(actions[1], e.Metadata.GetMetadata<ActionDescriptor>()); 447Assert.Same(actions[1], e.Metadata.GetMetadata<ActionDescriptor>()); 472Assert.Same(actions[0], e.Metadata.GetMetadata<ActionDescriptor>());

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

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

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

26Assert.Same(expected, filter);

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

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

112Assert.Same(Exception, exception); 158Assert.Same(Exception, exception); 727Assert.Same(expected, thrown); 879Assert.Same(Result, context.Result); 921Assert.Same(Result, context.Result); 1021Assert.Same(exception, context.Exception); 1063Assert.Same(exception, context.Exception); 1107Assert.Same(exception, context.Exception); 1149Assert.Same(exception, context.Exception); 1229Assert.Same(Result, context.Result); 1266Assert.Same(expected, context.Result); 1305Assert.Same(expected, context.Result); 1333Assert.Same(Exception, context.Exception); 1334Assert.Same(Exception, context.ExceptionDispatchInfo.SourceException); 1372Assert.Same(expected, context.Exception); 1373Assert.Same(expected, context.ExceptionDispatchInfo.SourceException); 1392Assert.Same(Exception, context.Exception); 1393Assert.Same(Exception, context.ExceptionDispatchInfo.SourceException); 1441Assert.Same(expected, exception); 1442Assert.Same(expected, context.Exception); 1443Assert.Same(expected, context.ExceptionDispatchInfo.SourceException); 1477Assert.Same(expected, exception); 1478Assert.Same(expected, context.Exception); 1479Assert.Same(expected, context.ExceptionDispatchInfo.SourceException); 1513Assert.Same(expected, exception); 1514Assert.Same(expected, context.Exception); 1515Assert.Same(expected, context.ExceptionDispatchInfo.SourceException); 1569Assert.Same(expected.Object, context.Result); 1666Assert.Same(expected.Object, context.Result); 1737.Callback<ResultExecutingContext>(c => Assert.Same(Result, c.Result)) 1740.Callback<ResultExecutedContext>(c => Assert.Same(Result, c.Result)) 1769Assert.Same(Result, c.Result); 1840.Callback<ResultExecutingContext>(c => Assert.Same(Result, c.Result)) 1843.Callback<ResultExecutedContext>(c => Assert.Same(Result, c.Result)) 1872Assert.Same(Result, c.Result); 1937.Callback<ResultExecutingContext>(c => Assert.Same(Result, c.Result)) 1940.Callback<ResultExecutedContext>(c => Assert.Same(Result, c.Result)) 1969Assert.Same(Result, c.Result);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

34Assert.Same(result1, result2); 37Assert.Same(fileProvider.GetChangeToken(path), token); 53Assert.Same(result1, result2); 76token => Assert.Same(fileProvider.GetChangeToken(path), token), 77token => Assert.Same(fileProvider.GetChangeToken("/_ViewImports.cshtml"), token), 78token => Assert.Same(fileProvider.GetChangeToken("/file/_ViewImports.cshtml"), token), 79token => Assert.Same(fileProvider.GetChangeToken("/file/exists/_ViewImports.cshtml"), token)); 103Assert.Same(result1, result2); 157Assert.Same(expected2, result2); 183Assert.Same(expected2, result2); 203Assert.Same(precompiledView, result); 229Assert.Same(precompiledView, result); 249Assert.Same(precompiledView, result); 276Assert.Same(precompiledView.Item, result.Item); 284Assert.Same(precompiledView.Item, result.Item); 311Assert.Same(precompiledView, result); 319Assert.Same(precompiledView, result); 349Assert.Same(precompiledView.Item, result.Item); 354token => Assert.Same(fileProvider.GetChangeToken(path), token)); 384Assert.Same(expected, result); 411Assert.Same(precompiledView.Item, result.Item); 413Assert.Same(fileProvider.GetChangeToken(path), token); 441Assert.Same(precompiledView.Item, result.Item); 451Assert.Same(expected2, result); 478Assert.Same(precompiledView.Item, result.Item); 485Assert.Same(precompiledView.Item, result.Item); 515Assert.Same(expected1, result); 523Assert.Same(precompiledView.Item, result.Item); 555Assert.Same(precompiledView.Item, result.Item); 564Assert.Same(expected2, result); 642Assert.Same(result1, task1.Result); 643Assert.Same(result2, task2.Result); 686Assert.Same(result1, result2); 704Assert.Same(exception, actual); 711Assert.Same(exception, actual);

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

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

41Assert.Same(compiledView, result); 65Assert.Same(precompiledView, result); 83Assert.Same(compiledView, result); 105Assert.Same(compiledView, result); 115Assert.Same(hotReloaded, result);

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

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

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

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

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

158Assert.Same(page, view.RazorPage); 190Assert.Same(page, view1.RazorPage); 201Assert.Same(page, view2.RazorPage); 325Assert.Same(page, view.RazorPage); 356Assert.Same(page, view.RazorPage); 522Assert.Same(page, view.RazorPage); 558Assert.Same(areaPage, view1.RazorPage); 572Assert.Same(nonAreaPage, view2.RazorPage); 584Assert.Same(areaPage, view3.RazorPage); 586Assert.Same(nonAreaPage, view4.RazorPage); 622Assert.Same(areaPage1, view1.RazorPage); 637Assert.Same(areaPage2, view2.RazorPage); 649Assert.Same(areaPage1, view3.RazorPage); 651Assert.Same(areaPage2, view4.RazorPage); 844Assert.Same(page, view1.RazorPage); 857Assert.Same(page, view2.RazorPage); 881Assert.Same(page, view1.RazorPage); 894Assert.Same(page, view2.RazorPage); 932Assert.Same(page1, view1.RazorPage); 941Assert.Same(page2, view2.RazorPage); 1055Assert.Same(page, view.RazorPage); 1190Assert.Same(page, result.Page); 1249Assert.Same(page, result.Page); 1309Assert.Same(page.Object, result.Page); 1435Assert.Same(page, result.Page); 1463Assert.Same(page, result.Page); 1491Assert.Same(page, result.Page); 1516Assert.Same(pagePath, result); 1569Assert.Same(pagePath, result); 2003Assert.Same(page, view.RazorPage); 2021Assert.Same(hotReloadedPage, view.RazorPage);

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

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

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

457Assert.Same(typeof(EmptyPage).GetTypeInfo(), pageModel.HandlerType); 458Assert.Same(typeof(EmptyPage).GetTypeInfo(), pageModel.ModelType); 459Assert.Same(typeof(EmptyPage).GetTypeInfo(), pageModel.PageType); 478Assert.Same(typeof(EmptyPageModel).GetTypeInfo(), pageModel.DeclaredModelType); 479Assert.Same(typeof(EmptyPageModel).GetTypeInfo(), pageModel.ModelType); 480Assert.Same(typeof(EmptyPageModel).GetTypeInfo(), pageModel.HandlerType); 481Assert.Same(typeof(EmptyPageWithPageModel).GetTypeInfo(), pageModel.PageType); 591Assert.Same(typeof(ModelWithHandler).GetTypeInfo(), pageModel.HandlerType); 592Assert.Same(typeof(ModelWithHandler).GetTypeInfo(), pageModel.ModelType); 593Assert.Same(typeof(PageWithHandlerThatGetsIgnored).GetTypeInfo(), pageModel.PageType); 640Assert.Same(typeof(PageWithHandler).GetTypeInfo(), pageModel.HandlerType); 641Assert.Same(typeof(PocoModel).GetTypeInfo(), pageModel.ModelType); 642Assert.Same(typeof(PageWithHandler).GetTypeInfo(), pageModel.PageType); 785handler => Assert.Same(expected, handler.MethodInfo)); 815handler => Assert.Same(expected, handler.MethodInfo)); 843handler => Assert.Same(expected, handler.MethodInfo)); 875Assert.Same(typeInfo.GetMethod(nameof(PageModelWithHandlerNames.OnPutDeleteAsync)), handler.MethodInfo);

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

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

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

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

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

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

33Assert.Same(filter, feature.Value); 51Assert.Same(handler, filter.Subject);

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

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

51Assert.Same(descriptor1, actual); 99Assert.Same(descriptor3, actual); 194Assert.Same(descriptor1, actual); 230Assert.Same(descriptor, actual); 273Assert.Same(descriptor2, actual); 373Assert.Same(descriptor1, actual); 424Assert.Same(descriptor1, actual); 469Assert.Same(descriptor2, actual); 520Assert.Same(descriptor1, actual); 565Assert.Same(descriptor2, actual); 614Assert.Same(descriptor2, actual);

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

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

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

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

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

199Assert.Same(expected, actual);

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

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

112Assert.Same(valueProviderFactory1, pageContext.ValueProviderFactories[0]); 113Assert.Same(valueProviderFactory2, pageContext.ValueProviderFactories[1]); 146Assert.Same(valueProviderFactory2, pageContext.ValueProviderFactories[0]); 172Assert.Same(instance, c.HandlerInstance); 180Assert.Same(instance, c.Controller); 187Assert.Same(instance, c.Controller); 188Assert.Same(result, c.Result); 201Assert.Same(page, page.ViewContext.ViewData.Model); 204Assert.Same(page, pageResult.Page); 205Assert.Same(page, pageResult.Model); 206Assert.Same(page.ViewContext.ViewData, pageResult.ViewData); 228Assert.Same(instance, c.HandlerInstance); 236Assert.Same(instance, c.Controller); 243Assert.Same(instance, c.Controller); 244Assert.Same(result, c.Result); 260Assert.Same(page, pageResult.Page); 262Assert.Same(page.ViewContext.ViewData, pageResult.ViewData); 285Assert.Same(instance, c.HandlerInstance); 293Assert.Same(instance, c.Controller); 300Assert.Same(instance, c.Controller); 301Assert.Same(result, c.Result); 317Assert.Same(pageModel, pageModel.ViewData.Model); 321Assert.Same(pageModel, pageResult.Model); 322Assert.Same(pageModel.PageContext.ViewData, pageResult.ViewData); 371.Callback<PageHandlerExecutingContext>(c => Assert.Same(handler, c.HandlerMethod)) 375.Callback<PageHandlerExecutedContext>(c => Assert.Same(handler, c.HandlerMethod)) 381.Callback<PageHandlerSelectedContext>(c => Assert.Same(handler, c.HandlerMethod)) 385.Callback<PageHandlerExecutingContext>(c => Assert.Same(handler, c.HandlerMethod)) 389.Callback<PageHandlerExecutedContext>(c => Assert.Same(handler, c.HandlerMethod)) 428Assert.Same(handler, c.HandlerMethod); 436.Callback<PageHandlerSelectedContext>(c => Assert.Same(handler, c.HandlerMethod)) 443Assert.Same(handler, c.HandlerMethod); 517Assert.Same(Result, result); 547Assert.Same(Result, result); 579Assert.Same(expectedResult, pageResult); 613Assert.Same(expectedResult, pageResult); 648Assert.Same(expectedResult, pageResult); 682Assert.Same(expectedResult, pageResult); 717Assert.Same(expectedResult, pageResult); 751Assert.Same(expectedResult, pageResult); 787Assert.Same(expectedResult, pageResult); 822Assert.Same(expectedResult, pageResult); 885Assert.Same(context.Result, result.Object); 957Assert.Same(context.Result, result.Object); 1062Assert.Same(Exception, c.Exception); 1077Assert.Same(Exception, context.Exception); 1122Assert.Same(exception, context.Exception); 1167Assert.Same(exception, context.Exception); 1248Assert.Same(expected, context.Result); 1287Assert.Same(expected, context.Exception); 1288Assert.Same(expected, context.ExceptionDispatchInfo.SourceException); 1326Assert.Same(expected, context.Exception); 1327Assert.Same(expected, context.ExceptionDispatchInfo.SourceException); 1344Assert.Same(Exception, context.Exception);

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

55Assert.Same(simpleModel, instance);

45Assert.Same(url, result.Url); 62Assert.Same(url, result.Url); 79Assert.Same(url, result.Url); 96Assert.Same(url, result.Url); 143Assert.Same(url, result.Url); 160Assert.Same(url, result.Url); 177Assert.Same(url, result.Url); 194Assert.Same(url, result.Url); 875Assert.Same(routeName, resultTemporary.RouteName); 892Assert.Same(routeName, resultTemporary.RouteName); 909Assert.Same(routeName, resultPermanent.RouteName); 926Assert.Same(routeName, resultPermanent.RouteName); 1242Assert.Same(url, result.PageName); 1262Assert.Same(pageName, resultPermanent.PageName); 1283Assert.Same(routeName, resultPermanent.PageName); 1304Assert.Same(routeName, resultTemporary.RouteName); 1325Assert.Same(routeName, resultTemporary.RouteName); 1346Assert.Same(routeName, resultPermanent.RouteName); 1367Assert.Same(routeName, resultPermanent.RouteName); 1383Assert.Same(fileContents, result.FileContents); 1400Assert.Same(fileContents, result.FileContents); 1461Assert.Same(fileStream, result.FileStream); 1487Assert.Same(fileStream, result.FileStream); 1607Assert.Same(Encoding.UTF8, MediaType.GetEncoding(actualContentResult.ContentType)); 1743Assert.Same(pageContext, pageModel.PageContext); 1744Assert.Same(httpContext, pageModel.HttpContext); 1745Assert.Same(httpContext.Request, pageModel.Request); 1746Assert.Same(httpContext.Response, pageModel.Response); 1747Assert.Same(modelState, pageModel.ModelState); 1748Assert.Same(viewData, pageModel.ViewData); 1807Assert.Same(urlHelper, pageModel.Url); 2003Assert.Same(viewData, result.ViewData); 2025Assert.Same(viewData, result.ViewData); 2042Assert.Same(arguments, result.Arguments);

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

62Assert.Same(endpoints1, endpoints2);

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

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

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

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

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

42Assert.Same(content, page.Buffer[0].Value); 264Assert.Same(nested, buffer[0].Buffer[0].Value); 311Assert.Same(page, original[0]); 338Assert.Same(page, original[1]); 370Assert.Same(page, original[1]);

23Assert.Same(model, result); 39Assert.Same(func1, func2); 56Assert.Same(differentModel, result); 88Assert.Same(differentModel, result); 105Assert.Same(differentModel, result1); 112Assert.Same(differentModel, result2); 128Assert.Same(differentModel, result1); 136Assert.Same(differentModel, result2); 184Assert.Same(func1, func2); 218Assert.Same(func1, func2); 298Assert.Same(func1, func2); 541Assert.Same(func1, func2); 557Assert.Same(func1, func2); 833Assert.Same(differentModel, result); 850Assert.Same(differentModel, result);

49Assert.Same(replacementViewData, controller.ViewData); 79Assert.Same(controller.ViewData, actualViewResult.ViewData); 80Assert.Same(controller.TempData, actualViewResult.TempData); 103Assert.Same(controller.ViewData, actualViewResult.ViewData); 104Assert.Same(controller.TempData, actualViewResult.TempData); 105Assert.Same(model, actualViewResult.ViewData.Model); 124Assert.Same(controller.ViewData, actualViewResult.ViewData); 125Assert.Same(controller.TempData, actualViewResult.TempData); 146Assert.Same(controller.ViewData, actualViewResult.ViewData); 147Assert.Same(controller.TempData, actualViewResult.TempData); 148Assert.Same(model, actualViewResult.ViewData.Model); 168Assert.Same(controller.ViewData, actualViewResult.ViewData); 169Assert.Same(controller.TempData, actualViewResult.TempData); 170Assert.Same(model, actualViewResult.ViewData.Model); 190Assert.Same(controller.ViewData, actualViewResult.ViewData); 191Assert.Same(controller.TempData, actualViewResult.TempData); 214Assert.Same(controller.ViewData, actualViewResult.ViewData); 215Assert.Same(controller.TempData, actualViewResult.TempData); 216Assert.Same(model, actualViewResult.ViewData.Model); 237Assert.Same(controller.ViewData, actualViewResult.ViewData); 238Assert.Same(controller.TempData, actualViewResult.TempData); 239Assert.Same(model, actualViewResult.ViewData.Model); 259Assert.Same(controller.ViewData, actualViewResult.ViewData); 260Assert.Same(controller.TempData, actualViewResult.TempData); 261Assert.Same(model, actualViewResult.ViewData.Model); 281Assert.Same(controller.ViewData, actualViewResult.ViewData); 282Assert.Same(controller.TempData, actualViewResult.TempData); 283Assert.Same(model, actualViewResult.ViewData.Model); 303Assert.Same(controller.ViewData, actualViewResult.ViewData); 304Assert.Same(controller.TempData, actualViewResult.TempData); 320Assert.Same(data, actualJsonResult.Value); 336Assert.Same(data, actualJsonResult.Value); 337Assert.Same(serializerSettings, actualJsonResult.SerializerSettings);

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

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

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

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

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

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

29Assert.Same(filter, feature.Value); 46Assert.Same(controller, filter.Subject);

81Assert.Same(expected, property.PropertyInfo); 102Assert.Same(expected, property.PropertyInfo);

61Assert.Same(expected, property.PropertyInfo);

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

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

92Assert.Same(exception, modelError.Exception); 112Assert.Same(exception, modelError.Exception); 130Assert.Same(exception, modelError.Exception); 150Assert.Same(exception, modelError.Exception); 168Assert.Same(exception, modelError.Exception); 188Assert.Same(exception, modelError.Exception); 207Assert.Same(exception, modelError.Exception); 228Assert.Same(exception, modelError.Exception); 306Assert.Same(expected, modelState.Value); 326Assert.Same(expected, modelState.Value); 345Assert.Same(expected, modelState.Value); 368Assert.Same(expected, modelState.Value); 390Assert.Same(expected, modelState.Value);

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

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

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

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

38Assert.Same(replacementViewData, context.ViewData); 64Assert.Same(originalContext.ActionDescriptor, context.ActionDescriptor); 66Assert.Same(originalContext.ExecutingFilePath, context.ExecutingFilePath); 67Assert.Same(originalContext.FormContext, context.FormContext); 69Assert.Same(originalContext.HttpContext, context.HttpContext); 70Assert.Same(originalContext.ModelState, context.ModelState); 71Assert.Same(originalContext.RouteData, context.RouteData); 72Assert.Same(originalContext.TempData, context.TempData); 73Assert.Same(originalContext.ValidationMessageElement, context.ValidationMessageElement); 74Assert.Same(originalContext.ValidationSummaryMessageElement, context.ValidationSummaryMessageElement); 76Assert.Same(view, context.View); 77Assert.Same(viewData, context.ViewData); 78Assert.Same(writer, context.Writer);

70Assert.Same(Dictionary, result);

43Assert.Same(tempData1, tempData2);

140Assert.Same(item, value);

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

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

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

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

23Assert.Same(typeof(ViewComponentContainer.SuffixViewComponent).GetTypeInfo(), result.TypeInfo); 36Assert.Same(typeof(ViewComponentContainer.SuffixViewComponent).GetTypeInfo(), result.TypeInfo); 49Assert.Same(typeof(ViewComponentContainer.WithoutSuffix).GetTypeInfo(), result.TypeInfo); 62Assert.Same(typeof(ViewComponentContainer.WithoutSuffix).GetTypeInfo(), result.TypeInfo); 75Assert.Same(typeof(ViewComponentContainer.ByAttribute).GetTypeInfo(), result.TypeInfo); 88Assert.Same(typeof(ViewComponentContainer.ByNamingConventionViewComponent).GetTypeInfo(), result.TypeInfo); 141Assert.Same(typeof(ViewComponentContainer.Ambiguous1).GetTypeInfo(), result.TypeInfo); 154Assert.Same(typeof(ViewComponentContainer.DerivedAmbiguousWithOverriddenName).GetTypeInfo(), result.TypeInfo); 169Assert.Same(typeof(ViewComponentContainer.FullNameInAttribute).GetTypeInfo(), result.TypeInfo);

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

294Assert.Same(expected, actual);

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

22Assert.Same(modelState, viewData.ModelState); 51Assert.Same(model, viewData1.Model); 54Assert.Same(source.ModelMetadata, viewData1.ModelMetadata); 63Assert.Same(model, viewData2.Model); 66Assert.Same(source.ModelMetadata, viewData2.ModelMetadata); 93Assert.Same(source.ModelMetadata, viewData1.ModelMetadata); 105Assert.Same(source.ModelMetadata, viewData2.ModelMetadata); 126Assert.Same(model, viewData.Model); 129Assert.Same(source.ModelMetadata, viewData.ModelMetadata); 147Assert.Same(model, viewData.Model); 150Assert.Same(source.ModelMetadata, viewData.ModelMetadata); 279Assert.Same(source.ModelMetadata, viewData.ModelMetadata); 319Assert.Same(source.ModelExplorer, viewData.ModelExplorer); 320Assert.Same(source.ModelMetadata, viewData.ModelMetadata);

40Assert.Same(modelState, viewData.ModelState); 181Assert.Same(model, vdd.Model); 205Assert.Same(model, viewData.Model); 208Assert.Same(source.ModelMetadata, viewData.ModelMetadata); 249Assert.Same(source.ModelMetadata, viewData.ModelMetadata); 263Assert.Same(source.ModelMetadata, viewData.ModelMetadata); 314Assert.Same(source.ModelMetadata, viewData.ModelMetadata); 338Assert.Same(originalMetadata, viewData.ModelMetadata); 387Assert.Same(metadata, viewData.ModelMetadata); 430Assert.Same(originalMetadata, viewData.ModelMetadata); 455Assert.Same(originalMetadata, viewData.ModelMetadata); 456Assert.Same(originalExplorer, viewData.ModelExplorer); 665Assert.Same(model, result);

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

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

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

42Assert.Same(transformer, insertedTransformer); 99Assert.Same(transformer, insertedTransformer); 156Assert.Same(transformer, insertedTransformer);

41Assert.Same(Stream.Null, Get<Stream>(env, "owin.RequestBody")); 51Assert.Same(Stream.Null, Get<Stream>(env, "owin.ResponseBody")); 86Assert.Same(Stream.Null, context.Request.Body); 94Assert.Same(Stream.Null, context.Response.Body);

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

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

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

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

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

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

571Assert.Same(cachedVaryByRules, context.CachedVaryByRules);

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

198Assert.Same(serviceProvider, endpointBuilderServiceProvider);

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

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

36Assert.Same(item, Assert.Single(tree.Matches)); 77Assert.Same(item, Assert.Single(addUser.Value.Matches)); 114Assert.Same(item1, Assert.Single(store.Value.Matches)); 125Assert.Same(item2, Assert.Single(store.Value.Matches)); 158Assert.Same(item3, Assert.Single(buy.Matches));

578Assert.Same(expected, actual);

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

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

35Assert.Same(endpoints[i], state.Endpoint); 71Assert.Same(endpoint, state.Endpoint); 72Assert.Same(values, state.Values); 139Assert.Same(endpoints[i], state.Endpoint); 178Assert.Same(replacements[0], candidateSet[0].Endpoint); 180Assert.Same(replacements[2], candidateSet[1].Endpoint); 182Assert.Same(replacements[1], candidateSet[2].Endpoint); 188Assert.Same(endpoints[i - 2], state.Endpoint); 231Assert.Same(endpoints[i], state.Endpoint); 235Assert.Same(replacements[0], candidateSet[5].Endpoint); 237Assert.Same(replacements[2], candidateSet[6].Endpoint); 239Assert.Same(replacements[1], candidateSet[7].Endpoint); 245Assert.Same(endpoints[i - 2], state.Endpoint); 288Assert.Same(endpoints[i], state.Endpoint); 292Assert.Same(replacements[0], candidateSet[9].Endpoint); 294Assert.Same(replacements[2], candidateSet[10].Endpoint); 296Assert.Same(replacements[1], candidateSet[11].Endpoint); 360Assert.Same(endpoints[i], state.Endpoint);

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

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

30Assert.Same(endpoint, Assert.Single(root.Matches)); 69Assert.Same(endpoint, Assert.Single(c.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); 195Assert.Same(endpoint1, Assert.Single(c1.Matches)); 207Assert.Same(endpoint2, Assert.Single(c2.Matches)); 247Assert.Same(endpoint1, Assert.Single(c1.Matches)); 259Assert.Same(endpoint2, Assert.Single(c2.Matches)); 302e => Assert.Same(endpoint1, e), 303e => Assert.Same(endpoint2, e)); 315Assert.Same(endpoint2, Assert.Single(c2.Matches)); 356e => Assert.Same(endpoint1, e), 357e => Assert.Same(endpoint2, e)); 385Assert.Same(endpoint2, Assert.Single(a.Matches)); 391Assert.Same(endpoint2, Assert.Single(a.Matches)); 400e => Assert.Same(endpoint1, e), 401e => Assert.Same(endpoint2, e)); 406Assert.Same(endpoint2, Assert.Single(catchAll.Matches)); 407Assert.Same(catchAll, catchAll.Parameters); 408Assert.Same(catchAll, catchAll.CatchAll); 434Assert.Same(endpoint2, Assert.Single(a.Matches)); 438Assert.Same(endpoint2, Assert.Single(a.Matches)); 447e => Assert.Same(endpoint1, e), 448e => Assert.Same(endpoint2, e)); 453Assert.Same(endpoint2, Assert.Single(catchAll.Matches)); 454Assert.Same(catchAll, catchAll.Parameters); 455Assert.Same(catchAll, catchAll.CatchAll); 485Assert.Same(endpoint1, Assert.Single(cNode.Matches)); 498Assert.Same(endpoint2, Assert.Single(paramCNode.Matches)); 532Assert.Same(endpoint1, Assert.Single(cNode.Matches)); 545Assert.Same(endpoint2, Assert.Single(paramCNode.Matches)); 577Assert.Same(endpoint1, Assert.Single(cNode.Matches)); 590Assert.Same(endpoint2, Assert.Single(paramBCNode.Matches)); 605Assert.Same(endpoint2, Assert.Single(paramCNode.Matches)); 640Assert.Same(endpoint3, Assert.Single(cNode.Matches)); 668Assert.Same(endpoint2, Assert.Single(paramCNode.Matches)); 700Assert.Same(endpoint1, Assert.Single(cNode.Matches)); 713Assert.Same(endpoint2, Assert.Single(paramCNode.Matches)); 745Assert.Same(endpoint1, Assert.Single(cNode.Matches)); 758Assert.Same(endpoint2, Assert.Single(paramBCNode.Matches)); 773Assert.Same(endpoint2, Assert.Single(paramCNode.Matches)); 805Assert.Same(endpoint1, Assert.Single(cNode.Matches)); 818Assert.Same(endpoint2, Assert.Single(paramCNode.Matches)); 850Assert.Same(endpoint1, Assert.Single(cNode.Matches)); 863Assert.Same(endpoint2, Assert.Single(paramBCNode.Matches)); 878Assert.Same(endpoint2, Assert.Single(paramCNode.Matches)); 910Assert.Same(endpoint1, Assert.Single(cNode.Matches)); 923Assert.Same(endpoint2, Assert.Single(paramBCNode.Matches)); 938Assert.Same(endpoint2, Assert.Single(paramCNode.Matches)); 975Assert.Same(endpoint1, Assert.Single(cNode.Matches)); 990Assert.Same(endpoint2, Assert.Single(paramCNode.Matches)); 1025Assert.Same(endpoint3, Assert.Single(cNode.Matches)); 1053Assert.Same(endpoint2, Assert.Single(paramCNode.Matches)); 2416Assert.Same(endpoint2, Assert.Single(a.Matches)); 2422e => Assert.Same(endpoint1, e), 2423e => Assert.Same(endpoint2, e)); 2429Assert.Same(endpoint2, Assert.Single(catchAll.Matches)); 2431Assert.Same(catchAll, catchAll.Parameters); 2432Assert.Same(catchAll, catchAll.CatchAll); 2459Assert.Same(endpoint1, Assert.Single(a.Matches)); 2465e => Assert.Same(endpoint1, e), 2466e => Assert.Same(endpoint2, e)); 2472Assert.Same(endpoint1, Assert.Single(catchAll.Matches)); 2474Assert.Same(catchAll, catchAll.Parameters); 2475Assert.Same(catchAll, catchAll.CatchAll); 2501Assert.Same(endpoint2, Assert.Single(a1.Matches)); 2507e => Assert.Same(endpoint1, e), 2508e => Assert.Same(endpoint2, e)); 2514Assert.Same(endpoint2, Assert.Single(catchAll1.Matches)); 2516Assert.Same(catchAll1, catchAll1.Parameters); 2517Assert.Same(catchAll1, catchAll1.CatchAll); 2526e => Assert.Same(endpoint1, e)); 2555Assert.Same(endpoint1, Assert.Single(a1.Matches)); 2561e => Assert.Same(endpoint1, e), 2562e => Assert.Same(endpoint2, e)); 2568Assert.Same(endpoint1, Assert.Single(catchAll1.Matches)); 2570Assert.Same(catchAll1, catchAll1.Parameters); 2571Assert.Same(catchAll1, catchAll1.CatchAll); 2580e => Assert.Same(endpoint2, e)); 2605Assert.Same(endpoint1, Assert.Single(a1.Matches)); 2609Assert.Same(endpoint2, Assert.Single(b1.Matches)); 2621e => Assert.Same(endpoint2, e)); 2661Assert.Same(endpoint1, Assert.Single(test2_true.Matches)); 2707Assert.Same(endpoint1, Assert.Single(test2_true.Matches)); 2720Assert.Same(endpoint2, Assert.Single(test2_true.Matches)); 2725Assert.Same(endpoint3, Assert.Single(test2_false.Matches)); 2968Assert.Same(endpoint, Assert.Single(index.Matches)); 2988Assert.Same(endpoint, Assert.Single(root.Matches)); 2995Assert.Same(endpoint, Assert.Single(home.Matches)); 3002Assert.Same(endpoint, Assert.Single(index.Matches)); 3029Assert.Same(endpoint, Assert.Single(login.Matches)); 3036Assert.Same(endpoint, Assert.Single(index.Matches)); 3068Assert.Same(endpoint1, Assert.Single(root.Matches)); 3075Assert.Same(endpoint1, Assert.Single(home.Matches)); 3082Assert.Same(endpoint1, Assert.Single(homeIndex.Matches)); 3086Assert.Same(endpoint1, Assert.Single(homeIndex.Parameters.Matches)); 3090Assert.Same(endpoint2, Assert.Single(login.Matches)); 3097Assert.Same(endpoint2, Assert.Single(loginIndex.Matches)); 3101Assert.Same(endpoint2, Assert.Single(loginIndex.Parameters.Matches)); 3105Assert.Same(endpoint3, Assert.Single(loginChangePassword.Matches)); 3109Assert.Same(endpoint3, Assert.Single(loginChangePassword.Parameters.Matches)); 3128Assert.Same(endpoint, Assert.Single(root.Matches)); 3135Assert.Same(endpoint, Assert.Single(home.Matches)); 3142Assert.Same(endpoint, Assert.Single(index.Matches)); 3175Assert.Same(endpoint, Assert.Single(conventionalTransformer.Matches)); 3181Assert.Same(endpoint, Assert.Single(index.Matches)); 3185Assert.Same(endpoint, Assert.Single(index.Parameters.Matches)); 3396Assert.Same(constraint1.Value, constraint2.Value); 3419Assert.Same(constraint1.Value, constraint2.Value);

155Assert.Same(endpoint, httpContext.GetEndpoint()); 220Assert.Same(endpoint, httpContext.GetEndpoint()); 269Assert.Same(endpoint, httpContext.GetEndpoint()); 304Assert.Same(endpoint1, httpContext.GetEndpoint()); 312Assert.Same(endpoint2, httpContext.GetEndpoint()); 338Assert.Same(endpoint, httpContext.GetEndpoint()); 378Assert.Same(endpoint2, candidate.Endpoint); 431Assert.Same(endpoint1, candidate.Endpoint); 483Assert.Same(endpoint2, candidate.Endpoint); 536Assert.Same(endpoint1, candidate.Endpoint); 598Assert.Same(endpoint, httpContext.GetEndpoint()); 653Assert.Same(endpoint1, cs[0].Endpoint); 658Assert.Same(endpoint2, cs[1].Endpoint); 699Assert.Same(endpoint1, cs[0].Endpoint); 704Assert.Same(endpoint2, cs[1].Endpoint); 746Assert.Same(endpoint1, cs[0].Endpoint); 751Assert.Same(endpoint2, cs[1].Endpoint); 909Assert.Same(endpointDataSource.Endpoints[0], httpContext.GetEndpoint()); 978Assert.Same(dataSource.Endpoints[2], httpContext.GetEndpoint()); 1013Assert.Same(dataSource.Endpoints[1], httpContext.GetEndpoint()); 1062Assert.Same(dataSource.Endpoints[0], httpContext.GetEndpoint());

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

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

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

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

425Assert.Same(paramPartB, actual.Parameters[0]); 426Assert.Same(paramPartC, actual.Parameters[1]); 427Assert.Same(paramPartD, actual.Parameters[2]); 454Assert.Same(paramPartB, actual.Parameters[0]); 455Assert.Same(paramPartC, actual.Parameters[1]); 456Assert.Same(paramPartD, actual.Parameters[2]); 494Assert.Same(paramPartD, actual.Parameters[2]); 534Assert.Same(paramPartD, actual.Parameters[2]); 691Assert.Same(paramPartB, actual.Parts[0]); 692Assert.Same(paramPartC, actual.Parts[1]); 693Assert.Same(paramPartD, actual.Parts[2]); 712Assert.Same(paramPartB, actual.Parts[0]); 713Assert.Same(paramPartC, actual.Parts[1]); 714Assert.Same(paramPartD, actual.Parts[2]);

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

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

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

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

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

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

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

99Assert.Same(originalRouteDataValues, context.RouteData.Values); 103Assert.Same(originalDataTokens, context.RouteData.DataTokens); 497Assert.Same(target, context.RouteData.Routers[0]); 611Assert.Same(route, pathData.Router); 643Assert.Same(route, pathData.Router); 676Assert.Same(route, pathData.Router); 694Assert.Same(route, pathData.Router); 712Assert.Same(route, pathData.Router); 730Assert.Same(route, pathData.Router); 748Assert.Same(route, pathData.Router); 782Assert.Same(target.Object, pathData.Router); 823Assert.Same(route, pathData.Router); 847Assert.Same(route, pathData.Router); 863Assert.Same(route, pathData.Router); 904Assert.Same(route, pathData.Router); 945Assert.Same(route, pathData.Router); 979Assert.Same(route, pathData.Router); 1010Assert.Same(route, pathData.Router); 1041Assert.Same(route, pathData.Router); 1071Assert.Same(route, pathData.Router); 1102Assert.Same(route, pathData.Router); 1121Assert.Same(route, pathData.Router); 1153Assert.Same(route, pathData.Router); 1170Assert.Same(route, pathData.Router); 1202Assert.Same(route, pathData.Router); 1225Assert.Same(route, pathData.Router); 1247Assert.Same(route, pathData.Router); 1269Assert.Same(route, pathData.Router); 1291Assert.Same(route, pathData.Router); 1313Assert.Same(route, pathData.Router); 1335Assert.Same(route, pathData.Router); 1357Assert.Same(route, pathData.Router); 1379Assert.Same(route, pathData.Router); 1401Assert.Same(route, pathData.Router); 1425Assert.Same(route, pathData.Router); 1449Assert.Same(route, pathData.Router); 1473Assert.Same(route, pathData.Router); 1497Assert.Same(route, pathData.Router);

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); 355Assert.Same(endpoint, matchWithRequiredValue.Entry.Data); 356Assert.Same(endpoint, namedMatch.Entry.Data); 377Assert.Same(endpoint, namedMatch.Entry.Data); 412Assert.Same(endpoint, Assert.Single(allMatches).Entry.Data);

29Assert.Same(entry, Assert.Single(matches).Match); 49Assert.Same(entry, Assert.Single(matches).Match); 69Assert.Same(entry, Assert.Single(matches).Match); 90Assert.Same(entry, match.Match); 114Assert.Same(entry, match.Match); 138Assert.Same(entry, match.Match); 206Assert.Same(entry1, Assert.Single(matches).Match); 363m => { Assert.Same(entry2, m); }); 390m => { Assert.Same(entry2, m); }, 391m => { Assert.Same(entry1, m); }); 418m => { Assert.Same(entry2, m); }, 419m => { Assert.Same(entry1, m); }); 446m => { Assert.Same(entry2, m); }); 473m => { Assert.Same(entry2, m); }, 474m => { Assert.Same(entry1, m); }); 501m => { Assert.Same(entry2, m); }, 502m => { Assert.Same(entry1, m); }); 529m => { Assert.Same(entry1, m); }); 556m => { Assert.Same(entry1, m); }); 633m => { Assert.Same(entry2, m); }); 660m => { Assert.Same(entry2, m); });

821Assert.Same(route, result.Router); 844Assert.Same(route, result.Router); 876Assert.Same(route, result.Router); 908Assert.Same(route, result.Router); 943Assert.Same(route, result.Router); 989Assert.Same(route, result.Router); 1026Assert.Same(route, result.Router); 1056Assert.Same(route, result.Router); 1086Assert.Same(route, result.Router); 1144Assert.Same(route, result.Router); 1230Assert.Same(route, result.Router); 1250Assert.Same(route, pathData.Router); 1270Assert.Same(route, pathData.Router); 1307Assert.Same(route, pathData.Router); 1327Assert.Same(route, pathData.Router); 1347Assert.Same(route, pathData.Router); 1372Assert.Same(route, pathData.Router); 1392Assert.Same(route, pathData.Router); 1413Assert.Same(route, pathData.Router); 1451Assert.Same(route, pathData.Router); 1471Assert.Same(route, pathData.Router); 1493Assert.Same(route, pathData.Router); 1518Assert.Same(route, pathData.Router); 1543Assert.Same(route, pathData.Router); 1570Assert.Same(route, pathData.Router); 1597Assert.Same(route, pathData.Router); 1691Assert.Same(route, pathData.Router); 1914Assert.Same(route, pathData.Router); 1936Assert.Same(route, pathData.Router); 1958Assert.Same(route, pathData.Router); 1980Assert.Same(route, pathData.Router);

36Assert.Same(server, delegationFeature);

86Assert.Same(customHeaders, requestInfo.Headers);

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

287Assert.Same(state, httpContext);

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

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,

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

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

170Assert.Same(_serviceContext.ServerOptions.Limits.MinRequestBodyDataRate, _http1Connection.MinRequestBodyDataRate); 180Assert.Same(_serviceContext.ServerOptions.Limits.MinResponseDataRate, _http1Connection.MinResponseDataRate); 334Assert.Same(minDataRate, _http1Connection.MinRequestBodyDataRate); 343Assert.Same(minDataRate, _http1Connection.MinResponseDataRate); 357Assert.Same(originalRequestHeaders, _http1Connection.RequestHeaders); 371Assert.Same(originalResponseHeaders, _http1Connection.ResponseHeaders); 390Assert.Same(originalRequestBody, _http1Connection.RequestBody); 391Assert.Same(originalResponseBody, _http1Connection.ResponseBody); 915Assert.Same(newRequestHeaders, _http1Connection.RequestHeaders); 919Assert.Same(newRequestHeaders, _http1Connection.RequestHeaders); 924Assert.Same(newRequestHeaders, _http1Connection.RequestHeaders);

69Assert.Same(_collection[type], feature.Value); 182Assert.Same(_collection.Get<IHttpRequestFeature>(), _collection[typeof(IHttpRequestFeature)]); 183Assert.Same(_collection.Get<IHttpRequestBodyDetectionFeature>(), _collection[typeof(IHttpRequestBodyDetectionFeature)]); 184Assert.Same(_collection.Get<IHttpResponseFeature>(), _collection[typeof(IHttpResponseFeature)]); 185Assert.Same(_collection.Get<IHttpResponseBodyFeature>(), _collection[typeof(IHttpResponseBodyFeature)]); 186Assert.Same(_collection.Get<IRequestBodyPipeFeature>(), _collection[typeof(IRequestBodyPipeFeature)]); 187Assert.Same(_collection.Get<IHttpRequestIdentifierFeature>(), _collection[typeof(IHttpRequestIdentifierFeature)]); 188Assert.Same(_collection.Get<IHttpRequestLifetimeFeature>(), _collection[typeof(IHttpRequestLifetimeFeature)]); 189Assert.Same(_collection.Get<IHttpConnectionFeature>(), _collection[typeof(IHttpConnectionFeature)]); 190Assert.Same(_collection.Get<IHttpMaxRequestBodySizeFeature>(), _collection[typeof(IHttpMaxRequestBodySizeFeature)]); 191Assert.Same(_collection.Get<IHttpMinRequestBodyDataRateFeature>(), _collection[typeof(IHttpMinRequestBodyDataRateFeature)]); 192Assert.Same(_collection.Get<IHttpMinResponseDataRateFeature>(), _collection[typeof(IHttpMinResponseDataRateFeature)]); 193Assert.Same(_collection.Get<IHttpBodyControlFeature>(), _collection[typeof(IHttpBodyControlFeature)]); 232Assert.Same(featureLookup, featureIter.Value); 233Assert.Same(featureLookup, _collection);

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

42Assert.Same(error, exception);

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

134Assert.Same(knownString1, knownString2);

447Assert.Same(customEndpoint, transportEndPoint.BoundEndPoint); 448Assert.Same(customEndpoint, multiplexedTransportEndPoint.BoundEndPoint); 648Assert.Same(unbindException, await Assert.ThrowsAsync<InvalidOperationException>(() => stopTask1.TimeoutAfter(timeout))); 649Assert.Same(unbindException, await Assert.ThrowsAsync<InvalidOperationException>(() => stopTask2.TimeoutAfter(timeout))); 650Assert.Same(unbindException, await Assert.ThrowsAsync<InvalidOperationException>(() => stopTask3.TimeoutAfter(timeout)));

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

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

37Assert.Same(bytes, bytesCached);

408Assert.Same(options1, options2); 444Assert.Same(lastSeenSslOptions, options1); 447Assert.Same(lastSeenSslOptions, options2); 487Assert.Same(selectorCertificate, selectorOptions1.ServerCertificate); 490Assert.Same(selectorCertificate, selectorOptions2.ServerCertificate); 502Assert.Same(configOptions1, configOptions2); 546Assert.Same(fallbackOptions.ServerCertificate, options.ServerCertificate); 574Assert.Same(selectorCertificate, options.ServerCertificate); 884Assert.Same(options.CipherSuitesPolicy, clonedOptions.CipherSuitesPolicy); 896Assert.Same(options.RemoteCertificateValidationCallback, clonedOptions.RemoteCertificateValidationCallback); 900Assert.Same(options.ServerCertificate, clonedOptions.ServerCertificate); 903Assert.Same(options.ServerCertificateContext, clonedOptions.ServerCertificateContext); 906Assert.Same(options.ServerCertificateSelectionCallback, clonedOptions.ServerCertificateSelectionCallback); 909Assert.Same(options.CertificateChainPolicy, clonedOptions.CertificateChainPolicy);

77Assert.Same(path, Http1Connection.Path); 78Assert.Same(query, Http1Connection.QueryString); 130Assert.Same(rawTarget, Http1Connection.RawTarget); 132Assert.Same(path, Http1Connection.Path); 133Assert.Same(query, Http1Connection.QueryString); 225Assert.Same(prevRequestUrl, Http1Connection.RawTarget); 226Assert.Same(prevPath, Http1Connection.Path); 227Assert.Same(prevQuery, Http1Connection.QueryString); 318Assert.Same(prevRequestUrl, Http1Connection.RawTarget); 319Assert.Same(prevPath, Http1Connection.Path); 320Assert.Same(prevQuery, Http1Connection.QueryString); 392Assert.Same(rawTarget, Http1Connection.RawTarget); 393Assert.Same(path, Http1Connection.Path); 394Assert.Same(query, Http1Connection.QueryString); 398Assert.Same(prevRequestUrl, Http1Connection.RawTarget); 399Assert.Same(prevPath, Http1Connection.Path); 400Assert.Same(prevQuery, Http1Connection.QueryString); 475Assert.Same(path, Http1Connection.Path); 476Assert.Same(query, Http1Connection.QueryString); 480Assert.Same(prevRequestUrl, Http1Connection.RawTarget); 481Assert.Same(prevPath, Http1Connection.Path); 482Assert.Same(prevQuery, Http1Connection.QueryString); 507Assert.Same(path, Http1Connection.Path); 508Assert.Same(query, Http1Connection.QueryString);

1525Assert.Same(endpointsToStart[0], serverOptions.ConfigurationBackedListenOptions[1]); 1526Assert.Same(endpointsToStart[1], serverOptions.ConfigurationBackedListenOptions[2]);

182Assert.Same(memoryPoolFactory, host.Services.GetRequiredService<IOptions<SocketTransportOptions>>().Value.MemoryPoolFactory); 199Assert.Same(memoryPoolFactory, host.Services.GetRequiredService<IOptions<SocketTransportOptions>>().Value.MemoryPoolFactory); 219Assert.Same(memoryPoolFactory, host.Services.GetRequiredService<IOptions<SocketTransportOptions>>().Value.MemoryPoolFactory); 240Assert.Same(memoryPoolFactory, host.Services.GetRequiredService<IOptions<NamedPipeTransportOptions>>().Value.MemoryPoolFactory); 257Assert.Same(memoryPoolFactory, host.Services.GetRequiredService<IOptions<NamedPipeTransportOptions>>().Value.MemoryPoolFactory); 278Assert.Same(memoryPoolFactory, host.Services.GetRequiredService<IOptions<NamedPipeTransportOptions>>().Value.MemoryPoolFactory);

527Assert.Same(stream1, pooledStream); 539Assert.Same(stream1, pooledStream); 542Assert.Same(stream1, stream2); 732Assert.Same(quicStreamContext1, quicStreamContext2);

244Assert.Same(stream1, stream2);

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

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

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

173Assert.Same(typeof(TestObject), executor.AsyncResultType); 189Assert.Same(typeof(int), executor.AsyncResultType); 204Assert.Same(typeof(TestObject), executor.AsyncResultType); 221Assert.Same(typeof(int), executor.AsyncResultType); 243Assert.Same(typeof(void), executor.AsyncResultType); 258Assert.Same(typeof(string), executor.AsyncResultType); 273Assert.Same(typeof(string), executor.AsyncResultType); 288Assert.Same(typeof(int), executor.AsyncResultType); 303Assert.Same(typeof(string), executor.AsyncResultType); 318Assert.Same(typeof(int), executor.AsyncResultType); 334Assert.Same(typeof(string), executor.AsyncResultType); 352Assert.Same(typeof(string), executor.AsyncResultType); 370Assert.Same(typeof(string), executor.AsyncResultType); 388Assert.Same(typeof(string), executor.AsyncResultType); 403Assert.Same(typeof(string), executor.AsyncResultType);

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

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

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

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

64Assert.Same(exception, await closedErrorTcs.Task.DefaultTimeout()); 153Assert.Same(originalConnectionId, hubConnection.ConnectionId); 158Assert.Same(firstException, await reconnectingErrorTcs.Task.DefaultTimeout()); 160Assert.Same(firstException, retryContexts[0].RetryReason); 167Assert.Same(reconnectedConnectionId, await reconnectedConnectionIdTcs.Task.DefaultTimeout()); 170Assert.Same(reconnectException, retryContexts[1].RetryReason); 255Assert.Same(firstException, await reconnectingErrorTcs.Task.DefaultTimeout()); 257Assert.Same(firstException, retryContexts[0].RetryReason); 268Assert.Same(reconnectException, retryContexts[1].RetryReason); 350Assert.Same(firstException, await reconnectingErrorTcs.Task.DefaultTimeout()); 432Assert.Same(firstException, await reconnectingErrorTcs.Task.DefaultTimeout()); 434Assert.Same(firstException, retryContexts[0].RetryReason); 450Assert.Same(secondException, await reconnectingErrorTcs.Task.DefaultTimeout()); 452Assert.Same(secondException, retryContexts[1].RetryReason); 719Assert.Same(firstException, await Assert.ThrowsAsync<Exception>(() => startTask).DefaultTimeout()); 799Assert.Same(firstException, await reconnectingErrorTcs.Task.DefaultTimeout()); 801Assert.Same(firstException, retryContexts[0].RetryReason); 811Assert.Same(secondException, retryContexts[1].RetryReason); 906Assert.Same(firstException, await reconnectingErrorTcs.Task.DefaultTimeout()); 908Assert.Same(firstException, retryContexts[0].RetryReason); 1026Assert.Same(firstException, await reconnectingErrorTcs.Task.DefaultTimeout()); 1028Assert.Same(firstException, retryContexts[0].RetryReason); 1103Assert.Same(firstException, await reconnectingErrorTcs.Task.DefaultTimeout()); 1105Assert.Same(firstException, retryContexts[0].RetryReason);