5653 references to Same
Analyzer.Utilities.UnitTests (1)
FlowAnalysis\Analysis\PropertySetAnalysis\PropertySetAnalysisTests.cs (1)
1355Assert.Same(model, operation.SemanticModel);
Client.ChannelLayer.IntegrationTests (2)
DuplexChannelWithSynchronizationContext.cs (2)
63Assert.Same(syncCtx, callbackSyncContext); 128Assert.Same(syncCtx, callbackSyncContext);
IIS.Tests (2)
MaxRequestBodySizeTests.cs (2)
362Assert.Same(thrownError, appErrorLog.Exception); 363Assert.Same(thrownError, badRequestLog.Exception);
InMemory.FunctionalTests (34)
EventSourceTests.cs (20)
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);
Http2\Http2ConnectionTests.cs (5)
208Assert.Same(contentType1, contentType2); 209Assert.Same(authority1, authority2); 210Assert.Same(path1, path2); 5328Assert.Same(ioException, logMessage.Exception); 5347Assert.Same(exception, logMessage.Exception);
Http3\Http3ConnectionTests.cs (4)
436Assert.Same(streamContext1, streamContext2); 471Assert.Same(contentType1, contentType2); 472Assert.Same(authority1, authority2); 545Assert.Same(first, last);
HttpsTests.cs (1)
728Assert.Same(testCert, authOptions.ServerCertificate);
RequestTests.cs (2)
1318Assert.Same(originalRequestHeaders, requestFeature.Headers); 2125Assert.Same(initialContentTypeValue, contentTypeHeaderValue);
ResponseTests.cs (2)
2682Assert.Same(onStartingException, writeException.InnerException); 3085Assert.Same(originalResponseHeaders, responseFeature.Headers);
InProcessWebSite (4)
src\Servers\IIS\IIS\test\testassets\InProcessWebSite\Startup.cs (4)
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);
Interop.FunctionalTests (4)
Http3\Http3RequestTests.cs (4)
364Assert.Same(contentType1, contentType2); 365Assert.Same(authority1, authority2); 953Assert.Same((string)request2Headers["alt-used"], (string)request3Headers["alt-used"]); 1510Assert.Same(request1HeaderValue, request2HeaderValue);
Microsoft.AspNetCore.Antiforgery.Test (2)
DefaultAntiforgeryTokenStoreTest.cs (2)
314Assert.Same(ioException, ex.InnerException); 339Assert.Same(exception, ex.InnerException);
Microsoft.AspNetCore.App.Analyzers.Test (56)
Components\DisallowNonLiteralSequenceNumbersTest.cs (3)
46Assert.Same(DiagnosticDescriptors.DoNotUseNonLiteralSequenceNumbers, diagnostic.Descriptor); 67Assert.Same(DiagnosticDescriptors.DoNotUseNonLiteralSequenceNumbers, diagnostic.Descriptor); 88Assert.Same(DiagnosticDescriptors.DoNotUseNonLiteralSequenceNumbers, diagnostic.Descriptor);
RouteEmbeddedLanguage\RoutePatternAnalyzerTests.cs (11)
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);
RouteHandlers\DetectMisplacedLambdaAttributeTest.cs (6)
48Assert.Same(DiagnosticDescriptors.DetectMisplacedLambdaAttribute, diagnostic.Descriptor); 70Assert.Same(DiagnosticDescriptors.DetectMisplacedLambdaAttribute, diagnostic.Descriptor); 96Assert.Same(DiagnosticDescriptors.DetectMisplacedLambdaAttribute, diagnostic.Descriptor); 102Assert.Same(DiagnosticDescriptors.DetectMisplacedLambdaAttribute, diagnostic.Descriptor); 129Assert.Same(DiagnosticDescriptors.DetectMisplacedLambdaAttribute, diagnostic.Descriptor); 218Assert.Same(DiagnosticDescriptors.DetectMisplacedLambdaAttribute, diagnostic.Descriptor);
RouteHandlers\DisallowMvcBindArgumentsOnParametersTest.cs (2)
61Assert.Same(DiagnosticDescriptors.DoNotUseModelBindingAttributesOnRouteHandlerParameters, diagnostic.Descriptor); 83Assert.Same(DiagnosticDescriptors.DoNotUseModelBindingAttributesOnRouteHandlerParameters, diagnostic.Descriptor);
RouteHandlers\DisallowReturningActionResultsFromMapMethodsTest.cs (6)
130Assert.Same(DiagnosticDescriptors.DoNotReturnActionResultsFromRouteHandlers, diagnostic.Descriptor); 153Assert.Same(DiagnosticDescriptors.DoNotReturnActionResultsFromRouteHandlers, diagnostic.Descriptor); 181Assert.Same(DiagnosticDescriptors.DoNotReturnActionResultsFromRouteHandlers, diagnostic.Descriptor); 213Assert.Same(DiagnosticDescriptors.DoNotReturnActionResultsFromRouteHandlers, diagnostic.Descriptor); 251Assert.Same(DiagnosticDescriptors.DoNotReturnActionResultsFromRouteHandlers, diagnostic.Descriptor); 289Assert.Same(DiagnosticDescriptors.DoNotReturnActionResultsFromRouteHandlers, diagnostic.Descriptor);
WebApplicationBuilder\DisallowConfigureHostBuilderConfigureWebHostTest.cs (7)
45Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, diagnostic.Descriptor); 66Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, diagnostic.Descriptor); 88Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, diagnostic.Descriptor); 128Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, diagnostic.Descriptor); 156Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, diagnostic.Descriptor); 185Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, diagnostic.Descriptor); 219Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, diagnostic.Descriptor);
WebApplicationBuilder\DisallowConfigureHostLoggingTest.cs (1)
273Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor);
WebApplicationBuilder\DisallowConfigureServicesTest.cs (1)
284Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureServices, diagnostic.Descriptor);
WebApplicationBuilder\DisallowConfigureWebHostBuilderConfigureTest.cs (4)
47Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWithConfigureWebHostBuilder, diagnostic.Descriptor); 68Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWithConfigureWebHostBuilder, diagnostic.Descriptor); 95Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWithConfigureWebHostBuilder, diagnostic.Descriptor); 123Assert.Same(DiagnosticDescriptors.DoNotUseConfigureWithConfigureWebHostBuilder, diagnostic.Descriptor);
WebApplicationBuilder\DisallowConfigureWebHostBuilderUseStartupTest.cs (6)
46Assert.Same(DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder, diagnostic.Descriptor); 67Assert.Same(DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder, diagnostic.Descriptor); 87Assert.Same(DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder, diagnostic.Descriptor); 108Assert.Same(DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder, diagnostic.Descriptor); 135Assert.Same(DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder, diagnostic.Descriptor); 163Assert.Same(DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder, diagnostic.Descriptor);
WebApplicationBuilder\UseTopLevelRouteRegistrationInsteadOfUseEndpointsTest.cs (9)
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);
Microsoft.AspNetCore.AsyncState.Tests (2)
AsyncContextHttpContextOfTTests.cs (2)
40Assert.Same(value, stored); 91Assert.Same(value, stored);
Microsoft.AspNetCore.Authentication.Core.Test (10)
AuthenticationPropertiesTests.cs (6)
24Assert.Same(items, props.Items); 25Assert.Same(parameters, props.Parameters); 54Assert.Same(items, props.Items); 71Assert.Same(items, props.Items); 72Assert.Same(parameters, props.Parameters); 156Assert.Same(list, props.Parameters["foo"]);
AuthenticationSchemeProviderTests.cs (2)
190Assert.Same(a, b); 191Assert.Same(b, c);
AuthenticationTicketTests.cs (2)
27Assert.Same(items, ticket.Properties.Items); 28Assert.Same(parameters, ticket.Properties.Parameters);
Microsoft.AspNetCore.Authentication.Test (4)
AuthenticationMiddlewareTests.cs (4)
80Assert.Same(context.User, authenticateResultFeature.AuthenticateResult.Principal); 123Assert.Same(context.User, authenticateResultFeature.AuthenticateResult.Principal); 149Assert.Same(context.User, authenticateResultFeature.AuthenticateResult.Principal); 153Assert.Same(context.User, newTicket.Principal);
Microsoft.AspNetCore.Authorization.Test (8)
AuthorizationMiddlewareTests.cs (8)
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);
Microsoft.AspNetCore.Components.Analyzers.Tests (11)
ComponentInternalUsageDiagnosticsAnalyzerTest.cs (11)
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);
Microsoft.AspNetCore.Components.Authorization.Tests (4)
AuthorizeViewTest.cs (1)
472Assert.Same(resource, call.resource);
src\Components\Shared\test\AssertFrame.cs (3)
126Assert.Same(action, frame.ElementReferenceCaptureAction); 140Assert.Same(action, frame.ComponentReferenceCaptureAction); 147Assert.Same(mode, frame.ComponentRenderMode);
Microsoft.AspNetCore.Components.Endpoints.Tests (5)
Binding\FormDataMetadataFactoryTests.cs (4)
352Assert.Same(metadata, property.PropertyMetadata); 404Assert.Same(property.PropertyMetadata, subProperty.PropertyMetadata); 442Assert.Same(metadata, property.PropertyMetadata.ElementType); 479Assert.Same(metadata, property.PropertyMetadata.ValueType);
RazorComponentResultTest.cs (1)
39Assert.Same(paramsDict, result.Parameters);
Microsoft.AspNetCore.Components.Forms.Tests (24)
EditContextDataAnnotationsExtensionsTest.cs (1)
28Assert.Same(editContext, returnValue);
EditContextTest.cs (8)
20Assert.Same(model, editContext.Model); 32Assert.Same(model, fieldIdentifier.Model); 113Assert.Same(editContext, sender); 221Assert.Same(editContext, sender); 286Assert.Same(value1, editContext.Properties[key1]); 287Assert.Same(value2, editContext.Properties[key2]); 312Assert.Same(value1, retrievedValue1); 313Assert.Same(value2, retrievedValue2);
FieldIdentifierTest.cs (12)
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);
src\Components\Shared\test\AssertFrame.cs (3)
126Assert.Same(action, frame.ElementReferenceCaptureAction); 140Assert.Same(action, frame.ComponentReferenceCaptureAction); 147Assert.Same(mode, frame.ComponentRenderMode);
Microsoft.AspNetCore.Components.SdkAnalyzers.Tests (11)
ComponentInternalUsageDiagnosticsAnalyzerTest.cs (11)
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);
Microsoft.AspNetCore.Components.Server.Tests (26)
Circuits\CircuitHostTest.cs (4)
155Assert.Same(componentException, eventArgs.ExceptionObject); 265Assert.Same(circuitHost, sender); 286Assert.Same(ex, aex.InnerExceptions.Single()); 854Assert.Same(Dispatcher, SynchronizationContext.Current);
Circuits\CircuitPersistenceManagerTest.cs (1)
204Assert.Same(persistedState, circuitPersistenceProvider.State);
Circuits\CircuitRegistryTest.cs (15)
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);
Circuits\DefaultInMemoryCircuitPersistenceProviderTest.cs (2)
28Assert.Same(persistedState, result); 62Assert.Same(persistedState, firstResult);
Circuits\RevalidatingServerAuthenticationStateProviderTest.cs (2)
23Assert.Same(hostAuthStateTask, provider.GetAuthenticationStateAsync()); 28Assert.Same(hostAuthStateTask2, provider.GetAuthenticationStateAsync());
Circuits\ServerAuthenticationStateProviderTest.cs (2)
33Assert.Same(expectedAuthenticationState1, actualAuthenticationState1); 43Assert.Same(expectedAuthenticationState2, actualAuthenticationState2);
Microsoft.AspNetCore.Components.Tests (183)
CascadingParameterStateTest.cs (12)
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);
CascadingParameterTest.cs (2)
485Assert.Same(component.GetCascadingParameterValue(), anotherConsumer.GetCascadingParameterValue()); 710Assert.Same(updatedValue, component.GetCascadingParameterValue());
ComponentBaseTest.cs (4)
415Assert.Same(expected, actual); 431Assert.Same(expected, actual); 447Assert.Same(expected, actual); 463Assert.Same(expected, actual);
ComponentFactoryTest.cs (5)
152Assert.Same(resolvedComponent, instance); 156Assert.Same(componentActivator, renderer.SuppliedActivator); 202Assert.Same(resolvedComponent, instance); 205Assert.Same(componentActivator, renderer.SuppliedActivator); 206Assert.Same(callSiteRenderMode, renderer.SuppliedRenderMode);
DependencyInjectionTest.cs (10)
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);
EventCallbackFactoryTest.cs (64)
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);
ParameterViewTest.Assignment.cs (3)
32Assert.Same(someObject, target.ObjectPropCurrentValue); 109Assert.Same(existingObjectValue, target.ObjectPropCurrentValue); 334Assert.Same(value, target.CaptureUnmatchedValues);
ParameterViewTest.cs (5)
161Assert.Same(myEntryValue, result); 180Assert.Same(myEntryValue, result); 293Assert.Same(entry2Value, entry.Value); 317Assert.Same(myEntryValue, result); 576Assert.Same(expectedValue, parameter.Value);
RendererTest.cs (32)
595Assert.Same(eventArgs, receivedArgs); 618Assert.Same(typeof(DerivedEventArgs), eventArgsType); 641Assert.Same(typeof(EventArgs), eventArgsType); 749Assert.Same(eventArgs, receivedArgs); 818Assert.Same(eventArgs, receivedArgs); 856Assert.Same(eventArgs, receivedArgs); 899Assert.Same(eventArgs, receivedArgs); 996Assert.Same(eventArgs, receivedArgs); 2096Assert.Same(objectThatWillNotChange, childComponentInstance.ObjectProperty); 2105Assert.Same(objectThatWillNotChange, childComponentInstance.ObjectProperty); 2338Assert.Same(exception1, aex); 2461Assert.Same(exception1, aex); 2604Assert.Same(exception1, ex); 2611Assert.Same(exception2, ex); 3678Assert.Same(exception, Assert.Single(renderer.HandledExceptions).GetBaseException()); 3694Assert.Same(exception, Assert.Single(renderer.HandledExceptions).GetBaseException()); 3734Assert.Same(exception, Assert.Single(renderer.HandledExceptions).GetBaseException()); 3901Assert.Same(exception, Assert.Single(renderer.HandledExceptions).GetBaseException()); 3957Assert.Same(exception, Assert.Single(renderer.HandledExceptions).GetBaseException()); 3977Assert.Same(ConstructorThrowingComponent.Exception, Assert.Single(renderer.HandledExceptions).GetBaseException()); 4017Assert.Same(AttachThrowingComponent.Exception, Assert.Single(renderer.HandledExceptions).GetBaseException()); 4286Assert.Same(exception1, handledException); 4319Assert.Same(exception1, handledException); 4487Assert.Same(parameterValue, capturingComponent.SomeParam); 4566component => Assert.Same(exception, component.ReceivedException)); 4602component => Assert.Same(exception, component.ReceivedException)); 4642component => Assert.Same(exception, component.ReceivedException)); 4680component => Assert.Same(exception, component.ReceivedException)); 4724component => Assert.Same(exception, component.ReceivedException)); 4779component => Assert.Same(exception, component.ReceivedException)); 4927Assert.Same(exception1, Assert.Single(renderer.HandledExceptions)); 4935Assert.Same(exception2, renderer.HandledExceptions[1]);
Rendering\ArrayBuilderSegmentTest.cs (3)
21Assert.Same(builder.Buffer, segment.Array); 40Assert.Same(originalBuffer, segment.Array); 47Assert.Same(builder.Buffer, segment.Array);
Rendering\ArrayBuilderTest.cs (5)
214Assert.Same(buffer, returnedBuffer); 231Assert.Same(buffer, returnedBuffer); 261Assert.Same(buffer, returnedBuffer); 280Assert.Same(buffer, returnedBuffer); 323Assert.Same(buffer, Assert.Single(ArrayPool.ReturnedBuffers));
Rendering\RendererSynchronizationContextTest.cs (13)
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);
Rendering\RenderTreeBuilderTest.cs (2)
1708Assert.Same(keyValue, frame.ElementKey); 1734Assert.Same(keyValue, frame.ComponentKey);
RenderTreeDiffBuilderTest.cs (14)
244Assert.Same(oldComponent, newComponents[1]); 281Assert.Same(oldComponents[1], newComponent); 313Assert.Same(oldComponents[1], newComponent); 342Assert.Same(oldComponents[0], newComponents[1]); 1606Assert.Same(testObject, componentInstance.ObjectProperty); 1643Assert.Same(originalFakeComponentInstance, newFrame1.Component); 1644Assert.Same(originalFakeComponent2Instance, newFrame2.Component); 1725Assert.Same(originalComponentInstance, newComponentInstance); 1727Assert.Same(objectWillNotChange, newComponentInstance.ObjectProperty); 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]);
Routing\RouteTableFactoryTests.cs (3)
34Assert.Same(routes1, routes2); 48Assert.Same(routes1, routes2); 1110Assert.Same(typeof(TestHandler1), context.Handler);
src\Components\Shared\test\AssertFrame.cs (3)
126Assert.Same(action, frame.ElementReferenceCaptureAction); 140Assert.Same(action, frame.ComponentReferenceCaptureAction); 147Assert.Same(mode, frame.ComponentRenderMode);
StackObjectPoolTest.cs (3)
54Assert.Same(instance1, instance1b); 55Assert.Same(instance2, instance2b); 84Assert.Same(instance1, instance1b);
Microsoft.AspNetCore.Components.Web.Tests (8)
Forms\EditFormTest.cs (2)
77Assert.Same(model, returnedEditContext.Model); 97Assert.Same(editContext, returnedEditContext);
Forms\InputBaseTest.cs (1)
72Assert.Same(rootComponent.EditContext, inputComponent.EditContext);
Forms\InputFileChangeEventArgsTest.cs (2)
23Assert.Same(file, instance.File); 54Assert.Same(files, instance.GetMultipleFiles());
src\Components\Shared\test\AssertFrame.cs (3)
126Assert.Same(action, frame.ElementReferenceCaptureAction); 140Assert.Same(action, frame.ComponentReferenceCaptureAction); 147Assert.Same(mode, frame.ComponentRenderMode);
Microsoft.AspNetCore.Components.WebView.Test (1)
ComponentsWebViewServiceCollectionExtensionsTests.cs (1)
28Assert.Same(persistenceManager.State, persistentState);
Microsoft.AspNetCore.ConcurrencyLimiter.Tests (1)
ConcurrencyLimiterEventSourceTests.cs (1)
40Assert.Same(eventSource, eventData.EventSource);
Microsoft.AspNetCore.Cors.Test (7)
CorsOptionsTest.cs (3)
22Assert.Same(expectedPolicy, actualPolicy); 38Assert.Same(expectedPolicy, actualPolicy); 61Assert.Same(expectedPolicy, actualPolicy);
CorsPolicyBuilderTests.cs (2)
41Assert.Same(originalPolicy.IsOriginAllowed, corsPolicy.IsOriginAllowed); 186Assert.Same(corsPolicy.IsOriginAllowed, isOriginAllowed);
DefaultCorsPolicyProviderTests.cs (2)
26Assert.Same(policy, actualPolicy); 46Assert.Same(policy, actualPolicy);
Microsoft.AspNetCore.Cryptography.Internal.Tests (9)
Cng\CachedAlgorithmHandlesTests.cs (3)
113Assert.Same(algorithmHandle, algorithmHandleSecondAttempt); 135Assert.Same(algorithmHandle, algorithmHandleSecondAttempt); 166Assert.Same(algorithmHandle, algorithmHandleSecondAttempt);
WeakReferenceHelpersTests.cs (6)
26Assert.Same(newInstance, target); 27Assert.Same(newInstance, retVal); 44Assert.Same(newInstance, target); 45Assert.Same(newInstance, retVal); 68Assert.Same(instanceThatWillBeCreatedFirst, target); 69Assert.Same(instanceThatWillBeCreatedFirst, retVal);
Microsoft.AspNetCore.DataProtection.Abstractions.Tests (7)
DataProtectionCommonExtensionsTests.cs (7)
69Assert.Same(finalExpectedProtector, retVal); 89Assert.Same(finalExpectedProtector, retVal); 106Assert.Same(finalExpectedProtector, retVal); 133Assert.Same(expected, actual); 196Assert.Same(finalExpectedProtector, retVal); 220Assert.Same(finalExpectedProtector, retVal); 240Assert.Same(finalExpectedProtector, retVal);
Microsoft.AspNetCore.DataProtection.Tests (50)
ActivatorTests.cs (3)
29Assert.Same(services, retVal2.Services); 32Assert.Same(services, retVal3.Services); 79Assert.Same(expectedActivator, actualActivator);
KeyManagement\CacheableKeyRingTests.cs (1)
54Assert.Same(keyRing, cacheableKeyRing.KeyRing);
KeyManagement\DefaultKeyResolverTests.cs (13)
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);
KeyManagement\DeferredKeyTests.cs (1)
41Assert.Same(mockDescriptor, key.Descriptor);
KeyManagement\KeyRingProviderTests.cs (14)
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);
KeyManagement\KeyRingTests.cs (7)
26Assert.Same(expectedEncryptorInstance, keyRing.DefaultAuthenticatedEncryptor); 28Assert.Same(expectedEncryptorInstance, keyRing.DefaultAuthenticatedEncryptor); 77Assert.Same(expectedEncryptorInstance1, keyRing.GetAuthenticatedEncryptorByKeyId(key1.KeyId, out var isRevoked)); 80Assert.Same(expectedEncryptorInstance1, keyRing.GetAuthenticatedEncryptorByKeyId(key1.KeyId, out isRevoked)); 84Assert.Same(expectedEncryptorInstance2, keyRing.GetAuthenticatedEncryptorByKeyId(key2.KeyId, out isRevoked)); 87Assert.Same(expectedEncryptorInstance2, keyRing.GetAuthenticatedEncryptorByKeyId(key2.KeyId, out isRevoked)); 90Assert.Same(expectedEncryptorInstance2, keyRing.DefaultAuthenticatedEncryptor);
KeyManagement\KeyTests.cs (1)
31Assert.Same(descriptor, key.Descriptor);
KeyManagement\XmlKeyManagerTests.cs (9)
71Assert.Same(expectedXmlEncryptor, keyManager.KeyEncryptor); 133Assert.Same(expectedDescriptor, newKey.Descriptor); 135Assert.Same(expectedAuthenticatedEncryptor, testEncryptorFactory.CreateEncryptorInstance(newKey)); 231Assert.Same(expectedDescriptor, newKey.Descriptor); 233Assert.Same(expectedAuthenticatedEncryptor, testEncryptorFactory.CreateEncryptorInstance(newKey)); 377Assert.Same(descriptorA, keys[0].Descriptor); 383Assert.Same(descriptorB, keys[1].Descriptor); 488Assert.Same(expectedDescriptor, keys[0].Descriptor); 527Assert.Same(expectedDescriptor, keys[0].Descriptor);
XmlEncryption\XmlEncryptionExtensionsTests.cs (1)
24Assert.Same(original, retVal);
Microsoft.AspNetCore.HeaderParsing.Tests (2)
HeaderParsingFeatureTests.cs (2)
205Assert.Same(value1, value2); 206Assert.Same(value1, value3);
Microsoft.AspNetCore.HeaderPropagation.Tests (1)
HeaderPropagationMiddlewareTest.cs (1)
138Assert.Same(Context, receivedContext);
Microsoft.AspNetCore.Hosting.Tests (13)
HostingApplicationTests.cs (3)
63Assert.Same(previousContext, context.HttpContext); 67Assert.Same(previousContext, context.HttpContext); 120Assert.Same(initialActivity, activityFeature.Activity);
Http\DefaultHttpContextFactoryTests.cs (3)
26Assert.Same(context, accessor.HttpContext); 44Assert.Same(context, accessor.HttpContext); 80Assert.Same(services.GetRequiredService<IServiceScopeFactory>(), context.ServiceScopeFactory);
Internal\HostingEventSourceTests.cs (5)
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);
WebHostTests.cs (2)
881Assert.Same(httpContext.TraceIdentifier, featuresTraceIdentifier); 902Assert.Same(requestIdentifierFeature, httpContext.Features.Get<IHttpRequestIdentifierFeature>());
Microsoft.AspNetCore.Html.Abstractions.Tests (2)
HtmlContentBuilderExtensionsTest.cs (2)
57entry => Assert.Same(content, entry), 108entry => Assert.Same(content, entry));
Microsoft.AspNetCore.Http.Abstractions.Tests (14)
EndpointMetadataCollectionTests.cs (2)
54Assert.Same(Array.Empty<string>(), ordered); 67Assert.Same(ordered1, ordered2);
HttpMethodslTests.cs (1)
41Assert.Same(expectedMethod, canonicalizedValue);
RouteValueDictionaryTests.cs (10)
73Assert.Same(otherStorage, storage); 421Assert.Same(StringComparer.OrdinalIgnoreCase, dict.Comparer); 1610Assert.Same(value, removedValue); 1627Assert.Same(value, removedValue); 1666Assert.Same(value, removedValue); 1686Assert.Same(value, removedValue); 1708Assert.Same(value, removedValue); 1733Assert.Same(value, removedValue); 1758Assert.Same(value, removedValue); 2157Assert.Same(Array.Empty<KeyValuePair<string, object?>>(), value._arrayStorage);
UseMiddlewareTest.cs (1)
279Assert.Same(middlewareFactory.Created, middlewareFactory.Released);
Microsoft.AspNetCore.Http.Connections.Tests (14)
HttpConnectionDispatcherTests.cs (2)
1867Assert.Same(currentUser, connection.User); 1919Assert.Same(currentUser, connection.User);
HttpConnectionManagerTests.cs (9)
153Assert.Same(newConnection, connection); 171Assert.Same(newConnection, connection); 172Assert.Same(transport, newConnection.Transport); 190Assert.Same(newConnection, connection); 191Assert.Same(transport, newConnection.Transport); 212Assert.Same(newConnection, connection); 213Assert.Same(transport, newConnection.Transport); 234Assert.Same(newConnection, connection); 235Assert.Same(transport, newConnection.Transport);
Internal\HttpConnectionsEventSourceTests.cs (3)
45Assert.Same(httpConnectionsEventSource, eventData.EventSource); 72Assert.Same(httpConnectionsEventSource, eventData.EventSource); 99Assert.Same(httpConnectionsEventSource, eventData.EventSource);
Microsoft.AspNetCore.Http.Extensions.Tests (36)
ProblemDetailsServiceCollectionExtensionsTest.cs (2)
82Assert.Same(customService, service.ImplementationInstance); 240Assert.Same(customProblemDetailsResolver.LastProblemDetailsInfo, pdTypeInfo);
RequestDelegateFactoryTests.cs (10)
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), 2888Assert.Same(options.EndpointBuilder.Metadata, result.EndpointMetadata); 3067Assert.Same(initialRequestDelegate, result.RequestDelegate); 3083Assert.Same(options.EndpointBuilder.RequestDelegate, result.RequestDelegate); 3084Assert.Same(options.EndpointBuilder.Metadata, result.EndpointMetadata); 3100Assert.Same(Results.Empty, response);
RequestDelegateGenerator\RequestDelegateCreationTests.Forms.cs (1)
944Assert.Same(ioException, logMessage.Exception);
RequestDelegateGenerator\RequestDelegateCreationTests.JsonBody.cs (6)
239Assert.Same(httpContext.Request.Body, stream); 280Assert.Same(httpContext.Request.Body, stream); 324Assert.Same(httpContext.Request.Body, stream); 325Assert.Same(httpContext.Request.BodyReader, pipeReader); 365Assert.Same(httpContext.Request.Body, stream); 366Assert.Same(httpContext.Request.BodyReader, pipeReader);
RequestDelegateGenerator\RequestDelegateCreationTests.KeyServices.cs (8)
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"]);
RequestDelegateGenerator\RequestDelegateCreationTests.Logging.cs (3)
495Assert.Same(ioException, logMessage.Exception); 533Assert.Same(jsonException, logMessage.Exception); 576Assert.Same(jsonException, badHttpRequestException.InnerException);
RequestDelegateGenerator\RequestDelegateCreationTests.SpecialTypes.cs (6)
40Assert.Same(httpContext, httpContext.Items["arg"]); 84Assert.Same(user, httpContext.Items["arg"]); 147Assert.Same(httpContext, httpContext.Items["input"]); 148Assert.Same(httpContext.User, httpContext.Items["user"]); 149Assert.Same(httpContext.Request, httpContext.Items["request"]); 150Assert.Same(httpContext.Response, httpContext.Items["response"]);
Microsoft.AspNetCore.Http.Results.Tests (6)
CreatedOfTResultTests.cs (1)
42Assert.Same(location, result.Location);
CreatedResultTests.cs (1)
27Assert.Same(location, result.Location);
LocalRedirectResultTests.cs (3)
24Assert.Same(url, result.Url); 39Assert.Same(url, result.Url); 54Assert.Same(url, result.Url);
RedirectResultTests.cs (1)
22Assert.Same(url, result.Url);
Microsoft.AspNetCore.Http.Tests (45)
DefaultHttpContextTests.cs (13)
40Assert.Same(session, context.Session); 56Assert.Same(session, context.Session); 115Assert.Same(items, context.Items); 118Assert.Same(item, context.Items["foo"]); 129Assert.Same(traceIdentifier, context.TraceIdentifier); 132Assert.Same("Hello", context.TraceIdentifier); 143Assert.Same(items, context.Items); 146Assert.Same(item, context.Items["foo"]); 200Assert.Same(serviceProvider, context.RequestServices); 379Assert.Same(features, field.GetValue(value)); 384Assert.Same(features[field.FieldType], v); 397Assert.Same(features, property.GetValue(value)); 404Assert.Same(features[property.PropertyType], v);
Features\FormFeatureTests.cs (17)
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);
HeaderDictionaryTests.cs (3)
126Assert.Same(Array.Empty<string>(), (string[])emptyHeaders["Header1"]); 129Assert.Same(Array.Empty<string>(), (string[])asIHeaderDictionary["Header1"]); 130Assert.Same(Array.Empty<string>(), (string[])asIHeaderDictionary.Host);
HttpContextAccessorTests.cs (4)
19Assert.Same(context, accessor.HttpContext); 45Assert.Same(context, accessor.HttpContext); 90Assert.Same(context, accessor.HttpContext); 116Assert.Same(context2, accessor.HttpContext);
Internal\DefaultHttpRequestTests.cs (1)
158Assert.Same(query2, request.Query);
Internal\DefaultHttpResponseTests.cs (5)
85Assert.Same(originalStream, context.Response.Body); 86Assert.Same(responseBodyMock.Object, context.Features.Get<IHttpResponseBodyFeature>()); 90Assert.Same(replacementStream, context.Response.Body); 95Assert.Same(originalStream, context.Response.Body); 96Assert.Same(responseBodyMock.Object, context.Features.Get<IHttpResponseBodyFeature>());
QueryCollectionTests.cs (2)
17Assert.Same(Array.Empty<string>(), (string[])query["query1"]); 20Assert.Same(Array.Empty<string>(), (string[])QueryCollection.Empty["query1"]);
Microsoft.AspNetCore.Identity.Test (10)
SignInManagerTest.cs (6)
387Assert.Same(SignInResult.Success, signInResult); 1255Assert.Same(SignInResult.Failed, result); 1310Assert.Same(SignInResult.Failed, result); 1344Assert.Same(expectedSignInResult, result); 1376Assert.Same(expectedSignInResult, result); 1425Assert.Same(userEntity, options.UserEntity);
UserManagerTest.cs (4)
44Assert.Same(provider.GetRequiredService<UserManager<PocoUser>>(), 46Assert.Same(provider.GetRequiredService<RoleManager<PocoRole>>(), 705Assert.Same(passkeys, result); 1916Assert.Same(describer, manager.ErrorDescriber);
Microsoft.AspNetCore.InternalTesting.Tests (2)
AssemblyTestLogTests.cs (1)
32Assert.Same(
LoggedTestXunitTests.cs (1)
114Assert.Same(loggerFactory, serviceCollection.BuildServiceProvider().GetRequiredService<ILoggerFactory>());
Microsoft.AspNetCore.JsonPatch.SystemTextJson.Tests (6)
IntegrationTests\ListIntegrationTest.cs (2)
339Assert.Same(simpleObject2, targetObject.SimpleObjectList[0]); 340Assert.Same(simpleObject1, targetObject.SimpleObjectList[1]);
IntegrationTests\NestedObjectIntegrationTest.cs (1)
314Assert.Same(iDto, targetObject.SimpleObject);
Internal\ObjectVisitorTest.cs (3)
56Assert.Same(expectedTargetObject, targetObject); 90Assert.Same(expectedTargetObject, targetObject); 134Assert.Same(expectedTargetObject, targetObject);
Microsoft.AspNetCore.JsonPatch.Tests (8)
IntegrationTests\ListIntegrationTest.cs (2)
339Assert.Same(simpleObject2, targetObject.SimpleObjectList[0]); 340Assert.Same(simpleObject1, targetObject.SimpleObjectList[1]);
IntegrationTests\NestedObjectIntegrationTest.cs (1)
329Assert.Same(iDto, targetObject.SimpleObject);
Internal\ObjectVisitorTest.cs (5)
56Assert.Same(expectedTargetObject, targetObject); 89Assert.Same(expectedTargetObject, targetObject); 119Assert.Same(expectedTargetObject, targetObject); 120Assert.Same(typeof(DictionaryAdapter<string, object>), adapter.GetType()); 151Assert.Same(expectedTargetObject, targetObject);
Microsoft.AspNetCore.Localization.Tests (1)
RequestLocalizationOptionsExtensionsTest.cs (1)
21Assert.Same(provider, options.RequestCultureProviders[0]);
Microsoft.AspNetCore.Mvc.Abstractions.Test (19)
Filters\FilterContextTest.cs (1)
89Assert.Same(filters.Last(), result);
ModelBinding\BindingInfoTest.cs (14)
26Assert.Same("Test", bindingInfo.BinderModelName); 27Assert.Same(BindingSource.Query, bindingInfo.BindingSource); 45Assert.Same(bindAttribute, bindingInfo.PropertyFilterProvider); 79Assert.Same("PropertyPrefix", bindingInfo.BinderModelName); 119Assert.Same(typeof(ComplexObjectModelBinder), bindingInfo.BinderType); 120Assert.Same("Test", bindingInfo.BinderModelName); 168Assert.Same(typeof(ComplexObjectModelBinder), bindingInfo.BinderType); 169Assert.Same("Different", bindingInfo.BinderModelName); 170Assert.Same(BindingSource.Custom, bindingInfo.BindingSource); 191Assert.Same(typeof(ComplexObjectModelBinder), bindingInfo.BinderType); 217Assert.Same(BindingSource.Services, bindingInfo.BindingSource); 244Assert.Same(propertyFilterProvider, bindingInfo.PropertyFilterProvider); 309Assert.Same(BindingSource.Services, bindingInfo.BindingSource); 310Assert.Same(key, bindingInfo.ServiceKey);
ModelBinding\ModelStateDictionaryTest.cs (4)
299Assert.Same(exception, error.Exception); 339Assert.Same(exception, kvp.Value.Errors[1].Exception); 970Assert.Same(exception, error.Exception); 1083Assert.Same(exception, error.Exception);
Microsoft.AspNetCore.Mvc.ApiExplorer.Test (61)
DefaultApiDescriptionProviderTest.cs (61)
103Assert.Same(action, description.ActionDescriptor); 1235Assert.Same(formatters[0], apiResponseFormat.Formatter); 1338Assert.Same(formatters[1], format.Formatter); 1357Assert.Same(BindingSource.ModelBinding, parameter.Source); 1361Assert.Same(BindingSource.ModelBinding, parameter.Source); 1365Assert.Same(BindingSource.ModelBinding, parameter.Source); 1382Assert.Same(BindingSource.ModelBinding, parameter.Source); 1402Assert.Same(BindingSource.Path, parameter.Source); 1419Assert.Same(BindingSource.Query, parameter.Source); 1436Assert.Same(BindingSource.Body, parameter.Source); 1455Assert.Same(BindingSource.Form, parameter.Source); 1459Assert.Same(BindingSource.Form, parameter.Source); 1463Assert.Same(BindingSource.Form, parameter.Source); 1485Assert.Same(BindingSource.FormFile, parameter.Source); 1506Assert.Same(BindingSource.Header, parameter.Source); 1538Assert.Same(BindingSource.Custom, parameter.Source); 1557Assert.Same(BindingSource.ModelBinding, parameter.Source); 1561Assert.Same(BindingSource.ModelBinding, parameter.Source); 1565Assert.Same(BindingSource.ModelBinding, parameter.Source); 1584Assert.Same(BindingSource.Path, id.Source); 1588Assert.Same(BindingSource.Body, product.Source); 1592Assert.Same(BindingSource.Header, userId.Source); 1596Assert.Same(BindingSource.ModelBinding, comments.Source); 1615Assert.Same(BindingSource.Query, id.Source); 1634Assert.Same(BindingSource.Query, id.Source); 1653Assert.Same(BindingSource.Query, id.Source); 1672Assert.Same(BindingSource.Query, id.Source); 1691Assert.Same(BindingSource.Query, id.Source); 1710Assert.Same(BindingSource.Query, id.Source); 1729Assert.Same(BindingSource.Query, id.Source); 1748Assert.Same(BindingSource.Query, id.Source); 1752Assert.Same(BindingSource.Query, product.Source); 1772Assert.Same(BindingSource.Path, id.Source); 1776Assert.Same(BindingSource.Body, product.Source); 1780Assert.Same(BindingSource.Header, userId.Source); 1784Assert.Same(BindingSource.Query, comments.Source); 1803Assert.Same(BindingSource.Path, id.Source); 1807Assert.Same(BindingSource.ModelBinding, quantity.Source); 1811Assert.Same(BindingSource.ModelBinding, productId.Source); 1815Assert.Same(BindingSource.Query, price.Source); 1835Assert.Same(BindingSource.Path, id.Source); 1839Assert.Same(BindingSource.Query, quantity.Source); 1843Assert.Same(BindingSource.Query, productId.Source); 1847Assert.Same(BindingSource.Query, productPrice.Source); 1870Assert.Same(BindingSource.Query, id.Source); 1874Assert.Same(BindingSource.Query, name.Source); 1901Assert.Same(BindingSource.Query, id.Source); 1905Assert.Same(BindingSource.Query, name.Source); 1924Assert.Same(BindingSource.Query, c.Source); 1942Assert.Same(BindingSource.Query, products.Source); 1961Assert.Same(BindingSource.ModelBinding, items.Source); 1983Assert.Same(BindingSource.Query, id.Source); 1987Assert.Same(BindingSource.Query, name.Source); 2005Assert.Same(BindingSource.Header, name.Source); 2009Assert.Same(BindingSource.Form, id.Source); 2028Assert.Same(BindingSource.Query, name.Source); 2032Assert.Same(BindingSource.Path, id.Source); 2036Assert.Same(BindingSource.Body, product.Source); 2040Assert.Same(BindingSource.Header, userId.Source); 2044Assert.Same(BindingSource.ModelBinding, comments.Source); 2193Assert.Same(defaultValue, description.DefaultValue);
Microsoft.AspNetCore.Mvc.Core.Test (444)
AcceptedAtActionResultTests.cs (2)
103Assert.Same(value, result.Value); 143Assert.Same(value, actual);
AcceptedAtRouteResultTests.cs (2)
44Assert.Same(value, result.Value); 77Assert.Same(value, actual);
AcceptedResultTests.cs (2)
40Assert.Same(value, result.Value); 63Assert.Same(value, actual);
ActionConstraints\ActionConstraintCacheTest.cs (11)
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
ActionResultOfTTest.cs (4)
56Assert.Same(expected, result); 72Assert.Same(value, objectResult.Value); 90Assert.Same(value, objectResult.Value); 108Assert.Same(value, objectResult.Value);
ApplicationModels\ActionModelTest.cs (2)
53Assert.Same(action2, action2.Parameters[0].Action); 135Assert.Same(value1, value2);
ApplicationModels\AttributeRouteModelTests.cs (1)
48Assert.Same(value1, value2);
ApplicationModels\ControllerActionDescriptorProviderTests.cs (1)
69Assert.Same(globalFilter, filter1.Filter);
ApplicationModels\ControllerModelTest.cs (3)
55Assert.Same(controller2, controller2.Actions[0].Controller); 57Assert.Same(controller2, controller2.ControllerProperties[0].Controller); 137Assert.Same(value1, value2);
ApplicationModels\DefaultApplicationModelProviderTest.cs (13)
82Assert.Same(controllerModel, property.Controller); 91Assert.Same(controllerModel, property.Controller); 99Assert.Same(controllerModel, property.Controller); 108Assert.Same(controllerModel, property.Controller); 134Assert.Same(controllerModel, property.Controller); 143Assert.Same(controllerModel, property.Controller); 151Assert.Same(controllerModel, property.Controller); 160Assert.Same(controllerModel, property.Controller); 187Assert.Same(action, parameter.Action); 196Assert.Same(action, parameter.Action); 204Assert.Same(action, parameter.Action); 1362Assert.Same(typeof(ComplexObjectModelBinder), bindingInfo.BinderType); 1377Assert.Same(BindingSource.Path, property.BindingInfo.BindingSource);
ApplicationModels\InferParameterBindingInfoConventionTest.cs (46)
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);
ApplicationModels\ParameterModelTest.cs (1)
71Assert.Same(value1, value2);
ApplicationModels\PropertyModelTest.cs (1)
62Assert.Same(value1, value2);
ApplicationModels\RouteTokenTransformerConventionTest.cs (1)
28Assert.Same(transformer, model.RouteParameterTransformer);
Authorization\AuthorizeFilterTest.cs (3)
432Assert.Same(authorizeFilter, result); 448Assert.Same(authorizeFilter, result); 507Assert.Same(policyProvider, actual.PolicyProvider);
ControllerBaseTest.cs (50)
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);
Controllers\ControllerActivatorProviderTest.cs (2)
34Assert.Same(expected, result); 66Assert.Same(expected, actual.TestService);
Controllers\ControllerFactoryProviderTest.cs (5)
34Assert.Same(result, expected); 139Assert.Same(expectedController, actual); 140Assert.Same(expectedProperty1, actual.ActivatedValue1); 141Assert.Same(expectedProperty2, actual.ActivatedValue2); 173Assert.Same(expected, actual);
Controllers\DefaultControllerActivatorTest.cs (1)
144Assert.Same(testService, controller.TestService);
Controllers\DefaultControllerFactoryTest.cs (3)
46Assert.Same(expected, controller); 74Assert.Same(context, controller.ActionContext); 101Assert.Same(context, controller.ControllerContext);
Controllers\ServiceBasedControllerActivatorTest.cs (1)
39Assert.Same(controller, instance);
CreatedResultTests.cs (1)
38Assert.Same(location, result.Location);
DependencyInjection\MvcBuilderExtensionsTest.cs (3)
30Assert.Same(result, builder); 55Assert.Same(TestApplicationPartFactory.TestPart, part); 75Assert.Same(result, builder);
DependencyInjection\MvcCoreBuilderExtensionsTest.cs (3)
27Assert.Same(result, builder); 52Assert.Same(TestApplicationPartFactory.TestPart, part); 72Assert.Same(result, builder);
DependencyInjection\MvcCoreServiceCollectionExtensionsTest.cs (2)
122Assert.Same(manager, builder.PartManager); 142Assert.Same(manager, builder.PartManager);
Filters\FilterCollectionTest.cs (4)
22Assert.Same(typeFilter, Assert.Single(collection)); 37Assert.Same(typeFilter, Assert.Single(collection)); 93Assert.Same(serviceFilter, Assert.Single(collection)); 108Assert.Same(serviceFilter, Assert.Single(collection));
Filters\FilterFactoryTest.cs (16)
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
Filters\FilterProviderTest.cs (9)
34Assert.Same(filter, item.Filter); 35Assert.Same(filter, item.Descriptor.Filter); 65Assert.Same(filter, item.Filter); 66Assert.Same(filterFactory.Object, item.Descriptor.Filter); 97Assert.Same(filter, item.Filter); 98Assert.Same(filterFactory.Object, item.Descriptor.Filter); 128Assert.Same(filter.Object, item.Filter); 129Assert.Same(filterFactory.Object, ((IFilterContainer)item.Filter).FilterDefinition); 130Assert.Same(filterFactory.Object, item.Descriptor.Filter);
Filters\MiddlewareFilterBuilderTest.cs (1)
71Assert.Same(pipeline1, pipeline2);
Filters\MiddlewareFilterTest.cs (4)
42Assert.Same(resourceExecutingContext, feature.ResourceExecutingContext); 43Assert.Same(resourceExecutionDelegate, feature.ResourceExecutionDelegate); 365Assert.Same(_controller, controller); 372Assert.Same(_controller, controller);
Formatters\AcceptHeaderParserTest.cs (1)
45Assert.Same(header, mediaType.MediaType.Buffer);
Formatters\TextOutputFormatterTests.cs (2)
123Assert.Same(firstContentType.Buffer, secondContentType.Buffer); 174Assert.Same(contentType, formatterContext.ContentType.Buffer);
HttpOkObjectResultTest.cs (1)
43Assert.Same(value, result.Value);
Infrastructure\ActionResultTypeMapperTest.cs (3)
24Assert.Same(expected, result); 40Assert.Same(returnValue, httpResult.Result); 71Assert.Same(returnValue, objectResult.Value);
Infrastructure\ActionSelectionTableTest.cs (8)
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);
Infrastructure\ActionSelectorTest.cs (14)
62Assert.Collection(candidates, (a) => Assert.Same(actions[0], a)); 105Assert.Collection(candidates, (a) => Assert.Same(actions[0], a)); 352Assert.Same(actions[0], action); 386Assert.Same(actions[0], action); 420Assert.Same(actions[0], action); 454Assert.Same(actions[0], action); 488Assert.Same(actions[0], action); 546Assert.Same(action, actionWithConstraints); 644Assert.Same(action, actionWithConstraints); 670Assert.Same(action, nullConstraint); 700Assert.Same(action, actionWithConstraints); 733Assert.Same(action, best); 770Assert.Same(action, best); 808Assert.Same(action, best);
Infrastructure\AsyncEnumerableReaderTest.cs (2)
79Assert.Same(reader1, reader2); 96Assert.Same(reader1, reader2);
Infrastructure\ClientErrorResultFilterTest.cs (5)
29Assert.Same(actionResult, context.Result); 50Assert.Same(actionResult, context.Result); 66Assert.Same(Result, context.Result); 84Assert.Same(Result, context.Result); 102Assert.Same(actionResult, context.Result);
Infrastructure\ControllerActionInvokerCacheTest.cs (1)
57Assert.Same(cacheEntry, cacheEntry2);
Infrastructure\ControllerActionInvokerTest.cs (16)
224Assert.Same(valueProviderFactory1, controllerContext.ValueProviderFactories[0]); 225Assert.Same(valueProviderFactory2, controllerContext.ValueProviderFactories[1]); 256Assert.Same(valueProviderFactory2, controllerContext.ValueProviderFactories[0]); 285Assert.Same(Result, result); 314Assert.Same(Result, result); 371Assert.Same(context.Result, result.Object); 440Assert.Same(context.Result, result.Object); 554Assert.Same(Exception, context.Exception); 597Assert.Same(exception, context.Exception); 640Assert.Same(exception, context.Exception); 719Assert.Same(expected, context.Result); 757Assert.Same(expected, context.Exception); 758Assert.Same(expected, context.ExceptionDispatchInfo.SourceException); 796Assert.Same(expected, context.Exception); 797Assert.Same(expected, context.ExceptionDispatchInfo.SourceException); 814Assert.Same(Exception, context.Exception);
Infrastructure\DefaultActionDescriptorCollectionProviderTest.cs (9)
36descriptor => Assert.Same(expected1, descriptor), 37descriptor => Assert.Same(expected2, descriptor), 38descriptor => Assert.Same(expected3, descriptor)); 62Assert.Same(collection1, collection2); 116item => Assert.Same(expected1, item)); 135Assert.Same(captured, collection2); 138item => Assert.Same(expected2, item)); 152Assert.Same(captured, collection3); 155item => Assert.Same(expected3, item));
Infrastructure\DefaultOutputFormatterSelectorTest.cs (7)
42Assert.Same(formatters[1], formatter); 72Assert.Same(formatters[1], formatter); 172Assert.Same(formatters[1], formatter); 201Assert.Same(formatters[1], formatter); 231Assert.Same(formatters[0], formatter); 328Assert.Same(formatters[0], formatter); 359Assert.Same(formatters[0], formatter);
Infrastructure\ModelStateInvalidFilterTest.cs (2)
31Assert.Same(expected, context.Result); 69Assert.Same(expected, context.Result);
LocalRedirectResultTest.cs (3)
29Assert.Same(url, result.Url); 44Assert.Same(url, result.Url); 59Assert.Same(url, result.Url);
ModelBinding\Binders\ArrayModelBinderTest.cs (1)
211Assert.Same(model, bindingContext.Result.Model);
ModelBinding\Binders\BodyModelBinderTests.cs (1)
586Assert.Same(canReadFormatter1, bindingContext.Result.Model);
ModelBinding\Binders\CollectionModelBinderTest.cs (3)
117Assert.Same(list, bindingContext.Result.Model); 169Assert.Same(list, bindingContext.Result.Model); 375Assert.Same(list, bindingContext.Result.Model);
ModelBinding\Binders\ComplexObjectModelBinderTest.cs (2)
454Assert.Same(originalModel, bindingContext.Model); 1014Assert.Same(originalCollection, model.ReadOnlyList);
ModelBinding\Binders\ComplexTypeModelBinderTest.cs (3)
330Assert.Same(model, returnedPerson); 610Assert.Same(originalModel, bindingContext.Model); 1176Assert.Same(originalCollection, model.ReadOnlyList);
ModelBinding\Binders\DictionaryModelBinderTest.cs (1)
86Assert.Same(dictionary, bindingContext.Result.Model);
ModelBinding\Binders\HeaderModelBinderProviderTest.cs (4)
66Assert.Same(testBinder, headerModelBinder.InnerModelBinder); 89Assert.Same(testBinder, headerModelBinder.InnerModelBinder); 115Assert.Same(testBinder, headerModelBinder.InnerModelBinder); 159Assert.Same(testBinder, headerModelBinder.InnerModelBinder);
ModelBinding\Binders\HeaderModelBinderTests.cs (2)
248Assert.Same(expectedValueProvider, bindingContext.ValueProvider); 272Assert.Same(testValueProvider.Object, bindingContext.ValueProvider);
ModelBinding\Binders\SimpleTypeModelBinderTest.cs (2)
33Assert.Same(value, bindingContext.Result.Model); 61Assert.Same(value, bindingContext.Result.Model);
ModelBinding\BindingSourceValueProviderTest.cs (1)
72Assert.Same(valueProvider, result);
ModelBinding\CompositeValueProviderTest.cs (1)
134Assert.Same(valueProvider1.Object, filteredProvider);
ModelBinding\DefaultModelBindingContextTest.cs (7)
51Assert.Same(newModelMetadata.BinderModelName, bindingContext.BinderModelName); 52Assert.Same(newModelMetadata.BindingSource, bindingContext.BindingSource); 56Assert.Same(newModelMetadata, bindingContext.ModelMetadata); 58Assert.Same(originalValueProvider, bindingContext.ValueProvider); 82vp => Assert.Same(original[1], vp)); 110vp => Assert.Same(original[1], vp)); 139vp => Assert.Same(original[2], vp));
ModelBinding\EnumerableValueProviderTest.cs (1)
268Assert.Same(result, provider);
ModelBinding\FormFileValueProviderFactoryTest.cs (3)
71Assert.Same(exception, ex.InnerException); 85Assert.Same(exception, ex.InnerException); 99Assert.Same(exception, ex);
ModelBinding\FormValueProviderFactoryTest.cs (3)
59Assert.Same(exception, ex.InnerException); 73Assert.Same(exception, ex.InnerException); 87Assert.Same(exception, ex);
ModelBinding\JQueryFormValueProviderFactoryTest.cs (3)
144Assert.Same(exception, ex.InnerException); 158Assert.Same(exception, ex.InnerException); 172Assert.Same(exception, ex);
ModelBinding\Metadata\DefaultModelMetadataProviderTest.cs (15)
38Assert.Same(metadata1, metadata2); 39Assert.Same(metadata1.Attributes, metadata2.Attributes); 40Assert.Same(metadata1.BindingMetadata, metadata2.BindingMetadata); 41Assert.Same(metadata1.DisplayMetadata, metadata2.DisplayMetadata); 42Assert.Same(metadata1.ValidationMetadata, metadata2.ValidationMetadata); 56Assert.Same(metadata1, metadata2); 129Assert.Same(properties1[i], properties2[i]); 130Assert.Same(properties1[i].Attributes, properties2[i].Attributes); 131Assert.Same(properties1[i].BindingMetadata, properties2[i].BindingMetadata); 132Assert.Same(properties1[i].DisplayMetadata, properties2[i].DisplayMetadata); 133Assert.Same(properties1[i].ValidationMetadata, properties2[i].ValidationMetadata); 148Assert.Same(metadata1.Properties, metadata2.Properties); 261Assert.Same(metadata1, metadata2); 329Assert.Same(metadata1, metadata2); 412Assert.Same(metadata1, metadata2);
ModelBinding\Metadata\DefaultModelMetadataTest.cs (3)
499Assert.Same(expectedProperties[i], properties[i]); 701Assert.Same(SinglePropertiesEvaluation, secondPropertiesEvaluation); 893Assert.Same(value, validationFilter);
ModelBinding\Metadata\DefaultValidationMetadataProviderTest.cs (3)
124Assert.Same(attribute, validatorMetadata); 143Assert.Same(attribute, validatorMetadata); 163Assert.Same(attribute, validatorMetadata);
ModelBinding\Metadata\ModelBinderAttributeTest.cs (2)
36Assert.Same(BindingSource.Custom, source); 49Assert.Same(BindingSource.Custom, source);
ModelBinding\ModelBinderFactoryTest.cs (7)
277Assert.Same(result1, result2); 364Assert.Same(expectedInfo.PropertyFilterProvider, context.BindingInfo.PropertyFilterProvider); 386Assert.Same(modelBinder, result); 410Assert.Same(inner, binder); 472Assert.Same(inner, binder); 565Assert.Same(inner, result2); 629Assert.Same(inner, result2);
ModelBinding\ModelBindingHelperTest.cs (6)
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);
ModelBinding\ModelBindingResultTest.cs (1)
19Assert.Same(model, result.Model);
ModelBinding\ParameterBinderTest.cs (4)
345Assert.Same(model, result.Model); 400Assert.Same(model, result.Model); 455Assert.Same(model, result.Model); 509Assert.Same(model, result.Model);
ModelBinding\RouteValueProviderTests.cs (1)
248Assert.Same(result, provider);
ModelBinding\Validation\ClientValidatorCacheTest.cs (2)
32Assert.Same(validators1, validators2); 61Assert.Same(validator1, Assert.Single(validators2.OfType<RequiredAttributeAdapter>())); // cached
ModelBinding\Validation\DefaultCollectionValidationStrategyTest.cs (9)
29Assert.Same(metadata.ElementMetadata, e.Metadata); 35Assert.Same(metadata.ElementMetadata, e.Metadata); 41Assert.Same(metadata.ElementMetadata, e.Metadata); 69Assert.Same(metadata.ElementMetadata, e.Metadata); 75Assert.Same(metadata.ElementMetadata, e.Metadata); 81Assert.Same(metadata.ElementMetadata, e.Metadata); 104Assert.Same(metadata.ElementMetadata, e.Metadata); 110Assert.Same(metadata.ElementMetadata, e.Metadata); 116Assert.Same(metadata.ElementMetadata, e.Metadata);
ModelBinding\Validation\DefaultComplexObjectValidationStrategyTest.cs (12)
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);
ModelBinding\Validation\ExplicitIndexCollectionValidationStrategyTest.cs (13)
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);
ModelBinding\Validation\ShortFormDictionaryValidationStrategyTest.cs (7)
40Assert.Same(valueMetadata, e.Metadata); 46Assert.Same(valueMetadata, e.Metadata); 52Assert.Same(valueMetadata, e.Metadata); 87Assert.Same(valueMetadata, e.Metadata); 93Assert.Same(valueMetadata, e.Metadata); 128Assert.Same(valueMetadata, e.Metadata); 134Assert.Same(valueMetadata, e.Metadata);
ModelBinding\Validation\ValidatorCacheTest.cs (1)
32Assert.Same(validators1, validators2);
ProducesAttributeTests.cs (1)
140Assert.Same(personType, producesAttribute.Type);
ProducesResponseTypeAttributeTests.cs (1)
57Assert.Same(typeof(Person), producesResponseTypeAttribute.Type);
RedirectResultTest.cs (3)
46Assert.Same(url, result.Url); 61Assert.Same(url, result.Url); 76Assert.Same(url, result.Url);
Routing\ActionEndpointDataSourceBaseTest.cs (1)
62Assert.Same(endpoints1, endpoints2);
Routing\ActionEndpointFactoryTest.cs (1)
287Assert.Same(del, endpoint.RequestDelegate);
Routing\AttributeRouteTest.cs (1)
92Assert.Same(actions[1], selected);
Routing\ControllerActionEndpointDataSourceTest.cs (15)
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>());
Routing\DynamicControllerEndpointMatcherPolicyTest.cs (6)
189Assert.Same(ControllerEndpoints[0], candidates[0].Endpoint); 267Assert.Same(ControllerEndpoints[0], candidates[0].Endpoint); 288Assert.Same(State, kvp.Value); 388Assert.Same(State, kvp.Value); 433Assert.Same(ControllerEndpoints[1], candidates[0].Endpoint); 434Assert.Same(ControllerEndpoints[2], candidates[1].Endpoint);
Routing\UrlHelperTestBase.cs (8)
637Assert.Same(id, dictionary["ID"]); 638Assert.Same(isprint, dictionary["isprint"]); 682Assert.Same(action, dict["ACTION"]); 683Assert.Same(controller, dict["Controller"]); 684Assert.Same(id, dict["ID"]); 902Assert.Same(expectedUrlHelper, urlHelper); 921Assert.Same(urlHelper, actionContext.HttpContext.Items[typeof(IUrlHelper)] as IUrlHelper); 944Assert.Same(urlHelper, actionContext.HttpContext.Items[typeof(IUrlHelper)] as IUrlHelper);
Routing\ViewEnginePathTest.cs (2)
32Assert.Same(input, result); 47Assert.Same(input, result);
ServiceFilterAttributeTest.cs (1)
26Assert.Same(expected, filter);
TypeFilterAttributeTest.cs (6)
29Assert.Same(value, testFilter.Value); 30Assert.Same(uri, testFilter.Uri); 54Assert.Same(value, testFilter.Value); 55Assert.Same(uri, testFilter.Uri); 79Assert.Same(value, testFilter.Value); 80Assert.Same(uri, testFilter.Uri);
VirtualFileResultTest.cs (2)
61Assert.Same(webHostFileProvider, fileProvider); 78Assert.Same(fileProvider, actual);
Microsoft.AspNetCore.Mvc.Core.TestCommon (38)
CommonResourceInvokerTest.cs (38)
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);
Microsoft.AspNetCore.Mvc.DataAnnotations.Test (10)
DataAnnotationsClientModelValidatorProviderTest.cs (1)
66Assert.Same(expectedValidatorItem.Validator, validatorItem.Validator);
DataAnnotationsMetadataProviderTest.cs (5)
121Assert.Same(displayFormat.DataFormatString, context.DisplayMetadata.DisplayFormatString); 144Assert.Same(displayFormat.DataFormatString, context.DisplayMetadata.DisplayFormatString); 1534Assert.Same(attribute, validatorMetadata); 1555Assert.Same(attribute, validatorMetadata); 1576Assert.Same(attribute, validatorMetadata);
DataAnnotationsModelValidatorTest.cs (1)
32Assert.Same(attribute, validator.Attribute);
DataTypeClientModelValidatorProviderTest.cs (1)
57Assert.Same(expectedValidatorItem.Validator, validatorItem.Validator);
ModelMetadataProviderTest.cs (2)
637Assert.Same(typeof(ComplexObjectModelBinder), metadata.BinderType); 656Assert.Same(typeof(ComplexObjectModelBinder), metadata.BinderType);
Microsoft.AspNetCore.Mvc.Formatters.Xml.Test (6)
DelegatingEnumerableTest.cs (1)
52Assert.Same(errors[i], errorWrapper.SerializableError);
ProblemDetailsWrapperProviderFactoryTest.cs (2)
36Assert.Same(instance, wrapper.ProblemDetails); 53Assert.Same(instance, wrapper.ProblemDetails);
SerializableErrorWrapperProviderTest.cs (1)
36Assert.Same(serializableError, errorWrapper.SerializableError);
SerializableErrorWrapperTests.cs (1)
38Assert.Same(serializableError, wrapper.SerializableError);
XmlDataContractSerializerOutputFormatterTest.cs (1)
170Assert.Same(writerSettings, formatter.WriterSettings);
Microsoft.AspNetCore.Mvc.IntegrationTests (9)
TryUpdateModelIntegrationTest.cs (9)
44Assert.Same(oldModel, model); 187Assert.Same(oldModel, model); 269Assert.Same(collection, model.Address); 651Assert.Same(oldModel, model); 787Assert.Same(oldModel, model); 864Assert.Same(collection, model.Address); 1121Assert.Same(oldModel, model); 1189Assert.Same(oldModel, model); 1241Assert.Same(oldModel, model);
Microsoft.AspNetCore.Mvc.Localization.Test (2)
MvcLocalizationMvcBuilderExtensionsTest.cs (1)
122Assert.Same(dataAnnotationLocalizerProvider, actualOptions.Value.DataAnnotationLocalizerProvider);
MvcLocalizationMvcCoreBuilderExtensionsTest.cs (1)
122Assert.Same(dataAnnotationLocalizerProvider, actualOptions.Value.DataAnnotationLocalizerProvider);
Microsoft.AspNetCore.Mvc.NewtonsoftJson.Test (8)
DependencyInjection\NewtonsoftJsonMvcCoreBuilderExtensionsTest.cs (3)
45Assert.Same(typeof(NewtonsoftJsonHelper), jsonHelper.ImplementationType); 60Assert.Same(typeof(BsonTempDataSerializer), tempDataSerializer.ImplementationType); 75Assert.Same(typeof(NewtonsoftJsonResultExecutor), jsonResultExecutor.ImplementationType);
NewtonsoftJsonInputFormatterTest.cs (2)
148Assert.Same(serializerSettings, formatter.SerializerSettings); 192Assert.Same(settings.ContractResolver, actual.ContractResolver);
NewtonsoftJsonOutputFormatterTest.cs (1)
44Assert.Same(serializerSettings, jsonFormatter.SerializerSettings);
src\Mvc\Mvc.Core\test\Infrastructure\AsyncEnumerableReaderTest.cs (2)
79Assert.Same(reader1, reader2); 96Assert.Same(reader1, reader2);
Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation.Test (40)
CSharpCompilerTest.cs (2)
31Assert.Same(DependencyContextCompilationOptions.Default, options); 45Assert.Same(DependencyContextCompilationOptions.Default, options);
PageLoaderMatcherPolicyTest.cs (3)
31Assert.Same(compiled.Endpoint, candidateSet[0].Endpoint); 56Assert.Same(compiled.Endpoint, candidateSet[0].Endpoint); 84Assert.Same(compiled.Endpoint, candidateSet[0].Endpoint);
RuntimeViewCompilerTest.cs (35)
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);
Microsoft.AspNetCore.Mvc.Razor.Test (79)
ApplicationParts\RazorCompiledItemFeatureProviderTest.cs (3)
141Assert.Same(item.Item, item1); 145Assert.Same(typeof(TestReloadedPage), item.Item.Type); 146Assert.Same("Item2", item.Item.Identifier);
Compilation\DefaultRazorPageFactoryProviderTest.cs (1)
39Assert.Same(descriptor, result.ViewDescriptor);
Compilation\DefaultViewCompilerTest.cs (5)
41Assert.Same(compiledView, result); 65Assert.Same(precompiledView, result); 83Assert.Same(compiledView, result); 105Assert.Same(compiledView, result); 115Assert.Same(hotReloaded, result);
Compilation\RazorPagePropertyActivatorTest.cs (2)
190Assert.Same(original, viewDataDictionary); 214Assert.Same(original, viewDataDictionary);
DefaultTagHelperFactoryTest.cs (1)
46Assert.Same(viewDataValue, helper.ViewDataValue);
RazorPageActivatorTest.cs (20)
61Assert.Same(DiagnosticListener, instance.DiagnosticSource); 62Assert.Same(HtmlEncoder, instance.HtmlEncoder); 63Assert.Same(JsonHelper, instance.Json); 64Assert.Same(urlHelper, instance.Url); 65Assert.Same(viewContext.ViewData, instance.ViewData); 78Assert.Same(viewContext, service.ViewContext); 79Assert.Same(viewContext, keyedService.ViewContext); 99Assert.Same(DiagnosticListener, instance.DiagnosticSource); 100Assert.Same(HtmlEncoder, instance.HtmlEncoder); 126Assert.Same(DiagnosticListener, instance.DiagnosticSource); 127Assert.Same(HtmlEncoder, instance.HtmlEncoder); 128Assert.Same(JsonHelper, instance.Json); 129Assert.Same(urlHelper, instance.Url); 130Assert.Same(viewContext.ViewData, instance.ViewData); 150Assert.Same(viewContext, service.ViewContext); 151Assert.Same(viewContext, keyedService.ViewContext); 186Assert.Same(viewContext.ViewData, page.ViewData); 205Assert.Same(result1, result2); 220Assert.Same(result1, result2); 228Assert.Same(result3, result4);
RazorPageCreateModelExpressionTest.cs (2)
40Assert.Same(modelExplorer, modelExpression.ModelExplorer); 65Assert.Same(modelExplorer, modelExpression.ModelExplorer);
RazorPageTest.cs (8)
151Assert.Same(encoder, page.HtmlEncoder); 169Assert.Same(originalEncoder, page.HtmlEncoder); 225Assert.Same(originalWriter, page.Output); 940Assert.Same(HtmlString.Empty, actual); 1275Assert.Same(writer, page.ViewContext.Writer); 1292Assert.Same(writer, page.ViewContext.Writer); 1298Assert.Same(defaultWriter, poppedWriter); 1299Assert.Same(defaultWriter, page.ViewContext.Writer);
RazorViewEngineTest.cs (31)
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);
RazorViewTest.cs (5)
65Assert.Same(viewData, v.ViewContext.ViewData); 82Assert.Same(c, viewContext); 92Assert.Same(expectedWriter, viewContext.Writer); 103Assert.Same(viewData, v.ViewContext.ViewData); 125Assert.Same(c, viewContext);
TagHelpers\TagHelperComponentPropertyActivatorTest.cs (1)
28Assert.Same(viewContext, tagHelperComponent.ViewContext);
Microsoft.AspNetCore.Mvc.RazorPages.Test (241)
ApplicationModels\CompiledPageActionDescriptorBuilderTest.cs (21)
38Assert.Same(actionDescriptor.ActionConstraints, actual.ActionConstraints); 39Assert.Same(actionDescriptor.AttributeRouteInfo, actual.AttributeRouteInfo); 40Assert.Same(actionDescriptor.RelativePath, actual.RelativePath); 41Assert.Same(actionDescriptor.RouteValues, actual.RouteValues); 42Assert.Same(actionDescriptor.ViewEnginePath, actual.ViewEnginePath); 86Assert.Same(pageApplicationModel.PageType, actual.PageTypeInfo); 87Assert.Same(pageApplicationModel.DeclaredModelType, actual.DeclaredModelTypeInfo); 88Assert.Same(pageApplicationModel.ModelType, actual.ModelTypeInfo); 89Assert.Same(pageApplicationModel.HandlerType, actual.HandlerTypeInfo); 90Assert.Same(pageApplicationModel.Properties, actual.Properties); 174Assert.Same(globalFilters[0], filterDescriptor.Filter); 179Assert.Same(pageApplicationModel.Filters[0], filterDescriptor.Filter); 296Assert.Same(parameterModel2.BindingInfo, p.BindingInfo); 336Assert.Same(propertyModel.PropertyName, p.Name); 337Assert.Same(typeof(int), p.ParameterType); 338Assert.Same(propertyModel.PropertyInfo, p.Property); 339Assert.Same(propertyModel.BindingInfo, p.BindingInfo); 385Assert.Same(propertyModel1.PropertyName, p.Name); 386Assert.Same(typeof(int), p.ParameterType); 387Assert.Same(propertyModel1.PropertyInfo, p.Property); 388Assert.Same(propertyModel1.BindingInfo, p.BindingInfo);
ApplicationModels\DefaultPageApplicationModelProviderTest.cs (17)
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);
ApplicationModels\PageRouteTransformerConventionTest.cs (1)
24Assert.Same(transformer, model.RouteParameterTransformer);
DependencyInjection\MvcRazorPagesMvcBuilderExtensionsTest.cs (2)
37convention => Assert.Same(applicationModelConvention, convention), 38convention => Assert.Same(routeModelConvention, convention));
DependencyInjection\PageConventionCollectionExtensionsTest.cs (3)
37model => Assert.Same(filter, Assert.Single(model.Filters)), 38model => Assert.Same(filter, Assert.Single(model.Filters)), 39model => Assert.Same(filter, Assert.Single(model.Filters)));
Filters\AutoValidateAntiforgeryPageApplicationModelProviderTest.cs (2)
60actual => Assert.Same(expected, actual)); 85actual => Assert.Same(expected, actual));
Filters\PageSaveTempDataPropertyFilterFactoryTest.cs (1)
28Assert.Same(lifecycleProperties, pageFilter.Properties);
Filters\PageViewDataAttributeFilterFactoryTest.cs (1)
27Assert.Same(properties, filter.Properties);
Filters\PageViewDataAttributeFilterTest.cs (2)
33Assert.Same(filter, feature.Value); 51Assert.Same(handler, filter.Subject);
Infrastructure\CompiledPageActionDescriptorFactoryTest.cs (9)
24Assert.Same(model, m); 51Assert.Same(model, m); 58Assert.Same(model, m); 90Assert.Same(handlerModel, m); 117Assert.Same(handlerModel, m); 179Assert.Same(parameterModel, m); 210Assert.Same(parameterModel, m); 279Assert.Same(propertyModel, m); 310Assert.Same(propertyModel, m);
Infrastructure\DefaultPageFactoryProviderTest.cs (4)
62Assert.Same(pageContext, testPage.PageContext); 98Assert.Same(urlHelper, testPage.UrlHelper); 99Assert.Same(htmlEncoder, testPage.HtmlEncoder); 242Assert.Same(pageContext.ViewData, testPage.ViewData);
Infrastructure\DefaultPageHandlerMethodSelectorTest.cs (11)
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);
Infrastructure\DefaultPageLoaderTest.cs (6)
60Assert.Same(pageApplicationModel1, c.PageApplicationModel); 69Assert.Same(pageApplicationModel2, c.PageApplicationModel); 77Assert.Same(pageApplicationModel2, c.PageApplicationModel); 269Assert.Same(result1, result2); 351Assert.Same(pageDescriptor, result1); 352Assert.Same(pageDescriptor, result2);
Infrastructure\DefaultPageModelActivatorProviderTest.cs (1)
87Assert.Same(generator, modelWithServices.Generator);
Infrastructure\DefaultPageModelFactoryProviderTest.cs (3)
78Assert.Same(pageContext, testModel.ContextWithAttribute); 101Assert.Same(disposer, actual); 123Assert.Same(disposer, actual);
Infrastructure\DisallowOptionsRequestsPageFilterTest.cs (3)
39Assert.Same(expected, context.Result); 72Assert.Same(expected, context.Result); 106Assert.Same(expected, context.Result);
Infrastructure\DynamicPageEndpointMatcherPolicyTest.cs (6)
205Assert.Same(LoadedEndpoints[0], candidates[0].Endpoint); 246Assert.Same(LoadedEndpoints[0], candidates[0].Endpoint); 262Assert.Same(State, kvp.Value); 389Assert.Same(State, kvp.Value); 433Assert.Same(LoadedEndpoints[0], candidates[0].Endpoint); 434Assert.Same(LoadedEndpoints[1], candidates[1].Endpoint);
Infrastructure\PageActionDescriptorProviderTest.cs (1)
199Assert.Same(expected, actual);
Infrastructure\PageActionEndpointDataSourceTest.cs (5)
88Assert.Same(actions[0], e.Metadata.GetMetadata<ActionDescriptor>()); 158Assert.Same(actions[0], e.Metadata.GetMetadata<ActionDescriptor>()); 165Assert.Same(actions[1], e.Metadata.GetMetadata<ActionDescriptor>()); 208Assert.Same(actions[0], e.Metadata.GetMetadata<ActionDescriptor>()); 256Assert.Same(actions[0], e.Metadata.GetMetadata<ActionDescriptor>());
Infrastructure\PageActionInvokerProviderTest.cs (11)
68Assert.Same(factory, entry.PageFactory); 69Assert.Same(releaser, entry.ReleasePage); 133Assert.Same(factory, entry.PageFactory); 134Assert.Same(releaser, entry.ReleasePage); 135Assert.Same(modelFactory, entry.ModelFactory); 136Assert.Same(modelDisposer, entry.ReleaseModel); 140Assert.Same(compiledPageActionDescriptor, pageContext.ActionDescriptor); 141Assert.Same(context.ActionContext.HttpContext, pageContext.HttpContext); 142Assert.Same(context.ActionContext.ModelState, pageContext.ModelState); 143Assert.Same(context.ActionContext.RouteData, pageContext.RouteData); 241Assert.Same(entry1, entry2);
Infrastructure\PageActionInvokerTest.cs (54)
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);
Infrastructure\PageBinderFactoryTest.cs (6)
45Assert.Same(PageBinderFactory.NullPropertyBinder, factory); 71Assert.Same(PageBinderFactory.NullPropertyBinder, factory); 96Assert.Same(PageBinderFactory.NullPropertyBinder, factory); 122Assert.Same(PageBinderFactory.NullPropertyBinder, factory); 147Assert.Same(PageBinderFactory.NullPropertyBinder, factory); 173Assert.Same(PageBinderFactory.NullPropertyBinder, factory);
Infrastructure\ServiceBasedPageModelActivatorProviderTest.cs (1)
55Assert.Same(simpleModel, instance);
PageModelTest.cs (34)
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);
PageTest.cs (35)
42Assert.Same(pageContext, page.PageContext); 43Assert.Same(viewContext, page.ViewContext); 44Assert.Same(httpContext, page.HttpContext); 45Assert.Same(httpContext.Request, page.Request); 46Assert.Same(httpContext.Response, page.Response); 47Assert.Same(modelState, page.ModelState); 48Assert.Same(tempData, page.TempData); 65Assert.Same(url, result.Url); 82Assert.Same(url, result.Url); 99Assert.Same(url, result.Url); 116Assert.Same(url, result.Url); 163Assert.Same(url, result.Url); 180Assert.Same(url, result.Url); 197Assert.Same(url, result.Url); 214Assert.Same(url, result.Url); 895Assert.Same(routeName, resultTemporary.RouteName); 912Assert.Same(routeName, resultTemporary.RouteName); 929Assert.Same(routeName, resultPermanent.RouteName); 946Assert.Same(routeName, resultPermanent.RouteName); 966Assert.Same(routeName, resultTemporary.RouteName); 987Assert.Same(routeName, resultTemporary.RouteName); 1008Assert.Same(routeName, resultPermanent.RouteName); 1029Assert.Same(routeName, resultPermanent.RouteName); 1316Assert.Same(url, result.PageName); 1336Assert.Same(pageName, resultPermanent.PageName); 1357Assert.Same(routeName, resultPermanent.PageName); 1373Assert.Same(fileContents, result.FileContents); 1390Assert.Same(fileContents, result.FileContents); 1451Assert.Same(fileStream, result.FileStream); 1477Assert.Same(fileStream, result.FileStream); 1597Assert.Same(Encoding.UTF8, MediaType.GetEncoding(actualContentResult.ContentType)); 1778Assert.Same(viewData, result.ViewData); 1800Assert.Same(viewData, result.ViewData); 1825Assert.Same(arguments, result.Arguments); 1826Assert.Same(viewData, result.ViewData);
src\Mvc\Mvc.Core\test\Routing\ActionEndpointDataSourceBaseTest.cs (1)
62Assert.Same(endpoints1, endpoints2);
Microsoft.AspNetCore.Mvc.Routing.Abstractions.Tests (3)
VirtualPathDataTests.cs (3)
21Assert.Same(router, pathData.Router); 40Assert.Same(router, pathData.Router); 58Assert.Same(router, pathData.Router);
Microsoft.AspNetCore.Mvc.TagHelpers.Test (13)
DefaultTagHelperActivatorTest.cs (6)
35Assert.Same(CacheProvider.Cache, scriptTagHelper.Cache); 36Assert.Same(HostingEnvironment, scriptTagHelper.HostingEnvironment); 37Assert.Same(FileVersionProvider, scriptTagHelper.FileVersionProvider); 49Assert.Same(CacheProvider.Cache, linkTagHelper.Cache); 50Assert.Same(HostingEnvironment, linkTagHelper.HostingEnvironment); 51Assert.Same(FileVersionProvider, linkTagHelper.FileVersionProvider);
PartialTagHelperTest.cs (5)
34Assert.Same(expectedModel, model); 82Assert.Same(expectedModel, model); 101Assert.Same(expectedModel, model); 333Assert.Same(expected, actual); 466Assert.Same(model, v.ViewData.Model);
SelectTagHelperTest.cs (2)
623Assert.Same(currentValues, actualCurrentValues.Values); 699Assert.Same(currentValues, actualCurrentValues.Values);
Microsoft.AspNetCore.Mvc.Test (1)
MvcServiceCollectionExtensionsTest.cs (1)
389Assert.Same(manager, descriptor.ImplementationInstance);
Microsoft.AspNetCore.Mvc.ViewFeatures.Test (194)
Buffers\ViewBufferTest.cs (5)
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]);
CachedExpressionCompilerTest.cs (15)
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);
ControllerTest.cs (33)
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);
ControllerUnitTestabilityTests.cs (18)
32Assert.Same(model, viewResult.Model); 33Assert.Same(model, viewResult.ViewData.Model); 34Assert.Same(controller.ViewData, viewResult.ViewData); 35Assert.Same(controller.TempData, viewResult.TempData); 54Assert.Same(model, viewResult.Model); 55Assert.Same(model, viewResult.ViewData.Model); 56Assert.Same(controller.ViewData, viewResult.ViewData); 57Assert.Same(controller.TempData, viewResult.TempData); 202Assert.Same(model, jsonResult.Value); 234Assert.Same(model, jsonResult.Value); 302Assert.Same(error, httpBadRequest.Value); 337Assert.Same(value, createdAtRouteResult.Value); 373Assert.Same(value, acceptedAtRouteResult.Value); 411Assert.Same(value, createdAtActionResult.Value); 450Assert.Same(value, acceptedAtActionResult.Value); 611Assert.Same(httpContext, controller.HttpContext); 612Assert.Same(routeData, controller.RouteData); 614Assert.Same(actionDescriptor, controllerContext.ActionDescriptor);
CookieTempDataProviderTest.cs (2)
111Assert.Same(Dictionary, actualValues); 310Assert.Same(Dictionary, tempData);
ExpressionHelperTest.cs (2)
387Assert.Same(text1, text2); // cached 417Assert.Same(text1, text2); // cached
ExpressionMetadataProviderTest.cs (2)
109Assert.Same(myModel, metadata.Container.Model); 152Assert.Same(myModel, metadata.Container.Model);
Filters\ControllerSaveTempDataPropertyFilterFactoryTest.cs (1)
24Assert.Same(lifecycleProperties, tempDataFilter.Properties);
Filters\ControllerViewDataAttributeFilterFactoryTest.cs (1)
26Assert.Same(properties, filter.Properties);
Filters\ControllerViewDataAttributeFilterTest.cs (2)
29Assert.Same(filter, feature.Value); 46Assert.Same(controller, filter.Subject);
Filters\TempDataApplicationModelProviderTest.cs (2)
81Assert.Same(expected, property.PropertyInfo); 102Assert.Same(expected, property.PropertyInfo);
Filters\ViewDataAttributeApplicationModelProviderTest.cs (1)
61Assert.Same(expected, property.PropertyInfo);
HtmlAttributePropertyHelperTest.cs (2)
83Assert.Same(helpers1, helpers2); 84Assert.Same(helpers1[0], helpers2[0]);
ModelExplorerTest.cs (3)
54Assert.Same(modelExplorer, baseProperty.Container); 59Assert.Same(modelExplorer, derivedProperty.Container); 78Assert.Same(modelExplorer, baseProperty.Container);
ModelStateDictionaryExtensionsTest.cs (13)
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);
PartialViewResultTest.cs (1)
38Assert.Same(customModel, viewResult.Model);
Rendering\HtmlHelperPartialExtensionsTest.cs (8)
60Assert.Same(htmlContent, result); 86Assert.Same(expected, actual); 134Assert.Same(htmlContent, result); 177Assert.Same(expected, actual); 281Assert.Same(expected, actual); 300Assert.Same(expected, actual); 326Assert.Same(expected, actual); 346Assert.Same(expected, actual);
Rendering\HtmlHelperSelectTest.cs (2)
1338Assert.Same(htmlHelper.SelectListItems, result); // No replacement of the underlying List 1398Assert.Same(htmlHelper.SelectListItems, result); // No replacement of the underlying List
Rendering\HtmlHelperTest.cs (1)
305Assert.Same(helperToContextualize.ViewContext, viewContext);
Rendering\ViewContextTests.cs (13)
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);
SessionStateTempDataProviderTest.cs (1)
70Assert.Same(Dictionary, result);
TempDataDictionaryFactoryTest.cs (1)
43Assert.Same(tempData1, tempData2);
TempDataDictionaryTest.cs (1)
140Assert.Same(item, value);
ViewComponentResultTest.cs (1)
47Assert.Same(customModel, viewResult.Model);
ViewComponents\DefaultViewComponentActivatorTests.cs (2)
35Assert.Same(context, instance.ViewComponentContext); 59Assert.Same(context, instance.ViewComponentContext);
ViewComponents\DefaultViewComponentFactoryTest.cs (2)
31Assert.Same(component, activablePropertiesComponent); 32Assert.Same(component.Context, activablePropertiesComponent.Context);
ViewComponents\DefaultViewComponentHelperTest.cs (1)
112Assert.Same(expectedValue, item.Value);
ViewComponents\DefaultViewComponentSelectorTest.cs (9)
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);
ViewComponents\ViewComponentContextTest.cs (7)
46Assert.Same(tempData, viewComponentContext.TempData); 47Assert.Same(viewContext.View, viewComponentContext.ViewContext.View); 48Assert.Same(viewContext.Writer, viewComponentContext.ViewContext.Writer); 51Assert.Same(viewComponentContext.ViewContext.ViewData, viewComponentContext.ViewData); 52Assert.Same(viewComponentContext.ViewContext.TempData, viewComponentContext.TempData); 53Assert.Same(viewComponentContext.ViewContext.Writer, viewComponentContext.Writer); 57Assert.Same(viewData.ModelMetadata, viewComponentContext.ViewData.ModelMetadata);
ViewComponents\ViewViewComponentResultTest.cs (1)
294Assert.Same(expected, actual);
ViewComponentTests.cs (6)
62Assert.Same(expectedContent, actualResult.Content); 97Assert.Same(model, actualResult.ViewData.Model); 135Assert.Same(model, actualResult.ViewData.Model); 213Assert.Same(model, actualResult.ViewData.Model); 233Assert.Same(viewComponent.ViewData, viewComponent.ViewContext.ViewData); 254Assert.Same(viewComponent.TempData, viewComponent.ViewContext.TempData);
ViewDataDictionaryOfTModelTest.cs (14)
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);
ViewDataDictionaryTest.cs (13)
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);
ViewDataOfTTest.cs (1)
46Assert.Same(value, viewDataOfT.Model);
ViewEngines\CompositeViewEngineTest.cs (6)
89Assert.Same(view, result.View); 123Assert.Same(view2, result.View); 224Assert.Same(view, result.View); 261Assert.Same(view2, result.View); 356Assert.Same(view, result.View); 390Assert.Same(view2, result.View);
ViewResultTest.cs (1)
48Assert.Same(customModel, viewResult.Model);
Microsoft.AspNetCore.OpenApi.Tests (3)
Transformers\OpenApiOptionsTests.cs (3)
42Assert.Same(transformer, insertedTransformer); 99Assert.Same(transformer, insertedTransformer); 156Assert.Same(transformer, insertedTransformer);
Microsoft.AspNetCore.Owin.Tests (4)
OwinEnvironmentTests.cs (4)
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);
Microsoft.AspNetCore.Razor.Runtime.Test (8)
Runtime\TagHelpers\TagHelperExecutionContextTest.cs (6)
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]);
Runtime\TagHelpers\TagHelperRunnerTest.cs (1)
203Assert.Same(tagHelper.ContextProcessedWith.Items, executionContext.Items);
Runtime\TagHelpers\TagHelperScopeManagerTest.cs (1)
60Assert.Same(parentComplexObject, executionContextItem.Value);
Microsoft.AspNetCore.Razor.Test (9)
TagHelpers\TagHelperContextTest.cs (3)
38Assert.Same(expectedItems, context.Items); 62Assert.Same(expectedItems, context.Items); 85Assert.Same(expectedItems, context.Items);
TagHelpers\TagHelperOutputTest.cs (6)
86Assert.Same(content, result); 127Assert.Same(encoder, passedEncoder); 128Assert.Same(content, result); 157Assert.Same(content, result); 201Assert.Same(encoder, passedEncoder); 202Assert.Same(content, result);
Microsoft.AspNetCore.ResponseCaching.Tests (2)
CachedResponseBodyTests.cs (1)
21Assert.Same(segments, body.Segments);
ResponseCachingMiddlewareTests.cs (1)
571Assert.Same(cachedVaryByRules, context.CachedVaryByRules);
Microsoft.AspNetCore.Routing.Tests (357)
Builder\EndpointRoutingApplicationBuilderExtensionsTest.cs (2)
106Assert.Same(endpoint, httpContext.GetEndpoint()); 341Assert.Same(local, global);
Builder\GroupTest.cs (1)
198Assert.Same(serviceProvider, endpointBuilderServiceProvider);
Builder\RequestDelegateEndpointRouteBuilderExtensionsTest.cs (2)
257Assert.Same(Results.Empty, response); 343Assert.Same(initialRequestDelegate, endpoint.RequestDelegate);
CompositeEndpointDataSourceTest.cs (21)
77Assert.Same(ex, Assert.Throws<Exception>(() => compositeDataSource.Endpoints)); 78Assert.Same(ex, Assert.Throws<Exception>(() => compositeDataSource.Endpoints)); 79Assert.Same(ex, Assert.Throws<Exception>(() => compositeDataSource.GetGroupedEndpoints(groupContext))); 80Assert.Same(ex, Assert.Throws<Exception>(() => compositeDataSource.GetGroupedEndpoints(groupContext))); 105(ep) => Assert.Same(endpoint1, ep), 106(ep) => Assert.Same(endpoint2, ep), 107(ep) => Assert.Same(endpoint3, ep), 108(ep) => Assert.Same(endpoint4, ep), 109(ep) => Assert.Same(endpoint5, ep)); 125Assert.Same(endpoint1, endpoint); 136(ep) => Assert.Same(endpoint1, ep), 137(ep) => Assert.Same(endpoint2, ep)); 148(ep) => Assert.Same(endpoint1, ep), 149(ep) => Assert.Same(endpoint2, ep), 150(ep) => Assert.Same(endpoint3, ep)); 307Assert.Same(context, receivedContext); 312m => Assert.Same(metadata, m), 353Assert.Same(context, receivedContext); 408Assert.Same(context, receivedContext); 473receivedContext => Assert.Same(context, receivedContext), 474receivedContext => Assert.Same(context, receivedContext));
DecisionTreeBuilderTest.cs (5)
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));
DefaultLinkGeneratorTest.cs (1)
578Assert.Same(expected, actual);
DefaultLinkParserTest.cs (2)
133Assert.Same(expected.Matcher, actual.Matcher); 134Assert.Same(expected.Constraints, actual.Constraints);
EndpointNameAddressSchemeTest.cs (5)
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));
Matching\CandidateSetTest.cs (18)
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);
Matching\DataSourceDependentMatcherTest.cs (2)
51e => Assert.Same(endpoint, e)); 137Assert.Same(endpoint, Assert.Single(inner.Endpoints));
Matching\DefaultEndpointSelectorTest.cs (4)
68Assert.Same(endpoints[0], httpContext.GetEndpoint()); 89Assert.Same(endpoints[1], httpContext.GetEndpoint()); 111Assert.Same(endpoints[1], httpContext.GetEndpoint()); 142Assert.Same(endpoints[4], httpContext.GetEndpoint());
Matching\DfaMatcherBuilderTest.cs (115)
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);
Matching\DfaMatcherTest.cs (21)
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());
Matching\EndpointComparerTest.cs (10)
210e => Assert.Same(endpoint1, e), 211e => Assert.Same(endpoint2, e), 212e => Assert.Same(endpoint3, e), 213e => Assert.Same(endpoint4, e), 214e => Assert.Same(endpoint5, e), 215e => Assert.Same(endpoint6, e), 216e => Assert.Same(endpoint7, e)); 237e => Assert.Same(endpoint1, e), 238e => Assert.Same(endpoint2, e), 239e => Assert.Same(endpoint3, e));
Matching\EndpointMetadataComparerTest.cs (2)
81e => Assert.Same(endpoint1, e), 82e => Assert.Same(endpoint2, e));
Matching\HttpMethodMatcherPolicyIntegrationTestBase.cs (3)
79Assert.Same(HttpMethodMatcherPolicy.Http405EndpointDisplayName, httpContext.GetEndpoint().DisplayName); 199Assert.Same(HttpMethodMatcherPolicy.Http405EndpointDisplayName, httpContext.GetEndpoint().DisplayName); 309Assert.Same(HttpMethodMatcherPolicy.Http405EndpointDisplayName, httpContext.GetEndpoint().DisplayName);
Patterns\DefaultRoutePatternTransformerTest.cs (3)
170Assert.Same(actual.Defaults, original.Defaults); 171Assert.Same(actual.Parameters, original.Parameters); 172Assert.Same(actual.PathSegments, original.PathSegments);
Patterns\RoutePatternFactoryTest.cs (14)
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]);
RequestDelegateRouteBuilderExtensionsTest.cs (1)
62Assert.Same(NullHandler, context.Handler);
RouteBuilderTest.cs (3)
28Assert.Same(applicationBuilder, builder.ApplicationBuilder); 29Assert.Same(defaultHandler, builder.DefaultHandler); 30Assert.Same(applicationServices, builder.ServiceProvider);
RouteCollectionTest.cs (8)
53Assert.Same(target.Object, pathData.Router); 81Assert.Same(target.Object, pathData.Router); 119Assert.Same(target.Object, pathData.Router); 148Assert.Same(route, pathData.Router); 183Assert.Same(route1.Object, context.RouteData.Routers[0]); 209Assert.Same(route2.Object, context.RouteData.Routers[0]); 394Assert.Same(route, pathData.Router); 449Assert.Same(expectedRouteToMatch, ((INamedRouter)pathData.Router).Name);
RouteConstraintBuilderTest.cs (1)
50Assert.Same(originalConstraint, kvp.Value);
RouteEndpointBuilderTest.cs (1)
46m => Assert.Same(metadata, m),
RouteOptionsTests.cs (3)
48Assert.Same(endpoint1, result); 55ep => Assert.Same(endpoint1, ep), 56ep => Assert.Same(endpoint2, ep));
RouterMiddlewareTest.cs (1)
47Assert.Same(routingFeature.RouteData, context.GetRouteData());
RouteTest.cs (38)
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);
RouteValuesAddressSchemeTest.cs (18)
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);
Tree\LinkGenerationDecisionTreeTest.cs (21)
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); });
Tree\TreeRouterTest.cs (31)
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);
Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (10)
DelegateTests.cs (1)
36Assert.Same(server, delegationFeature);
RequestTests.cs (1)
86Assert.Same(customHeaders, requestInfo.Headers);
ResponseBodyTests.cs (3)
326Assert.Same(state, httpContext); 354Assert.Same(state, httpContext); 382Assert.Same(state, httpContext);
ResponseSendFileTests.cs (1)
287Assert.Same(state, httpContext);
ResponseTests.cs (4)
137Assert.Same(state, httpContext); 143Assert.Same(state, httpContext); 172Assert.Same(state, httpContext); 201Assert.Same(state, httpContext);
Microsoft.AspNetCore.Server.Kestrel.Core.Tests (102)
BodyControlTests.cs (13)
28Assert.Same(ex, 30Assert.Same(ex, 47Assert.Same(ex, 50Assert.Same(ex, 53Assert.Same(ex, 73Assert.Same(ex, 76Assert.Same(ex, 78Assert.Same(ex, 94Assert.Same(ex, 96Assert.Same(ex, 98Assert.Same(ex, 100Assert.Same(ex, 102Assert.Same(ex,
CertificatePathWatcherTests.cs (1)
62Assert.Same(changeToken, watcher.GetChangeToken());
ConcurrentPipeWriterTests.cs (5)
76Assert.Same(completeEx, mockPipeWriter.CompleteException); 174Assert.Same(completeEx, mockPipeWriter.CompleteException); 258Assert.Same(completeEx, mockPipeWriter.CompleteException); 326Assert.Same(completeEx, mockPipeWriter.CompleteException); 409Assert.Same(completeEx, mockPipeWriter.CompleteException);
Http1\Http1ConnectionTests.cs (11)
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);
Http1\Http1HttpProtocolFeatureCollectionTests.cs (15)
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);
HttpRequestHeadersTests.cs (7)
109Assert.Same(Array.Empty<string>(), (string[])headers["custom"]); 110Assert.Same(Array.Empty<string>(), (string[])headers["host"]); 111Assert.Same(Array.Empty<string>(), (string[])headers["Content-Length"]); 114Assert.Same(Array.Empty<string>(), (string[])headers.Host); 115Assert.Same(Array.Empty<string>(), (string[])headers.AltSvc); 171Assert.Same(enumerator0, enumerator1); 432Assert.Same(values.PrevHeaderValue, values.NextHeaderValue);
HttpRequestPipeReaderTests.cs (1)
42Assert.Same(error, exception);
HttpRequestStreamTests.cs (2)
151Assert.Same(error, exception); 185Assert.Same(error, exception);
HttpUtilitiesTest.cs (1)
134Assert.Same(knownString1, knownString2);
KestrelServerTests.cs (5)
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)));
ListenOptionsTests.cs (1)
47Assert.Same(serviceProvider, clone.ApplicationServices);
MessageBodyTests.cs (1)
568Assert.Same(MessageBody.ZeroContentLengthKeepAlive, result);
ReasonPhrasesTests.cs (1)
37Assert.Same(bytes, bytesCached);
SniOptionsSelectorTests.cs (14)
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);
StartLineTests.cs (24)
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);
Microsoft.AspNetCore.Server.Kestrel.Tests (8)
KestrelConfigurationLoaderTests.cs (2)
1525Assert.Same(endpointsToStart[0], serverOptions.ConfigurationBackedListenOptions[1]); 1526Assert.Same(endpointsToStart[1], serverOptions.ConfigurationBackedListenOptions[2]);
WebHostBuilderKestrelExtensionsTests.cs (6)
153Assert.Same(memoryPoolFactory, host.Services.GetRequiredService<IOptions<SocketTransportOptions>>().Value.MemoryPoolFactory); 166Assert.Same(memoryPoolFactory, host.Services.GetRequiredService<IOptions<SocketTransportOptions>>().Value.MemoryPoolFactory); 182Assert.Same(memoryPoolFactory, host.Services.GetRequiredService<IOptions<SocketTransportOptions>>().Value.MemoryPoolFactory); 199Assert.Same(memoryPoolFactory, host.Services.GetRequiredService<IOptions<NamedPipeTransportOptions>>().Value.MemoryPoolFactory); 212Assert.Same(memoryPoolFactory, host.Services.GetRequiredService<IOptions<NamedPipeTransportOptions>>().Value.MemoryPoolFactory); 229Assert.Same(memoryPoolFactory, host.Services.GetRequiredService<IOptions<NamedPipeTransportOptions>>().Value.MemoryPoolFactory);
Microsoft.AspNetCore.Server.Kestrel.Transport.Quic.Tests (5)
QuicConnectionContextTests.cs (4)
527Assert.Same(stream1, pooledStream); 539Assert.Same(stream1, pooledStream); 542Assert.Same(stream1, stream2); 732Assert.Same(quicStreamContext1, quicStreamContext2);
QuicStreamContextTests.cs (1)
244Assert.Same(stream1, stream2);
Microsoft.AspNetCore.Shared.Tests (27)
AdaptiveCapacityDictionaryTests.cs (7)
83Assert.Same(StringComparer.OrdinalIgnoreCase, dict.Comparer); 890Assert.Same(value, removedValue); 910Assert.Same(value, removedValue); 932Assert.Same(value, removedValue); 957Assert.Same(value, removedValue); 982Assert.Same(value, removedValue); 1319Assert.Same(Array.Empty<KeyValuePair<string, object?>>(), value._arrayStorage);
CopyOnWriteDictionaryHolderTest.cs (1)
36Assert.Same(source, holder.ReadDictionary);
CopyOnWriteDictionaryTest.cs (2)
51Assert.Same(values, copyOnWriteDictionary.Values); 53Assert.Same(enumerator, copyOnWriteDictionary.GetEnumerator());
ObjectMethodExecutorTest.cs (15)
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);
PropertyHelperTest.cs (2)
119Assert.Same(helpers1, helpers2); 120Assert.Same(helpers1[0], helpers2[0]);
Microsoft.AspNetCore.SignalR.Client.Tests (33)
HttpConnectionTests.cs (3)
111Assert.Same(clientCertificate, httpClientHandler.ClientCertificates[0]); 113Assert.Same(httpOptions.Proxy, httpClientHandler.Proxy); 114Assert.Same(httpOptions.Credentials, httpClientHandler.Credentials);
HubConnectionBuilderExtensionsTests.cs (2)
72Assert.Same(proxy, value.Proxy); 87Assert.Same(proxy, value.Proxy);
HubConnectionTests.cs (4)
41Assert.Same(exception, actualException); 56Assert.Same(exception, actualException); 799Assert.Same(originalOptions.AccessTokenProvider, accessTokenFactory); 800Assert.Same(resolvedOptions.Headers, originalOptions.Headers);
HubConnectionTests.Reconnect.cs (24)
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);
Microsoft.AspNetCore.SignalR.Common.Tests (2)
Internal\Protocol\JsonHubProtocolTestsBase.cs (1)
209Assert.Same(Array.Empty<string>(), (message as InvocationMessage).StreamIds);
Internal\Protocol\Utf8BufferTextWriterTests.cs (1)
244Assert.Same(textWriter1, textWriter2);
Microsoft.AspNetCore.SignalR.StackExchangeRedis.Tests (2)
RedisProtocolTests.cs (2)
166Assert.Same(_testMessage.Target, invocation.Target); 167Assert.Same(_testMessage.Arguments, invocation.Arguments);
Microsoft.AspNetCore.SignalR.Tests (23)
ClientProxyTests.cs (9)
39Assert.Same(data, arg); 60Assert.Same(data, arg); 81Assert.Same(data, arg); 102Assert.Same(data, arg); 123Assert.Same(data, arg); 144Assert.Same(data, arg); 165Assert.Same(data, arg); 186Assert.Same(data, arg); 207Assert.Same(data, arg);
DefaultHubActivatorTests.cs (1)
34Assert.Same(hub,
HubConnectionHandlerTestUtils\Hubs.cs (1)
1418Assert.Same(service, service2);
Internal\DefaultHubProtocolResolverTests.cs (2)
84Assert.Same(jsonProtocol2, resolvedProtocol); 100Assert.Same(jsonProtocol2, hubProtocols[0]);
Internal\TypedClientBuilderTests.cs (5)
28Assert.Same(objArg, send.Arguments[2]); 52Assert.Same(objArg, send.Arguments[2]); 79arg3 => Assert.Same(objArg, arg3)); 221arg2 => Assert.Same(objArg, arg2), 222arg3 => Assert.Same("test", arg3));
SerializedHubMessageTests.cs (2)
26actualMessage => Assert.Same(invocation, actualMessage)); 46actualMessage => Assert.Same(invocation, actualMessage));
WebSocketsTransportTests.cs (3)
55Assert.Same(clientCertificate, webSocketsOptions.ClientCertificates[0]); 57Assert.Same(httpOptions.Proxy, webSocketsOptions.Proxy); 58Assert.Same(httpOptions.Credentials, webSocketsOptions.Credentials);
Microsoft.AspNetCore.TestHost.Tests (1)
TestClientTests.cs (1)
935Assert.Same(value, capturedValue);
Microsoft.AspNetCore.Tests (15)
WebApplicationTests.cs (15)
188Assert.Same(app.Urls, urls); 206Assert.Same(app.Urls, urls); 300Assert.Same(hostedService, startOrder[0]); 301Assert.Same(server, startOrder[1]); 1213Assert.Same(builder.Configuration, app.Configuration); 1256Assert.Same(builder.Configuration, app.Configuration); 1282Assert.Same(builder.Configuration, app.Configuration); 1390Assert.Same(config, builder.Configuration); 1394Assert.Same(app.Configuration, builder.Configuration); 1407Assert.Same(config, builder.Configuration); 1411Assert.Same(app.Configuration, builder.Configuration); 2522Assert.Same(builder.Host.Properties, iHostApplicationBuilder.Properties); 2523Assert.Same(builder.Configuration, iHostApplicationBuilder.Configuration); 2524Assert.Same(builder.Logging, iHostApplicationBuilder.Logging); 2525Assert.Same(builder.Services, iHostApplicationBuilder.Services);
Microsoft.AspNetCore.WebSockets.Tests (3)
WebSocketMiddlewareTests.cs (3)
728Assert.Same(HeaderNames.Upgrade, context.Request.Headers.Connection.ToString()); 729Assert.Same(Constants.Headers.UpgradeWebSocket, context.Request.Headers.Upgrade.ToString()); 730Assert.Same(Constants.Headers.SupportedVersion, context.Request.Headers.SecWebSocketVersion.ToString());
Microsoft.Build.Engine.OM.UnitTests (36)
Construction\ProjectRootElement_Tests.cs (2)
1311Assert.Same(xml0, xml1); 1312Assert.Same(xml0, xml2);
Definition\ProjectCollection_Tests.cs (6)
1180Assert.Same(collection, sender); 1338Assert.Same(collection, sender); 1339Assert.Same(pre, e.ProjectXml); 1397Assert.Same(collection, sender); 1398Assert.Same(project, e.Project); 1488Assert.Same(collection, sender);
Definition\ProjectItem_Tests.cs (2)
1999Assert.Same(projectItem, project.GetItemsByEvaluatedInclude(projectItem.EvaluatedInclude).Single()); 2005Assert.Same(projectItem, project.GetItemsByEvaluatedInclude(projectItem.EvaluatedInclude).Single());
Instance\ProjectInstance_Tests.cs (1)
138Assert.Same(returned, item);
ObjectModelRemoting\Helpers\ViewValidation.construction.cs (4)
36Assert.Same(c1Where, c1.Get(where)); 65Assert.Same(c1Where, c1.Get(where)); 436Assert.Same(realChild.Parent, realXml); 444Assert.Same(viewChild.Parent, viewXml);
ObjectModelRemoting\Helpers\ViewValidation.evaluation.cs (10)
35Assert.Same(result, this.GetSingleItemWithVerify(where, result.EvaluatedInclude)); 86Assert.Same(added, toAdd.GetProperty(name)); 123Assert.Same(context.Pair.View, view.Project); 124Assert.Same(context.Pair.Real, real.Project); 156Assert.Same(context?.Pair.View, view.Project); 157Assert.Same(context?.Pair.Real, real.Project); 200Assert.Same(context?.Pair.View, view.Project); 201Assert.Same(context?.Pair.Real, real.Project); 250Assert.Same(context.Pair.View, view.Project); 251Assert.Same(context.Pair.Real, real.Project);
ObjectModelRemoting\LinkedConstructionModify_Tests.cs (7)
376Assert.Same(choose.View, chooseCreataed.View); 392Assert.Same(otherWise.View, choose.View.OtherwiseElement); 393Assert.Same(otherWise.Real, choose.Real.OtherwiseElement); 501Assert.Same(body.View, usingTaskFile.View.TaskBody); 502Assert.Same(body.Real, usingTaskFile.Real.TaskBody); 506Assert.Same(pg.View, usingTaskFile.View.ParameterGroup); 507Assert.Same(pg.Real, usingTaskFile.Real.ParameterGroup);
ObjectModelRemoting\LinkedProjectCollection_Tests.cs (4)
46Assert.Same(proj1, loadedLocal.FirstOrDefault()); 47Assert.Same(proj2, loadedRemote.FirstOrDefault()); 56Assert.Same(localProj, proj1); 99Assert.Same(proj0local, prj0Coll.First());
Microsoft.Build.Engine.UnitTests (15)
BackEnd\BuildManager_Tests.cs (2)
2131Assert.Same(preRoot, ProjectRootElement.TryOpen(rootProjectPath, projectCollection)); // "The root project file should be in the weak cache after a build." 2132Assert.Same(preImported, ProjectRootElement.TryOpen(importedProjectPath, projectCollection)); // "The imported project file should be in the weak cache after a build."
BackEnd\BuildRequestConfiguration_Tests.cs (1)
190Assert.Same(config1.Project, projectInstance);
Evaluation\Evaluator_Tests.cs (1)
1730Assert.Same(metadataElementFromProjectRootElement, metadatum.Predecessor.Xml);
Evaluation\ProjectRootElementCache_Tests.cs (1)
75Assert.Same(projectRootElement, projectRootElement2);
Evaluation\UsedUninitializedProperties_Tests.cs (2)
32Assert.Same(location1, elementLocation); 35Assert.Same(location1, elementLocation);
Globbing\CompositeGlob_Tests.cs (3)
156Assert.Same(glob, composite); 168Assert.Same(glob1, composite.Globs.First()); 169Assert.Same(glob2, composite.Globs.Skip(1).First());
Globbing\MSBuildGlob_Tests.cs (1)
161Assert.Same(glob1.TestOnlyRegex, glob2.TestOnlyRegex);
Instance\HostServices_Tests.cs (4)
48Assert.Same(hostObject, hostServices.GetHostObject("foo.proj", "target", "task")); 49Assert.Same(hostObject2, hostServices.GetHostObject("foo.proj", "target2", "task")); 50Assert.Same(hostObject3, hostServices.GetHostObject("foo.proj", "target", "task2")); 101Assert.Same(hostObject, hostServices.GetHostObject("project", "target", "task"));
Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests (4)
GeneratorDriverCacheTests.cs (4)
31Assert.Same(driver, drivers[0]); 45Assert.Same(driver, drivers[0]); 48Assert.Same(driver, drivers[1]); 51Assert.Same(driver, drivers[2]);
Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (8)
Completion\CompletionProviders\ConversionCompletionProviderTests.cs (1)
64Assert.Same(c, castCompletionItem);
EditAndContinue\ActiveStatementTrackingServiceTests.cs (2)
72Assert.Same(snapshot1, document1.GetTextSynchronously(CancellationToken.None).FindCorrespondingEditorTextSnapshot()); 73Assert.Same(snapshot2, document2.GetTextSynchronously(CancellationToken.None).FindCorrespondingEditorTextSnapshot());
EditorConfigSettings\Updater\SettingsUpdaterTests.cs (1)
59Assert.Same(text, actualText);
SymbolKey\SymbolKeyTests.cs (4)
51Assert.Same(type, resolved); 90Assert.Same(type, resolved); 96Assert.Same(type, resolved); 126Assert.Same(type, resolved);
Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (32)
CodeGen\CodeGenDeconstructTests.cs (9)
3582Assert.Same(symbol, model.GetDeclaredSymbol((SyntaxNode)decl)); 3583Assert.Same(symbol, model.LookupSymbols(decl.SpanStart, name: decl.Identifier.ValueText).Single()); 3602Assert.Same(symbol, model.GetSymbolInfo(reference).Symbol); 3603Assert.Same(symbol, model.LookupSymbols(reference.SpanStart, name: decl.Identifier.ValueText).Single()); 3614Assert.Same(field, model.GetDeclaredSymbol((SyntaxNode)decl)); 3615Assert.Same(field, model.LookupSymbols(decl.SpanStart, name: decl.Identifier.ValueText).Single()); 3621Assert.Same(field, model.GetSymbolInfo(reference).Symbol); 3622Assert.Same(field, model.LookupSymbols(reference.SpanStart, name: decl.Identifier.ValueText).Single()); 6054Assert.Same(symbol.Type, symbolClone.Type); // original symbol for System.Int32 has identity.
CodeGen\CodeGenLocalFunctionTests.cs (1)
163Assert.Same(localFunctionOperation.IgnoredBody, objectCreationOperation.Parent.Parent);
CodeGen\CodeGenTupleTest.cs (21)
3699Assert.Same(yType.TupleElements[1], yType.TupleElements[1].CorrespondingTupleField); 4507Assert.Same(vt2, unnamedTuple.ConstructedFrom); 4518Assert.Same(vt2, namedTuple.ConstructedFrom); 4519Assert.Same(vt2, namedTuple.OriginalDefinition); 5856Assert.Same(vt1, ((Symbols.PublicModel.NonErrorNamedTypeSymbol)tupleWithoutNames).UnderlyingNamedTypeSymbol); 5875Assert.Same(vt2, ((Symbols.PublicModel.NamedTypeSymbol)tupleWithoutNames).UnderlyingNamedTypeSymbol); 6058Assert.Same(vt8, ((Symbols.PublicModel.NamedTypeSymbol)tuple8WithoutNames).UnderlyingNamespaceOrTypeSymbol); 6193Assert.Same(vt2WithErrorType, tupleWithoutNames); 6228Assert.Same(comp.GlobalNamespace, ns.ContainingSymbol); 6229Assert.Same(comp.GlobalNamespace.ContainingAssembly, ns.ContainingAssembly); 6230Assert.Same(comp.GlobalNamespace.ContainingModule, ns.ContainingModule); 6236Assert.Same(comp.Assembly.GlobalNamespace, ns.ContainingSymbol); 6237Assert.Same(comp.Assembly.GlobalNamespace.ContainingAssembly, ns.ContainingAssembly); 6238Assert.Same(comp.Assembly.GlobalNamespace.ContainingModule, ns.ContainingModule); 6244Assert.Same(comp.SourceModule.GlobalNamespace, ns.ContainingSymbol); 6245Assert.Same(comp.SourceModule.GlobalNamespace.ContainingAssembly, ns.ContainingAssembly); 6246Assert.Same(comp.SourceModule.GlobalNamespace.ContainingModule, ns.ContainingModule); 11159Assert.Same(tupleType, m1Tuple.ConstructedFrom); 11161Assert.Same(tupleType, m1Tuple.OriginalDefinition); 11164Assert.Same(m1Tuple.ContainingSymbol, m1Tuple.ContainingSymbol); 11424Assert.Same(m1Tuple.OriginalDefinition, m1Tuple.ConstructedFrom);
Emit\InAttributeModifierTests.cs (1)
4429Assert.Same(assembly, assembly.CorLibrary);
Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (90)
Attributes\AttributeTests.cs (1)
10035Assert.Same(compilation1.Assembly, compilation2.SourceModule.ReferencedAssemblySymbols[1]);
Diagnostics\DiagnosticAnalyzerTests.cs (1)
4063Assert.Same(model, _cache[tree]);
Diagnostics\GetDiagnosticsTests.cs (1)
1653Assert.Same(tree1, analyzedTree);
FieldKeywordTests.cs (1)
8926Assert.Same(property.BackingField, otherPart.BackingField);
PartialEventsAndConstructorsTests.cs (12)
2002Assert.Same(implSymbol, defSymbol.PartialImplementationPart); 2003Assert.Same(defSymbol, implSymbol.PartialDefinitionPart); 2020Assert.Same(implSymbol, defSymbol.PartialImplementationPart); 2021Assert.Same(defSymbol, implSymbol.PartialDefinitionPart); 2041Assert.Same(implSymbol, defSymbol.PartialImplementationPart); 2042Assert.Same(defSymbol, implSymbol.PartialDefinitionPart); 2078Assert.Same(implSymbol, defSymbol.PartialImplementationPart); 2079Assert.Same(defSymbol, implSymbol.PartialDefinitionPart); 2109Assert.Same(implSymbol, defSymbol.PartialImplementationPart); 2110Assert.Same(defSymbol, implSymbol.PartialDefinitionPart); 2155Assert.Same(implSymbol, ((IMethodSymbol)defSymbol.ContainingSymbol).PartialImplementationPart!.Parameters.Single()); 2156Assert.Same(defSymbol, ((IMethodSymbol)implSymbol.ContainingSymbol).PartialDefinitionPart!.Parameters.Single());
Semantics\ExtensionTests.cs (12)
164Assert.Same(symbol, symbol.OriginalDefinition); 165Assert.Same(symbol, symbol.ConstructedFrom); 249Assert.Same(symbol, symbol.OriginalDefinition); 250Assert.Same(symbol, symbol.ConstructedFrom); 263Assert.Same(symbol, constructed.OriginalDefinition); 264Assert.Same(symbol, constructed.ConstructedFrom); 270Assert.Same(symbol, unbound.OriginalDefinition); 271Assert.Same(symbol, unbound.ConstructedFrom); 2729Assert.Same(extensionParameter, model.GetDeclaredSymbol(parameterSyntaxes[0])); 2772Assert.Same(extensionParameter.Type, symbol.TypeParameters[0]); 2796Assert.Same(extensionParameter.Type, symbol.ContainingType.TypeParameters[0]); 43014Assert.Same(context.Node.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree);
Semantics\OutVarTests.cs (19)
971Assert.Same(symbol, model.GetDeclaredSymbol((SyntaxNode)variableDeclaratorSyntax)); 980Assert.Same(symbol, other); 991Assert.Same(symbol, model.GetSymbolInfo(reference).Symbol); 992Assert.Same(symbol, model.LookupSymbols(reference.SpanStart, name: decl.Identifier().ValueText).Single()); 1144Assert.Same(symbol, model.GetDeclaredSymbol((SyntaxNode)variableDesignationSyntax)); 1166Assert.Same(symbol, model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Single()); 1197Assert.Same(symbol, model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Single()); 32736Assert.Same(symbol, model.GetDeclaredSymbol((SyntaxNode)variableDesignationSyntax)); 32748Assert.Same(symbol, symbols.Single()); 32777Assert.Same(symbol, referenceInfo.Symbol); 32778Assert.Same(symbol, symbols.Single()); 36023Assert.Same(initializerOperation.Parent.Parent, blockBodyOperation.Parent); 36047Assert.Same(blockBodyOperation.Parent, model.GetOperation(expressionBodySyntax).Parent); 36051Assert.Same(blockBodyOperation.Parent, model.GetOperation(declarationSyntax)); 36168Assert.Same(expressionBodyOperation.Parent, blockBodyOperation.Parent); 36176Assert.Same(expressionBodyOperation.Parent, model.GetOperation(declarationSyntax)); 36416Assert.Same(symbolInfo.Symbol, speculativeModel.GetDeclaredSymbol(tree2.GetRoot().DescendantNodes().OfType<LocalFunctionStatementSyntax>().Where(l => l.Identifier.ValueText == "M2").Single())); 36498Assert.Same(symbolInfo.Symbol, speculativeModel.GetDeclaredSymbol(tree2.GetRoot().DescendantNodes().OfType<LocalFunctionStatementSyntax>().Where(l => l.Identifier.ValueText == "M2").Single())); 36571Assert.Same(symbolInfo.Symbol, speculativeModel.GetDeclaredSymbol(tree2.GetRoot().DescendantNodes().OfType<LocalFunctionStatementSyntax>().Where(l => l.Identifier.ValueText == "M2").Single()));
Semantics\PatternMatchingTestBase.cs (13)
84Assert.Same(symbol, model.GetDeclaredSymbol((SyntaxNode)designation)); 93Assert.Same(symbol, other); 124Assert.Same(symbol, model.GetSymbolInfo(reference).Symbol); 125Assert.Same(symbol, model.LookupSymbols(reference.SpanStart, name: designation.Identifier.ValueText).Single()); 145Assert.Same(symbol, model.GetDeclaredSymbol((SyntaxNode)designation)); 171Assert.Same(symbol, model.GetDeclaredSymbol((SyntaxNode)declarator)); 185Assert.Same(symbol, model.GetDeclaredSymbol((SyntaxNode)designation)); 196Assert.Same(symbol, model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Single()); 210Assert.Same(symbol, other); 247Assert.Same(symbol, model.GetDeclaredSymbol((SyntaxNode)designation)); 259Assert.Same(symbol, symbols.Single()); 312Assert.Same(symbol, referenceInfo.Symbol); 313Assert.Same(symbol, symbols.Single());
Semantics\PrimaryConstructorTests.cs (18)
1014Assert.Same(symbol, model.LookupSymbols(x.SpanStart, name: "X").Single()); 1081Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1130Assert.Same(operation.Parent.Parent, model.GetOperation(baseWithargs.Parent.Parent)); 1308Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1321Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1537Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1626Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 1975Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 3803Assert.Same(literal.SyntaxTree, context.ContainingSymbol.DeclaringSyntaxReferences.Single().SyntaxTree); 3829Assert.Same(equalsValue.SyntaxTree, context.ContainingSymbol.DeclaringSyntaxReferences.Single().SyntaxTree); 3847Assert.Same(initializer.SyntaxTree, context.ContainingSymbol.DeclaringSyntaxReferences.Single().SyntaxTree); 3878Assert.Same(baseType.SyntaxTree, context.ContainingSymbol.DeclaringSyntaxReferences.Single().SyntaxTree); 3905Assert.Same(@class.SyntaxTree, context.ContainingSymbol.DeclaringSyntaxReferences.Single().SyntaxTree); 5292Assert.Same(literal.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 5310Assert.Same(equalsValue.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 5328Assert.Same(initializer.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 5357Assert.Same(record.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 7834Assert.Same(symbol, model.LookupSymbols(p1.SpanStart, name: "p1").Single());
Semantics\RecordTests.cs (12)
21257Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 21307Assert.Same(operation.Parent.Parent, model.GetOperation(baseWithargs.Parent.Parent)); 21486Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 21499Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 21715Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 21804Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 22191Assert.Same(symbol.ContainingSymbol, model.GetEnclosingSymbol(x.SpanStart)); 26347Assert.Same(literal.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 26373Assert.Same(equalsValue.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 26391Assert.Same(initializer.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 26422Assert.Same(baseType.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 26445Assert.Same(record.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree);
Microsoft.CodeAnalysis.CSharp.IOperation.UnitTests (22)
IOperation\IOperationTests.cs (4)
672Assert.Same(blockOperation, catchOperation.Handler); 684Assert.Same(model, operation.SemanticModel); 685Assert.Same(memberModel, ((Operation)operation).OwningSemanticModel); 690Assert.Same(expectedRootSyntax, operation.Syntax);
IOperation\IOperationTests_IAnonymousFunctionExpression.cs (10)
418Assert.Same(variableTreeLambdaOperation, lambdaOperation); 426Assert.Same(variableTreeLambdaOperation, variableTreeLambdaOperationSecondRequest); 427Assert.Same(lambdaOperation, lambdaOperationSecondRequest); 861Assert.Same(graphM, graphD1.Parent); 863Assert.Same(graphD1, graphD1_FromExtension); 868Assert.Same(graphD1, graphD2.Parent); 919Assert.Same(graphM, graphD1.Parent); 922Assert.Same(graphM, graphD2.Parent); 925Assert.Same(graphD1, graphD1_FromExtension); 929Assert.Same(graphD1, graphD1_FromExtension);
IOperation\IOperationTests_IArgument.cs (1)
4161Assert.Same(indexerSymbol, argument.Parameter.ContainingSymbol);
IOperation\IOperationTests_ILocalFunctionStatement.cs (7)
1804Assert.Same(graphM, graphD1.Parent); 1806Assert.Same(graphD1, graphD1_FromExtension); 1814Assert.Same(graphD1, graphD2.Parent); 1860Assert.Same(graphM, graphD1.Parent); 1863Assert.Same(graphM, graphD2.Parent); 1866Assert.Same(graphD1, graphD1_FromExtension); 1870Assert.Same(graphD1, graphD1_FromExtension);
Microsoft.CodeAnalysis.CSharp.Scripting.UnitTests (5)
ScriptOptionsTests.cs (1)
28Assert.Same(options, options.WithLanguageVersion(LanguageVersion.CSharp8));
ScriptTests.cs (4)
137Assert.Same(script, state.Script); 146Assert.Same(script, state.Script); 296Assert.Same(script, state.Script); 409Assert.Same(state.GetVariable("X"), state.GetVariable("X"));
Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (178)
Semantics\BindingTests.cs (2)
2935Assert.Same(symbol1, symbol2); 2977Assert.Same(symbol1, symbol2);
Semantics\DeconstructionTests.cs (2)
4176Assert.Same(x1, model.GetSymbolInfo(refs.Where(r => r.Identifier.ValueText == "x1").Single()).Symbol); 4181Assert.Same(x2, model.GetSymbolInfo(refs.Where(r => r.Identifier.ValueText == "x2").Single()).Symbol);
Semantics\ImportsTests.cs (1)
27Assert.Same(empty, empty.Concat(empty));
Semantics\LambdaTests.cs (2)
8121Assert.Same(constSymbol, defaultValueSymbol); 8126Assert.Same(constSymbol, lhsSymbol);
Semantics\LocalFunctionTests.cs (2)
4739Assert.Same(symbol, model.GetSymbolInfo(refs[0]).Symbol); 5122Assert.Same(symbol, parameterSymbol.Type);
Semantics\NativeIntegerTests.cs (11)
245Assert.Same(type, type.ConstructedFrom); 260Assert.Same(underlyingType.ContainingSymbol, nativeIntegerType.ContainingSymbol); 261Assert.Same(underlyingType.Name, nativeIntegerType.Name); 268Assert.Same(underlyingType, nativeIntegerType.NativeIntegerUnderlyingType); 359Assert.Same(underlyingType.ContainingSymbol, nativeIntegerType.ContainingSymbol); 360Assert.Same(underlyingType.Name, nativeIntegerType.Name); 543Assert.Same(type, member.ContainingSymbol); 544Assert.Same(type, member.ContainingType); 1632Assert.Same(underlyingType, ((INamedTypeSymbol)type.WithNullableAnnotation(CodeAnalysis.NullableAnnotation.None)).NativeIntegerUnderlyingType); 1633Assert.Same(underlyingType, ((INamedTypeSymbol)type.WithNullableAnnotation(CodeAnalysis.NullableAnnotation.Annotated)).NativeIntegerUnderlyingType); 1634Assert.Same(underlyingType, ((INamedTypeSymbol)type.WithNullableAnnotation(CodeAnalysis.NullableAnnotation.NotAnnotated)).NativeIntegerUnderlyingType);
Semantics\NullableReferenceTypesTests.cs (1)
3703Assert.Same(symbol1, symbol2);
Semantics\ObjectAndCollectionInitializerTests.cs (1)
3821Assert.Same(typeInfo.Type, typeInfo.ConvertedType);
Semantics\OperatorTests.cs (6)
7657Assert.Same(symbol1.ContainingSymbol, symbol1.Parameters[0].Type); 8298Assert.Same(symbol1, symbol2); 8299Assert.Same(symbol1, symbol3); 8300Assert.Same(symbol1, symbol4); 8306Assert.Same(symbol1, symbol3); 8315Assert.Same(symbol1, symbol4);
Semantics\RecordStructTests.cs (4)
6062Assert.Same(literal.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 6080Assert.Same(equalsValue.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 6098Assert.Same(initializer.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree); 6127Assert.Same(record.SyntaxTree, context.ContainingSymbol!.DeclaringSyntaxReferences.Single().SyntaxTree);
Semantics\ScriptSemanticsTests.cs (2)
526Assert.Same(symbol0, symbol1); 542Assert.Same(symbol0, symbol1);
Semantics\TopLevelStatementsTests.cs (131)
50Assert.Same(entryPoint, comp.GetEntryPoint(default)); 200Assert.Same(refSymbol, model1.LookupSymbols(localRef.SpanStart, name: refSymbol.Name).Single()); 238Assert.Same(declSymbol.ContainingSymbol, model1.GetDeclaredSymbol(unit1)); 239Assert.Same(declSymbol.ContainingSymbol, model1.GetDeclaredSymbol((SyntaxNode)unit1)); 240Assert.Same(refSymbol, declSymbol); 243Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: declSymbol.Name).Single()); 362Assert.Same(declSymbol.ContainingSymbol, declMethod); 366Assert.Same(declSymbol, model2.LookupSymbols(localDecl.SpanStart, name: declSymbol.Name).Single()); 487Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: declSymbol.Name).Single()); 496Assert.Same(declSymbol, model1.LookupSymbols(localFuncRef.SpanStart, name: declSymbol.Name).Single()); 539Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: declSymbol.Name).Single()); 547Assert.Same(declSymbol, refSymbol); 550Assert.Same(declSymbol, model1.LookupSymbols(localRef.SpanStart, name: declSymbol.Name).Single()); 579Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: declSymbol.Name).Single()); 588Assert.Same(declSymbol, model1.LookupSymbols(localFuncRef.SpanStart, name: declSymbol.Name).Single()); 594Assert.Same(declSymbol, refSymbol); 597Assert.Same(refSymbol, model1.LookupSymbols(localRef.SpanStart, name: refSymbol.Name).Single()); 703Assert.Same(local, model.GetSymbolInfo(reference).Symbol); 874Assert.Same(symbol1, model1.GetSymbolInfo(tree1.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "x").Single()).Symbol); 880Assert.Same(symbol2, model2.GetSymbolInfo(tree2.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "x").Single()).Symbol); 988Assert.Same(symbol1, model1.GetSymbolInfo(tree1.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "x").First()).Symbol); 992Assert.Same(symbol1, model1.GetSymbolInfo(tree1.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "x").Skip(1).Single()).Symbol); 1043Assert.Same(symbol1, model1.GetSymbolInfo(tree1.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "args").Single()).Symbol); 1698Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: "Test").Single()); 1703Assert.Same(testType, model1.LookupNamespacesAndTypes(localDecl.SpanStart, name: "Test").Single()); 1711Assert.Same(declSymbol, model1.GetSymbolInfo(nameRef).Symbol); 1720Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 1731Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 1735Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 1741Assert.Same(declSymbol, model.GetSymbolInfo(nameRef).Symbol); 1746Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 1751Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 1757Assert.Same(declSymbol, model.GetSymbolInfo(nameRef).Symbol); 1768Assert.Same(declSymbol, model.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 1773Assert.Same(testType, model.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 1871Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: "Test").Single()); 1876Assert.Same(testType, model1.LookupNamespacesAndTypes(localDecl.SpanStart, name: "Test").Single()); 1888Assert.Same(testType, model2.GetSymbolInfo(nameRef).Symbol); 1899Assert.Same(testType, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 1903Assert.Same(testType, model2.GetSymbolInfo(nameRef).Symbol); 1909Assert.Same(declSymbol, model2.GetSymbolInfo(nameRef).Symbol); 1914Assert.Same(testType, model2.GetSymbolInfo(nameRef).Symbol); 1919Assert.Same(testType, model2.GetSymbolInfo(nameRef).Symbol); 1925Assert.Same(declSymbol, model2.GetSymbolInfo(nameRef).Symbol); 1936Assert.Same(declSymbol, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 1941Assert.Same(testType, model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 2094Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: "Test").Single()); 2099Assert.Same(testType, model1.LookupNamespacesAndTypes(localDecl.SpanStart, name: "Test").Single()); 2106Assert.Same(testType, model1.GetSymbolInfo(nameRef).Symbol); 2114Assert.Same(testType, model1.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2118Assert.Same(testType, model1.GetSymbolInfo(nameRef).Symbol); 2123Assert.Same(declSymbol, model1.GetSymbolInfo(nameRef).Symbol); 2128Assert.Same(testType, model1.GetSymbolInfo(nameRef).Symbol); 2133Assert.Same(testType, model1.GetSymbolInfo(nameRef).Symbol); 2138Assert.Same(declSymbol, model1.GetSymbolInfo(nameRef).Symbol); 2149Assert.Same(declSymbol, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2154Assert.Same(testType, model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 2258Assert.Same(declSymbol, model1.LookupSymbols(localDecl.SpanStart, name: "Test").Single()); 2263Assert.Same(testType, model1.LookupNamespacesAndTypes(localDecl.SpanStart, name: "Test").Single()); 2272Assert.Same(testType, model2.GetSymbolInfo(nameRef).Symbol); 2280Assert.Same(testType, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2284Assert.Same(testType, model2.GetSymbolInfo(nameRef).Symbol); 2289Assert.Same(declSymbol, model2.GetSymbolInfo(nameRef).Symbol); 2294Assert.Same(testType, model2.GetSymbolInfo(nameRef).Symbol); 2299Assert.Same(testType, model2.GetSymbolInfo(nameRef).Symbol); 2304Assert.Same(declSymbol, model2.GetSymbolInfo(nameRef).Symbol); 2315Assert.Same(declSymbol, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2320Assert.Same(testType, model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 2437Assert.Same(testType, model1.LookupSymbols(labelDecl.SpanStart, name: "Test").Single()); 2442Assert.Same(testType, model1.LookupNamespacesAndTypes(labelDecl.SpanStart, name: "Test").Single()); 2444Assert.Same(declSymbol, model1.LookupLabels(labelDecl.SpanStart).Single()); 2445Assert.Same(declSymbol, model1.LookupLabels(labelDecl.SpanStart, name: "Test").Single()); 2452Assert.Same(testType, model1.GetSymbolInfo(nameRef).Symbol); 2460Assert.Same(testType, model1.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2466Assert.Same(declSymbol, model1.GetSymbolInfo(nameRef).Symbol); 2475Assert.Same(testType, model1.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2476Assert.Same(declSymbol, model1.LookupLabels(nameRef.SpanStart).Single()); 2477Assert.Same(declSymbol, model1.LookupLabels(nameRef.SpanStart, name: "Test").Single()); 2481Assert.Same(testType, model1.GetSymbolInfo(nameRef).Symbol); 2491Assert.Same(testType, model1.GetSymbolInfo(nameRef).Symbol); 2496Assert.Same(testType, model1.GetSymbolInfo(nameRef).Symbol); 2512Assert.Same(testType, model2.LookupSymbols(nameRef.SpanStart, name: "Test").Single()); 2517Assert.Same(testType, model2.LookupNamespacesAndTypes(nameRef.SpanStart, name: "Test").Single()); 3947Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 3954Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 3968Assert.Same(parameter, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 3973Assert.Same(testType, model.LookupNamespacesAndTypes(nameRef.SpanStart, name: "args").Single()); 3977Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 3982Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 3987Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 3992Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 3997Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 4008Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 4013Assert.Same(testType, model.LookupNamespacesAndTypes(nameRef.SpanStart, name: "args").Single()); 4096Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 4103Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 4107Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 4112Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 4117Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 4122Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 4127Assert.Same(testType, model.GetSymbolInfo(nameRef).Symbol); 4138Assert.Same(testType, model.LookupSymbols(nameRef.SpanStart, name: "args").Single()); 4143Assert.Same(testType, model.LookupNamespacesAndTypes(nameRef.SpanStart, name: "args").Single()); 4220Assert.Same(local, model.GetSymbolInfo(reference).Symbol); 4513Assert.Same(symbol1, model1.GetSymbolInfo(tree1.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "local1").Single()).Symbol); 4519Assert.Same(symbol2, model2.GetSymbolInfo(tree2.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "local1").Single()).Symbol); 4577Assert.Same(symbol1, model1.GetSymbolInfo(tree1.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "local1").First()).Symbol); 4581Assert.Same(symbol1, model1.GetSymbolInfo(tree1.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "local1").Skip(1).Single()).Symbol); 4626Assert.Same(symbol1, model1.GetSymbolInfo(tree1.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "args").Single()).Symbol); 4898Assert.Same(label, model.GetSymbolInfo(reference).Symbol); 4953Assert.Same(symbol1, model1.GetSymbolInfo(tree1.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "label1").Single()).Symbol); 4960Assert.Same(symbol2, model2.GetSymbolInfo(tree2.GetRoot().DescendantNodes().OfType<IdentifierNameSyntax>().Where(id => id.Identifier.ValueText == "label1").Single()).Symbol); 4983Assert.Same(label, model.GetSymbolInfo(reference).Symbol); 6041Assert.Same(declSymbol, refSymbol); 6044Assert.Same(declSymbol, model1.LookupSymbols(localRef.SpanStart, name: declSymbol.Name).Single()); 6283Assert.Same(x, semanticModel.LookupSymbols(localDecl.SpanStart, name: "x").Single()); 6284Assert.Same(x, semanticModel.GetSymbolInfo(localRef).Symbol); 6285Assert.Same(x, semanticModel.LookupSymbols(localRef.SpanStart, name: "x").Single()); 6328Assert.Same(xDecl, semanticModel1.LookupSymbols(localDecl.SpanStart, name: "x").Single()); 6330Assert.Same(xRef, semanticModel1.LookupSymbols(localRef.SpanStart, name: "x").Single()); 6333Assert.Same(xDecl, xRef); 6379Assert.Same(xDecl, semanticModel1.LookupSymbols(localDecl.SpanStart, name: "x").Single()); 6385Assert.Same(xRef, semanticModel2.LookupSymbols(localRef.SpanStart, name: "x").Single()); 6387Assert.Same(xDecl, xRef); 6456Assert.Same(globalStatement.SyntaxTree, context.ContainingSymbol.DeclaringSyntaxReferences.Single().SyntaxTree); 6722Assert.Same(context.ContainingSymbol.DeclaringSyntaxReferences.Single().SyntaxTree, context.Operation.Syntax.SyntaxTree); 6743Assert.Same(context.ContainingSymbol.DeclaringSyntaxReferences.Single().GetSyntax(), context.Operation.Syntax); 7421Assert.Same(context.ContainingSymbol.DeclaringSyntaxReferences.Single().GetSyntax(), context.Operation.Syntax); 9053Assert.Same(entryPoint, comp.GetEntryPoint(default)); 9108Assert.Same(entryPoint, comp.GetEntryPoint(default)); 9150Assert.Same(entryPoint, comp.GetEntryPoint(default));
SourceGeneration\GeneratorDriverTests.cs (11)
766Assert.Same(oldDriver, driver); 811Assert.Same(parseOptions, passedOptions); 1148Assert.Same(rootFromGetRoot, rootFromTryGetRoot); 4383Assert.Same(generator, sourceGenerator); 4394Assert.Same(generator.GetType(), type); 4405Assert.Same(generator, incrementalGenerator); 4416Assert.Same(generator.GetType(), type); 4630Assert.Same(newParseOptions, result.GeneratedTrees[0].Options); 4631Assert.Same(parseOptions, result.GeneratedTrees[1].Options); 4638Assert.Same(newParseOptions, result.GeneratedTrees[0].Options); 4639Assert.Same(newParseOptions, result.GeneratedTrees[1].Options);
SourceGeneration\StateTableTests.cs (1)
141Assert.Same(compactedTable, compactedTable2);
SourceGeneration\SyntaxAwareGeneratorTests.cs (1)
796Assert.Same(dType, typeInfo.Type);
Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (192)
Compilation\CompilationAPITests.cs (8)
598Assert.Same(NetFramework.MicrosoftCSharp, c.GetDirectiveReference(rd1[0])); 599Assert.Same(NetFramework.MicrosoftCSharp, c.GetDirectiveReference(rd1[1])); 600Assert.Same(NetFramework.MicrosoftCSharp, c.GetDirectiveReference(rd2[0])); 601Assert.Same(NetFramework.MicrosoftVisualBasic, c.GetDirectiveReference(rd2[1])); 602Assert.Same(NetFramework.MicrosoftCSharp, c.GetDirectiveReference(rd3[0])); 1733Assert.Same(compilation.ObjectType.ContainingAssembly, taskOfT.ContainingAssembly); 1734Assert.Same(compilation.ObjectType.ContainingAssembly, taskOfObject.ContainingAssembly); 1755Assert.Same(firstCompilation.ObjectType, secondCompilation.ObjectType);
Compilation\CSharpCompilationOptionsTests.cs (4)
57Assert.Same(newOpt1_alias, newOpt1); 447Assert.Same(options, options.WithCryptoPublicKey(default(ImmutableArray<byte>))); 448Assert.Same(options, options.WithCryptoPublicKey(ImmutableArray<byte>.Empty)); 478Assert.Same(oldOptions, newOptions);
Compilation\GetSemanticInfoTests.cs (1)
4046Assert.Same(method1.ReducedFrom.TypeParameters[0], method1.TypeParameters[0].ReducedFrom);
Compilation\ReferenceManagerTests.cs (2)
1376Assert.Same(NetFramework.MicrosoftCSharp, c.GetDirectiveReference(rd1)); 1377Assert.Same(NetFramework.MicrosoftVisualBasic, c.GetDirectiveReference(rd2));
Compilation\SemanticModelAPITests.cs (2)
210Assert.Same(model.GetDeclaredSymbol(rxDecl.Variables.Single()), rxSymbol); 242Assert.Same(model.GetDeclaredSymbol(rxDecl), rxSymbol);
Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (14)
390Assert.Same(eventSymbol.AddMethod, model.GetDeclaredSymbol(accessorList[0])); 391Assert.Same(eventSymbol.RemoveMethod, model.GetDeclaredSymbol(accessorList[1])); 2877Assert.Same(explicitPropertySymbol.GetMethod, explicitPropertyGetterSymbol); 2887Assert.Same(explicitPropertySymbol.SetMethod, explicitPropertySetterSymbol); 2998Assert.Same(mems2[0], dsymc1); 2999Assert.Same(mems2[1], dsymc2); 3000Assert.Same(mems2[2], dsymc3); 3757Assert.Same(declSymbol, memSymbol); 3878Assert.Same(alias1, alias2); 3938Assert.Same(alias1, alias1b); 3942Assert.Same(alias2, alias2b); 5225Assert.Same(symbol1.ContainingSymbol, symbol2.ContainingSymbol); 5246Assert.Same(symbol1.ContainingSymbol, symbol2.ContainingSymbol); 5267Assert.Same(symbol1.ContainingSymbol, symbol2.ContainingSymbol);
Compilation\UsedAssembliesTests.cs (3)
97Assert.Same(comp.ObjectType.ContainingAssembly, comp.GetAssemblyOrModuleSymbol(used[0])); 644Assert.Same(comp2.ObjectType.ContainingAssembly, comp2.GetAssemblyOrModuleSymbol(used[0])); 2333Assert.Same(comp.ObjectType.ContainingAssembly, comp.GetAssemblyOrModuleSymbol(used[0]));
Symbols\CompilationCreationTests.cs (37)
151Assert.Same(asm2[0], asm1[0]); 155Assert.Same(((PEAssemblySymbol)asm2[1]).Assembly, ((PEAssemblySymbol)asm1[1]).Assembly); 181Assert.Same(asm3[0], asm1[0]); 186Assert.Same(((PEAssemblySymbol)asm3[1]).Assembly, ((PEAssemblySymbol)asm1[1]).Assembly); 239Assert.Same(asm3[0], asm1[0]); 245Assert.Same(((PEAssemblySymbol)asm4[1]).Assembly, ((PEAssemblySymbol)asm1[1]).Assembly); 268Assert.Same(((PEAssemblySymbol)asm4[3]).Assembly, ((PEAssemblySymbol)asm3[3]).Assembly); 333Assert.Same(asm5[0], asm1[0]); 342Assert.Same(asm6[0], asm1[0]); 343Assert.Same(asm6[1], asm1[1]); 353Assert.Same(asm7[0], asm1[0]); 354Assert.Same(asm7[1], asm1[1]); 360Assert.Same(((PEAssemblySymbol)asm7[2]).Assembly, ((PEAssemblySymbol)asm3[3]).Assembly); 382Assert.Same(((PEAssemblySymbol)asm7[3]).Assembly, ((PEAssemblySymbol)asm4[4]).Assembly); 422Assert.Same(asm8[0], asm1[0]); 423Assert.Same(asm8[0], asm1[0]); 424Assert.Same(asm8[2], asm7[1]); 426Assert.Same(asm8[3], asm7[2]); 428Assert.Same(asm8[1], asm7[3]); 436Assert.Same(asm9[0], asm1[0]); 448Assert.Same(asm10[0], asm1[0]); 449Assert.Same(asm10[1], asm4[1]); 450Assert.Same(asm10[2], asm4[2]); 451Assert.Same(asm10[3], asm4[3]); 452Assert.Same(asm10[4], asm4[4]); 462Assert.Same(asm2[0], asm1[0]); 466Assert.Same(((PEAssemblySymbol)asm2[1]).Assembly, ((PEAssemblySymbol)asm1[1]).Assembly); 483Assert.Same(asm3[0], asm1[0]); 488Assert.Same(((PEAssemblySymbol)asm3[1]).Assembly, ((PEAssemblySymbol)asm1[1]).Assembly); 531Assert.Same(asm3[0], asm1[0]); 537Assert.Same(((PEAssemblySymbol)asm4[1]).Assembly, ((PEAssemblySymbol)asm1[1]).Assembly); 560Assert.Same(((PEAssemblySymbol)asm4[3]).Assembly, ((PEAssemblySymbol)asm3[3]).Assembly); 619Assert.Same(asm7[0], asm1[0]); 620Assert.Same(asm7[1], asm1[1]); 626Assert.Same(((PEAssemblySymbol)asm7[2]).Assembly, ((PEAssemblySymbol)asm3[3]).Assembly); 648Assert.Same(((PEAssemblySymbol)asm7[3]).Assembly, ((PEAssemblySymbol)asm4[4]).Assembly); 2579Assert.Same(module1.Module, module2.Module);
Symbols\CorLibrary\Choosing.cs (2)
44Assert.Same(corLib.Assembly, obj.ContainingAssembly); 52Assert.Same(obj, consumer.GetSpecialType(SpecialType.System_Object));
Symbols\DefaultInterfaceImplementationTests.cs (2)
14781Assert.Same(p2get, test1.FindImplementationForInterfaceMember(p2get)); 17072Assert.Same(p2get, test1.FindImplementationForInterfaceMember(p2get));
Symbols\InterfaceImplementationTests.cs (4)
935Assert.Same(baseClassPropertyGetter, derivedClass.FindImplementationForInterfaceMember(interfacePropertyGetter)); 936Assert.Same(baseClassPropertySetter, derivedClass.FindImplementationForInterfaceMember(interfacePropertySetter)); 1004Assert.Same(baseClassPropertyGetter, derivedClass.FindImplementationForInterfaceMember(interfacePropertyGetter)); 1005Assert.Same(baseClassPropertySetter, derivedClass.FindImplementationForInterfaceMember(interfacePropertySetter));
Symbols\Metadata\PE\LoadingNamespacesAndTypes.cs (2)
142Assert.Same(systemNS.ContainingAssembly, assembly); 155Assert.Same(collectionsNS.ContainingAssembly, assembly);
Symbols\Metadata\PE\MissingTypeReferences.cs (2)
89Assert.Same(constructedFrom, constructedFrom.Construct(constructedFrom.TypeParameters.ToArray())); 98Assert.Same(genericBase.OriginalDefinition, genericBase.ConstructedFrom);
Symbols\Metadata\PE\NoPia.cs (11)
103Assert.Same(pia1_1, assemblies2[2]); 158Assert.Same(localTypes2_3, missing.EmbeddingAssembly); 178Assert.Same(assemblies1[i], assemblies4[i]); 202Assert.Same(localTypes1_5, missing.EmbeddingAssembly); 306Assert.Same(localTypes1_8, ambiguous.EmbeddingAssembly); 444Assert.Same(pia1_1, assemblies2[0]); 476Assert.Same(pia1_1, assemblies3[0]); 505Assert.Same(assemblies1[i], assemblies4[i]); 530Assert.Same(localTypes1_5, missing.EmbeddingAssembly); 544Assert.Same(localTypes2_5, missing.EmbeddingAssembly); 642Assert.Same(localTypes1_8, ambiguous.EmbeddingAssembly);
Symbols\OverriddenOrHiddenMembersTests.cs (37)
264Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseInterface1Method.OverriddenOrHiddenMembers); 265Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseInterface1Property.OverriddenOrHiddenMembers); 267Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseInterface2Method.OverriddenOrHiddenMembers); 268Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseInterface2Property.OverriddenOrHiddenMembers); 270Assert.Same(OverriddenOrHiddenMembersResult.Empty, derivedInterface1MethodInt.OverriddenOrHiddenMembers); 272Assert.Same(OverriddenOrHiddenMembersResult.Empty, derivedInterface2MethodInt.OverriddenOrHiddenMembers); 357Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseInterface1MethodT.OverriddenOrHiddenMembers); 358Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseInterface1MethodInt.OverriddenOrHiddenMembers); 359Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseInterface1Property.OverriddenOrHiddenMembers); 361Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseInterface2MethodT.OverriddenOrHiddenMembers); 362Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseInterface2MethodInt.OverriddenOrHiddenMembers); 363Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseInterface2Property.OverriddenOrHiddenMembers); 365Assert.Same(OverriddenOrHiddenMembersResult.Empty, derivedInterface1Method.OverriddenOrHiddenMembers); 367Assert.Same(OverriddenOrHiddenMembersResult.Empty, derivedInterface2Method.OverriddenOrHiddenMembers); 427Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseClassMethod.OverriddenOrHiddenMembers); 428Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseClassProperty.OverriddenOrHiddenMembers); 430Assert.Same(OverriddenOrHiddenMembersResult.Empty, derivedClassMethodInt.OverriddenOrHiddenMembers); 479Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseClassMethodT.OverriddenOrHiddenMembers); 480Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseClassMethodInt.OverriddenOrHiddenMembers); 481Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseClassProperty.OverriddenOrHiddenMembers); 483Assert.Same(OverriddenOrHiddenMembersResult.Empty, derivedClassMethod.OverriddenOrHiddenMembers); 544Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseClassMethod.OverriddenOrHiddenMembers); 545Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseClassProperty.OverriddenOrHiddenMembers); 547Assert.Same(OverriddenOrHiddenMembersResult.Empty, derivedClassMethodInt.OverriddenOrHiddenMembers); 678Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseClassMethod1.OverriddenOrHiddenMembers); 679Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseClassMethod2.OverriddenOrHiddenMembers); 680Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseClassMethod3.OverriddenOrHiddenMembers); 681Assert.Same(OverriddenOrHiddenMembersResult.Empty, baseClassProperty.OverriddenOrHiddenMembers); 683Assert.Same(OverriddenOrHiddenMembersResult.Empty, derivedClassMethod.OverriddenOrHiddenMembers); 917Assert.Same(OverriddenOrHiddenMembersResult.Empty, classAMethod1.OverriddenOrHiddenMembers); 918Assert.Same(OverriddenOrHiddenMembersResult.Empty, classAMethod2.OverriddenOrHiddenMembers); 919Assert.Same(OverriddenOrHiddenMembersResult.Empty, classBMethod1.OverriddenOrHiddenMembers); 920Assert.Same(OverriddenOrHiddenMembersResult.Empty, classBMethod2.OverriddenOrHiddenMembers); 921Assert.Same(OverriddenOrHiddenMembersResult.Empty, classCMethod1.OverriddenOrHiddenMembers); 922Assert.Same(OverriddenOrHiddenMembersResult.Empty, classCMethod2.OverriddenOrHiddenMembers); 923Assert.Same(OverriddenOrHiddenMembersResult.Empty, classDMethod1.OverriddenOrHiddenMembers); 924Assert.Same(OverriddenOrHiddenMembersResult.Empty, classDMethod2.OverriddenOrHiddenMembers);
Symbols\PartialPropertiesTests.cs (8)
5237Assert.Same(implSymbol, defSymbol.PartialImplementationPart); 5238Assert.Same(defSymbol, implSymbol.PartialDefinitionPart); 5273Assert.Same(implSymbol, defSymbol.PartialImplementationPart); 5274Assert.Same(defSymbol, implSymbol.PartialDefinitionPart); 5320Assert.Same(implSymbol, defSymbol.PartialImplementationPart); 5321Assert.Same(defSymbol, implSymbol.PartialDefinitionPart); 5357Assert.Same(implSymbol, ((IPropertySymbol)defSymbol.ContainingSymbol).PartialImplementationPart!.Parameters[0]); 5358Assert.Same(defSymbol, ((IPropertySymbol)implSymbol.ContainingSymbol).PartialDefinitionPart!.Parameters[0]);
Symbols\Retargeting\NoPia.cs (15)
413Assert.Same(pia1_1, assemblies2[2]); 466Assert.Same(localTypes2_3, missing.EmbeddingAssembly); 485Assert.Same(assemblies1[i], assemblies4[i]); 508Assert.Same(localTypes1_5, missing.EmbeddingAssembly); 608Assert.Same(localTypes1_8, ambiguous.EmbeddingAssembly); 714Assert.Same(pia1_1, assemblies2[2]); 767Assert.Same(localTypes2_3, missing.EmbeddingAssembly); 786Assert.Same(assemblies1[i], assemblies4[i]); 809Assert.Same(localTypes1_5, missing.EmbeddingAssembly); 909Assert.Same(localTypes1_8, ambiguous.EmbeddingAssembly); 1018Assert.Same(pia1_1, assemblies2[2]); 1071Assert.Same(localTypes2_3, missing.EmbeddingAssembly); 1090Assert.Same(assemblies1[i], assemblies4[i]); 1113Assert.Same(localTypes1_5, missing.EmbeddingAssembly); 1213Assert.Same(localTypes1_8, ambiguous.EmbeddingAssembly);
Symbols\Retargeting\RetargetCustomModifiers.cs (2)
184Assert.Same(modifiers, volatileFld.ContainingSymbol); 189Assert.Same(volatileFld.ContainingModule, ((RetargetingFieldSymbol)volatileFld).RetargetingModule);
Symbols\Retargeting\RetargetingTests.cs (1)
847Assert.Same(originalComp.Assembly, ((RetargetingAssemblySymbol)mRetargeted.ContainingAssembly).UnderlyingAssembly);
Symbols\Source\BaseClassTests.cs (4)
1039Assert.Same(B1, ((Retargeting.RetargetingNamedTypeSymbol)B2).UnderlyingNamedType); 1100Assert.Same(((PEModuleSymbol)B1.ContainingModule).Module, ((PEModuleSymbol)B2.ContainingModule).Module); 1169Assert.Same(B1, ((Retargeting.RetargetingNamedTypeSymbol)B2).UnderlyingNamedType); 1226Assert.Same(((PEModuleSymbol)B1.ContainingModule).Module, ((PEModuleSymbol)B2.ContainingModule).Module);
Symbols\Source\DeclaringSyntaxNodeTests.cs (4)
129Assert.Same(expectedSyntaxNodes[i], declaringReferences[i].GetSyntax()); 345Assert.Same(localType.DeclaringSyntaxReferences[0].GetSyntax(), symbol.DeclaringSyntaxReferences[0].GetSyntax()); 372Assert.Same(propertyInitializer, member.DeclaringSyntaxReferences[0].GetSyntax()); 378Assert.Same(propertyInitializer, propSymbol.DeclaringSyntaxReferences[0].GetSyntax());
Symbols\Source\ExternAliasTests.cs (1)
492Assert.Same(externAliasSyntax, externAliasSymbol.DeclaringSyntaxReferences.Single().GetSyntax());
Symbols\Source\FileModifierTests.cs (2)
4318Assert.Same(sourceType, types[0]); 4345Assert.Same(sourceType, types[0]);
Symbols\Source\MethodTests.cs (2)
2549Assert.Same(partialDef.PartialImplementationPart, partialImpl); 2550Assert.Same(partialImpl.PartialDefinitionPart, partialDef);
Symbols\Source\NullablePublicAPITests.cs (1)
4181Assert.Same(localFunctionSymbol, typeParameters.ContainingSymbol);
Symbols\TypeResolutionTests.cs (1)
73Assert.Same(c2.Assembly, c2TestClass.ContainingAssembly);
Symbols\TypeTests.cs (4)
1508Assert.Same(comp.GetSpecialType(SpecialType.System_Nullable_T), memType.OriginalDefinition); 1526Assert.Same(comp.GetSpecialType(SpecialType.System_Nullable_T), memType.OriginalDefinition); 1551Assert.Same(comp.GetSpecialType(SpecialType.System_Nullable_T), memType.OriginalDefinition); 1769Assert.Same(comp.GetSpecialType(SpecialType.System_Nullable_T), memType.OriginalDefinition);
Symbols\UnsignedRightShiftTests.cs (16)
134Assert.Same(shiftSymbol.ReturnType, unsignedShiftSymbol.ReturnType); 135Assert.Same(shiftSymbol.Parameters[0].Type, unsignedShiftSymbol.Parameters[0].Type); 136Assert.Same(shiftSymbol.Parameters[1].Type, unsignedShiftSymbol.Parameters[1].Type); 137Assert.Same(shiftSymbol.ContainingSymbol, unsignedShiftSymbol.ContainingSymbol); 637Assert.Same(shiftSymbol.ReturnType, unsignedShiftSymbol.ReturnType); 638Assert.Same(shiftSymbol.Parameters[0].Type, unsignedShiftSymbol.Parameters[0].Type); 639Assert.Same(shiftSymbol.Parameters[1].Type, unsignedShiftSymbol.Parameters[1].Type); 640Assert.Same(shiftSymbol.ContainingSymbol, unsignedShiftSymbol.ContainingSymbol); 1187Assert.Same(shiftSymbol.ReturnType, unsignedShiftSymbol.ReturnType); 1188Assert.Same(shiftSymbol.Parameters[0].Type, unsignedShiftSymbol.Parameters[0].Type); 1189Assert.Same(shiftSymbol.Parameters[1].Type, unsignedShiftSymbol.Parameters[1].Type); 1190Assert.Same(shiftSymbol.ContainingSymbol, unsignedShiftSymbol.ContainingSymbol); 1595Assert.Same(shiftSymbol.ReturnType, unsignedShiftSymbol.ReturnType); 1596Assert.Same(shiftSymbol.Parameters[0].Type, unsignedShiftSymbol.Parameters[0].Type); 1597Assert.Same(shiftSymbol.Parameters[1].Type, unsignedShiftSymbol.Parameters[1].Type); 1598Assert.Same(shiftSymbol.ContainingSymbol, unsignedShiftSymbol.ContainingSymbol);
Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests (285)
Diagnostics\DiagnosticTest.cs (2)
86Assert.Same(syntaxTree, d1.Location.SourceTree); 100Assert.Same(syntaxTree, d3.Location.SourceTree);
Generated\Syntax.Test.xml.Generated.cs (247)
14309Assert.Same(oldNode, newNode); 14335Assert.Same(oldNode, newNode); 14361Assert.Same(oldNode, newNode); 14387Assert.Same(oldNode, newNode); 14413Assert.Same(oldNode, newNode); 14439Assert.Same(oldNode, newNode); 14465Assert.Same(oldNode, newNode); 14491Assert.Same(oldNode, newNode); 14517Assert.Same(oldNode, newNode); 14543Assert.Same(oldNode, newNode); 14569Assert.Same(oldNode, newNode); 14595Assert.Same(oldNode, newNode); 14621Assert.Same(oldNode, newNode); 14647Assert.Same(oldNode, newNode); 14673Assert.Same(oldNode, newNode); 14699Assert.Same(oldNode, newNode); 14725Assert.Same(oldNode, newNode); 14751Assert.Same(oldNode, newNode); 14777Assert.Same(oldNode, newNode); 14803Assert.Same(oldNode, newNode); 14829Assert.Same(oldNode, newNode); 14855Assert.Same(oldNode, newNode); 14881Assert.Same(oldNode, newNode); 14907Assert.Same(oldNode, newNode); 14933Assert.Same(oldNode, newNode); 14959Assert.Same(oldNode, newNode); 14985Assert.Same(oldNode, newNode); 15011Assert.Same(oldNode, newNode); 15037Assert.Same(oldNode, newNode); 15063Assert.Same(oldNode, newNode); 15089Assert.Same(oldNode, newNode); 15115Assert.Same(oldNode, newNode); 15141Assert.Same(oldNode, newNode); 15167Assert.Same(oldNode, newNode); 15193Assert.Same(oldNode, newNode); 15219Assert.Same(oldNode, newNode); 15245Assert.Same(oldNode, newNode); 15271Assert.Same(oldNode, newNode); 15297Assert.Same(oldNode, newNode); 15323Assert.Same(oldNode, newNode); 15349Assert.Same(oldNode, newNode); 15375Assert.Same(oldNode, newNode); 15401Assert.Same(oldNode, newNode); 15427Assert.Same(oldNode, newNode); 15453Assert.Same(oldNode, newNode); 15479Assert.Same(oldNode, newNode); 15505Assert.Same(oldNode, newNode); 15531Assert.Same(oldNode, newNode); 15557Assert.Same(oldNode, newNode); 15583Assert.Same(oldNode, newNode); 15609Assert.Same(oldNode, newNode); 15635Assert.Same(oldNode, newNode); 15661Assert.Same(oldNode, newNode); 15687Assert.Same(oldNode, newNode); 15713Assert.Same(oldNode, newNode); 15739Assert.Same(oldNode, newNode); 15765Assert.Same(oldNode, newNode); 15791Assert.Same(oldNode, newNode); 15817Assert.Same(oldNode, newNode); 15843Assert.Same(oldNode, newNode); 15869Assert.Same(oldNode, newNode); 15895Assert.Same(oldNode, newNode); 15921Assert.Same(oldNode, newNode); 15947Assert.Same(oldNode, newNode); 15973Assert.Same(oldNode, newNode); 15999Assert.Same(oldNode, newNode); 16025Assert.Same(oldNode, newNode); 16051Assert.Same(oldNode, newNode); 16077Assert.Same(oldNode, newNode); 16103Assert.Same(oldNode, newNode); 16129Assert.Same(oldNode, newNode); 16155Assert.Same(oldNode, newNode); 16181Assert.Same(oldNode, newNode); 16207Assert.Same(oldNode, newNode); 16233Assert.Same(oldNode, newNode); 16259Assert.Same(oldNode, newNode); 16285Assert.Same(oldNode, newNode); 16311Assert.Same(oldNode, newNode); 16337Assert.Same(oldNode, newNode); 16363Assert.Same(oldNode, newNode); 16389Assert.Same(oldNode, newNode); 16415Assert.Same(oldNode, newNode); 16441Assert.Same(oldNode, newNode); 16467Assert.Same(oldNode, newNode); 16493Assert.Same(oldNode, newNode); 16519Assert.Same(oldNode, newNode); 16545Assert.Same(oldNode, newNode); 16571Assert.Same(oldNode, newNode); 16597Assert.Same(oldNode, newNode); 16623Assert.Same(oldNode, newNode); 16649Assert.Same(oldNode, newNode); 16675Assert.Same(oldNode, newNode); 16701Assert.Same(oldNode, newNode); 16727Assert.Same(oldNode, newNode); 16753Assert.Same(oldNode, newNode); 16779Assert.Same(oldNode, newNode); 16805Assert.Same(oldNode, newNode); 16831Assert.Same(oldNode, newNode); 16857Assert.Same(oldNode, newNode); 16883Assert.Same(oldNode, newNode); 16909Assert.Same(oldNode, newNode); 16935Assert.Same(oldNode, newNode); 16961Assert.Same(oldNode, newNode); 16987Assert.Same(oldNode, newNode); 17013Assert.Same(oldNode, newNode); 17039Assert.Same(oldNode, newNode); 17065Assert.Same(oldNode, newNode); 17091Assert.Same(oldNode, newNode); 17117Assert.Same(oldNode, newNode); 17143Assert.Same(oldNode, newNode); 17169Assert.Same(oldNode, newNode); 17195Assert.Same(oldNode, newNode); 17221Assert.Same(oldNode, newNode); 17247Assert.Same(oldNode, newNode); 17273Assert.Same(oldNode, newNode); 17299Assert.Same(oldNode, newNode); 17325Assert.Same(oldNode, newNode); 17351Assert.Same(oldNode, newNode); 17377Assert.Same(oldNode, newNode); 17403Assert.Same(oldNode, newNode); 17429Assert.Same(oldNode, newNode); 17455Assert.Same(oldNode, newNode); 17481Assert.Same(oldNode, newNode); 17507Assert.Same(oldNode, newNode); 17533Assert.Same(oldNode, newNode); 17559Assert.Same(oldNode, newNode); 17585Assert.Same(oldNode, newNode); 17611Assert.Same(oldNode, newNode); 17637Assert.Same(oldNode, newNode); 17663Assert.Same(oldNode, newNode); 17689Assert.Same(oldNode, newNode); 17715Assert.Same(oldNode, newNode); 17741Assert.Same(oldNode, newNode); 17767Assert.Same(oldNode, newNode); 17793Assert.Same(oldNode, newNode); 17819Assert.Same(oldNode, newNode); 17845Assert.Same(oldNode, newNode); 17871Assert.Same(oldNode, newNode); 17897Assert.Same(oldNode, newNode); 17923Assert.Same(oldNode, newNode); 17949Assert.Same(oldNode, newNode); 17975Assert.Same(oldNode, newNode); 18001Assert.Same(oldNode, newNode); 18027Assert.Same(oldNode, newNode); 18053Assert.Same(oldNode, newNode); 18079Assert.Same(oldNode, newNode); 18105Assert.Same(oldNode, newNode); 18131Assert.Same(oldNode, newNode); 18157Assert.Same(oldNode, newNode); 18183Assert.Same(oldNode, newNode); 18209Assert.Same(oldNode, newNode); 18235Assert.Same(oldNode, newNode); 18261Assert.Same(oldNode, newNode); 18287Assert.Same(oldNode, newNode); 18313Assert.Same(oldNode, newNode); 18339Assert.Same(oldNode, newNode); 18365Assert.Same(oldNode, newNode); 18391Assert.Same(oldNode, newNode); 18417Assert.Same(oldNode, newNode); 18443Assert.Same(oldNode, newNode); 18469Assert.Same(oldNode, newNode); 18495Assert.Same(oldNode, newNode); 18521Assert.Same(oldNode, newNode); 18547Assert.Same(oldNode, newNode); 18573Assert.Same(oldNode, newNode); 18599Assert.Same(oldNode, newNode); 18625Assert.Same(oldNode, newNode); 18651Assert.Same(oldNode, newNode); 18677Assert.Same(oldNode, newNode); 18703Assert.Same(oldNode, newNode); 18729Assert.Same(oldNode, newNode); 18755Assert.Same(oldNode, newNode); 18781Assert.Same(oldNode, newNode); 18807Assert.Same(oldNode, newNode); 18833Assert.Same(oldNode, newNode); 18859Assert.Same(oldNode, newNode); 18885Assert.Same(oldNode, newNode); 18911Assert.Same(oldNode, newNode); 18937Assert.Same(oldNode, newNode); 18963Assert.Same(oldNode, newNode); 18989Assert.Same(oldNode, newNode); 19015Assert.Same(oldNode, newNode); 19041Assert.Same(oldNode, newNode); 19067Assert.Same(oldNode, newNode); 19093Assert.Same(oldNode, newNode); 19119Assert.Same(oldNode, newNode); 19145Assert.Same(oldNode, newNode); 19171Assert.Same(oldNode, newNode); 19197Assert.Same(oldNode, newNode); 19223Assert.Same(oldNode, newNode); 19249Assert.Same(oldNode, newNode); 19275Assert.Same(oldNode, newNode); 19301Assert.Same(oldNode, newNode); 19327Assert.Same(oldNode, newNode); 19353Assert.Same(oldNode, newNode); 19379Assert.Same(oldNode, newNode); 19405Assert.Same(oldNode, newNode); 19431Assert.Same(oldNode, newNode); 19457Assert.Same(oldNode, newNode); 19483Assert.Same(oldNode, newNode); 19509Assert.Same(oldNode, newNode); 19535Assert.Same(oldNode, newNode); 19561Assert.Same(oldNode, newNode); 19587Assert.Same(oldNode, newNode); 19613Assert.Same(oldNode, newNode); 19639Assert.Same(oldNode, newNode); 19665Assert.Same(oldNode, newNode); 19691Assert.Same(oldNode, newNode); 19717Assert.Same(oldNode, newNode); 19743Assert.Same(oldNode, newNode); 19769Assert.Same(oldNode, newNode); 19795Assert.Same(oldNode, newNode); 19821Assert.Same(oldNode, newNode); 19847Assert.Same(oldNode, newNode); 19873Assert.Same(oldNode, newNode); 19899Assert.Same(oldNode, newNode); 19925Assert.Same(oldNode, newNode); 19951Assert.Same(oldNode, newNode); 19977Assert.Same(oldNode, newNode); 20003Assert.Same(oldNode, newNode); 20029Assert.Same(oldNode, newNode); 20055Assert.Same(oldNode, newNode); 20081Assert.Same(oldNode, newNode); 20107Assert.Same(oldNode, newNode); 20133Assert.Same(oldNode, newNode); 20159Assert.Same(oldNode, newNode); 20185Assert.Same(oldNode, newNode); 20211Assert.Same(oldNode, newNode); 20237Assert.Same(oldNode, newNode); 20263Assert.Same(oldNode, newNode); 20289Assert.Same(oldNode, newNode); 20315Assert.Same(oldNode, newNode); 20341Assert.Same(oldNode, newNode); 20367Assert.Same(oldNode, newNode); 20393Assert.Same(oldNode, newNode); 20419Assert.Same(oldNode, newNode); 20445Assert.Same(oldNode, newNode); 20471Assert.Same(oldNode, newNode); 20497Assert.Same(oldNode, newNode); 20523Assert.Same(oldNode, newNode); 20549Assert.Same(oldNode, newNode); 20575Assert.Same(oldNode, newNode); 20601Assert.Same(oldNode, newNode); 20627Assert.Same(oldNode, newNode); 20653Assert.Same(oldNode, newNode); 20679Assert.Same(oldNode, newNode); 20705Assert.Same(oldNode, newNode);
Parsing\CSharpParseOptionsTests.cs (1)
27Assert.Same(newOpt2, newOpt1);
Syntax\SyntaxFactoryTests.cs (10)
688Assert.Same(parseOptions, argList.SyntaxTree.Options); 691Assert.Same(parseOptions, attrArgList.SyntaxTree.Options); 694Assert.Same(parseOptions, bracketedArgList.SyntaxTree.Options); 697Assert.Same(parseOptions, bracketedParamList.SyntaxTree.Options); 700Assert.Same(parseOptions, compUnit.SyntaxTree.Options); 703Assert.Same(parseOptions, expr.SyntaxTree.Options); 706Assert.Same(parseOptions, memberDecl.SyntaxTree.Options); 709Assert.Same(parseOptions, paramList.SyntaxTree.Options); 712Assert.Same(parseOptions, statement.SyntaxTree.Options); 715Assert.Same(parseOptions, typeName.SyntaxTree.Options);
Syntax\SyntaxNodeTests.cs (2)
1494Assert.Same(secondDirective, firstDirective.GetNextDirective()); 1499Assert.Same(secondDirective.GetPreviousDirective(), firstDirective);
Syntax\SyntaxRewriterTests.cs (11)
317Assert.Same(node, node.SyntaxTree.GetRoot()); 326Assert.Same(node1, node1.SyntaxTree.GetRoot()); 330Assert.Same(node2, node2.SyntaxTree.GetRoot()); 338Assert.Same(tree, tree.GetCompilationUnitRoot().ReplaceToken(tokenT, tokenT).SyntaxTree); 342Assert.Same(newRoot, newRoot.SyntaxTree.GetRoot()); 350Assert.Same(tree, tree.GetCompilationUnitRoot().ReplaceNode(typeName, typeName).SyntaxTree); 354Assert.Same(newRoot, newRoot.SyntaxTree.GetRoot()); 545Assert.Same(rewrittenRoot, rewrittenRoot.SyntaxTree.GetRoot()); 560Assert.Same(ifStmt1, expr1.SyntaxTree.GetRoot()); 578Assert.Same(ifStmt2, expr2.SyntaxTree.GetRoot()); 624Assert.Same(ifStmt2, expr2.SyntaxTree.GetRoot());
Syntax\SyntaxTreeTests.cs (12)
133Assert.Same(options, tree.DiagnosticOptions); 148Assert.Same(options, tree.DiagnosticOptions); 150Assert.Same(options, newTree.DiagnosticOptions); 181Assert.Same(ImmutableDictionary<string, ReportDiagnostic>.Empty, tree.DiagnosticOptions); 195Assert.Same(options, tree.DiagnosticOptions); 213Assert.Same(tree, newTree); 235Assert.Same(map, newTree.DiagnosticOptions); 250Assert.Same(newOptions, newTree.Options); 268Assert.Same(newOptions, newTree.Options); 269Assert.Same(Encoding.Unicode, newText.Encoding); 281Assert.Same(newOptions, newTree.Options); 310Assert.Same(Encoding.Unicode, newText.Encoding);
Microsoft.CodeAnalysis.CSharp.Test.Utilities (5)
CompilationTestUtils.cs (4)
143Assert.Same(constructedFrom, constructedMethod.ConstructedFrom); 144Assert.Same(constructedFrom, constructedMethod.OriginalDefinition); 146Assert.Same(constructedFrom, constructedFrom.ConstructedFrom); 147Assert.Same(constructedFrom, constructedFrom.OriginalDefinition);
CSharpTestBase.cs (1)
2545Assert.Same(model, operation.SemanticModel);
Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities (3)
Completion\AbstractCompletionProviderTests.cs (1)
1278Assert.Same(hostDocument, workspace.Documents.Single());
QuickInfo\ToolTipAssert.cs (2)
103Assert.Same(expected.NavigationAction, hyperLink.NavigationAction); 105Assert.Same(actual.NavigationAction, actualTarget.NavigationAction);
Microsoft.CodeAnalysis.EditorFeatures.UnitTests (4)
CodeFixes\CodeFixServiceTests.cs (1)
1100Assert.Same(analyzer, lowPriorityAnalyzer);
MetadataAsSource\AbstractMetadataAsSourceTests.TestContext.cs (1)
157=> Assert.Same(a.FilePath, b.FilePath);
TextEditor\OpenDocumentTests.cs (1)
64Assert.Same(workspace.CurrentSolution, newDocumentWithChanges.Project.Solution);
TextEditor\TryGetDocumentTests.cs (1)
60Assert.Same(text.Container, container);
Microsoft.CodeAnalysis.ExternalAccess.Razor.UnitTests (3)
RazorAnalyzerAssemblyResolverTests.cs (3)
126Assert.Same(expectedAssembly, actualAssembly); 150Assert.Same(assembly1, assembly2); 183Assert.Same(assembly1, assembly2);
Microsoft.CodeAnalysis.Features.Test.Utilities (1)
EditAndContinue\EditAndContinueTestVerifier.cs (1)
522Assert.Same(pair.Key, bodyMatch.OldRoot);
Microsoft.CodeAnalysis.Features.UnitTests (2)
EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (2)
3625Assert.Same(baselineA0, newBaselineA2.GetInitialEmitBaseline()); 3626Assert.Same(baselineB0, newBaselineB2.GetInitialEmitBaseline());
Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (1)
Options\SolutionAnalyzerConfigOptionsUpdaterTests.cs (1)
289Assert.Same(optionsAfterProjectAdded, workspace.CurrentSolution.FallbackAnalyzerOptions);
Microsoft.CodeAnalysis.Scripting.Desktop.UnitTests (1)
MetadataShadowCopyProviderTests.cs (1)
166Assert.Same(metadata1, metadata2);
Microsoft.CodeAnalysis.Scripting.UnitTests (6)
ScriptOptionsTests.cs (6)
179Assert.Same(options, options.WithEmitDebugInformation(true)); 193Assert.Same(options, options.WithFileEncoding(Encoding.ASCII)); 210Assert.Same(options, options.WithAllowUnsafe(allowUnsafe)); 237Assert.Same(options, options.WithCheckOverflow(checkOverflow)); 265Assert.Same(options, options.WithOptimizationLevel(optimizationLevel)); 299Assert.Same(options, options.WithWarningLevel(warningLevel));
Microsoft.CodeAnalysis.Test.Utilities (85)
CommonTestBase.cs (3)
657Assert.Same(model, operation.SemanticModel); 658Assert.Same(model, clonedOperation.SemanticModel); 660Assert.Same(((Operation)operation).OwningSemanticModel, ((Operation)clonedOperation).OwningSemanticModel);
Compilation\CompilationExtensions.cs (2)
308Assert.Same(semanticModel, operation.SemanticModel); 312Assert.Same(semanticModel, semanticModel.ContainingPublicModelOrSelf);
Compilation\ControlFlowGraphVerifier.cs (27)
77Assert.Same(operationRoot, graph.OriginalOperation); 143Assert.Same(graph.Root, currentRegion); 144Assert.Same(currentRegion, block.EnclosingRegion); 146Assert.Same(enclosing, currentRegion.EnclosingRegion); 161Assert.Same(graph.Root, currentRegion); 162Assert.Same(currentRegion, block.EnclosingRegion); 193Assert.Same(block, predecessorBranch.Destination); 197Assert.Same(blocks[predecessor.Ordinal], predecessor); 201Assert.Same(predecessor.ConditionalSuccessor, predecessorBranch); 206Assert.Same(predecessor.FallThroughSuccessor, predecessorBranch); 217Assert.Same(predecessor.FallThroughSuccessor, predecessorBranch); 248Assert.Same(block, conditionalBranch.Source); 251Assert.Same(blocks[conditionalBranch.Destination.Ordinal], conditionalBranch.Destination); 287Assert.Same(block, nextBranch.Source); 290Assert.Same(blocks[nextBranch.Destination.Ordinal], nextBranch.Destination); 331Assert.Same(g, graph.GetLocalFunctionControlFlowGraph(m)); 332Assert.Same(g, graph.GetLocalFunctionControlFlowGraphInScope(m)); 333Assert.Same(graph, g.Parent); 340Assert.Same(pair.Value, graph.GetAnonymousFunctionControlFlowGraph(pair.Key)); 341Assert.Same(pair.Value, graph.GetAnonymousFunctionControlFlowGraphInScope(pair.Key)); 342Assert.Same(graph, pair.Value.Parent); 1417Assert.Same(currentRegion, region); 1437Assert.Same(region.ExceptionType, region.EnclosingRegion.ExceptionType); 1456Assert.Same(region.ExceptionType, region.EnclosingRegion.ExceptionType); 1596Assert.Same(remainedIn1, r); 1608Assert.Same(remainedIn2, r); 1613Assert.Same(remainedIn1.EnclosingRegion, remainedIn2.EnclosingRegion);
Compilation\OperationTreeVerifier.cs (1)
2048Assert.Same(((ICaseClauseOperation)operation).Label, operation.Label);
Compilation\TestOperationVisitor.cs (49)
86Assert.Same(first, forwards.Current); 93Assert.Same(last, reversed.Current); 112Assert.Same(operation.SemanticModel, operation.SemanticModel.ContainingPublicModelOrSelf); 186Assert.Same(root, ((SwitchCaseOperation)root.Parent).Condition); 377Assert.Same(operation.Operation, operation.ChildOperations.Single()); 416Assert.Same(operation.ReturnedValue, operation.ChildOperations.Single()); 497Assert.Same(operation.Operand, operation.ChildOperations.Single()); 509Assert.Same(operation.Operation, operation.ChildOperations.Single()); 572Assert.Same(((IFunctionPointerTypeSymbol)operation.Target.Type).Signature, signature); 583Assert.Same(operation.Value, operation.ChildOperations.Single()); 623Assert.Same(operation.Pointer, operation.ChildOperations.Single()); 686Assert.Same(operation.Member, operation.Field); 695Assert.Same(operation.Member, operation.Method); 709Assert.Same(operation.Member, operation.Property); 717Assert.Same(operation.Member, operation.Event); 756Assert.Same(operation.Operand, operation.ChildOperations.Single()); 864Assert.Same(operation.Operand, operation.ChildOperations.Single()); 920Assert.Same(operation.ValueOperand, operation.ChildOperations.Single()); 941Assert.Same(operation.Body, operation.ChildOperations.Single()); 959Assert.Same(operation.Body, children[0]); 962Assert.Same(operation.IgnoredBody, children[1]); 993Assert.Same(operation.Operation, operation.ChildOperations.Single()); 999Assert.Same(operation.Argument, operation.ChildOperations.Single()); 1011Assert.Same(operation.Exception, operation.ChildOperations.Single()); 1018Assert.Same(operation.Reference, operation.ChildOperations.Single()); 1100Assert.Same(operation.Value, operation.ChildOperations.Single()); 1207Assert.Same(operation.Target, operation.ChildOperations.Single()); 1213Assert.Same(operation.Operand, operation.ChildOperations.Single()); 1234Assert.Same(operation.Instance, operation.ChildOperations.Single()); 1253Assert.Same(operation.Initializer, operation.ChildOperations.Single()); 1266Assert.Same(operation.Initializer, operation.ChildOperations.Single()); 1295Assert.Same(operation.Text, operation.ChildOperations.Single()); 1370Assert.Same(operation.Value, operation.ChildOperations.Single()); 1383Assert.Same(operation.Value, operation.ChildOperations.Single()); 1393Assert.Same(operation.LeftPattern, children[0]); 1394Assert.Same(operation.RightPattern, children[1]); 1401Assert.Same(operation.Pattern, operation.ChildOperations.Single()); 1452Assert.Same(operation.Pattern, operation.ChildOperations.Single()); 1582Assert.Same(((ICaseClauseOperation)operation).Label, operation.Label); 1590Assert.Same(operation.Pattern, operation.ChildOperations.Single()); 1597Assert.Same(operation.Operation, operation.ChildOperations.Single()); 1603Assert.Same(operation.Expression, operation.ChildOperations.Single()); 1615Assert.Same(operation.Target, operation.ChildOperations.Single()); 1671Assert.Same(operation.BlockBody, operation.ChildOperations.Single()); 1676Assert.Same(operation.ExpressionBody, operation.ChildOperations.Single()); 1704Assert.Same(operation.Value, operation.ChildOperations.Single()); 1743Assert.Same(operation.Operand, operation.ChildOperations.Single()); 1772Assert.Same(operation.LeftOperand, children[index++]); 1777Assert.Same(operation.RightOperand, children[index++]);
Diagnostics\CommonDiagnosticAnalyzers.cs (3)
1280Assert.Same(controlFlowGraphAndSymbol.Graph, getControlFlowGraph(operationBlock).Graph); 1312Assert.Same(controlFlowGraph, operationContext.GetControlFlowGraph()); 1318Assert.Same(controlFlowGraph, _controlFlowGraphMapOpt[rootOperation].Graph);
Microsoft.CodeAnalysis.UnitTests (101)
AnalyzerAssemblyLoaderTests.cs (4)
963Assert.Same(delta2B, delta2); 1431Assert.Same(copiedAssembly, assembly); 1560Assert.Same(expected, actual); 1589Assert.Same(expected, actual);
Analyzers\AnalyzerConfigTests.cs (6)
1592Assert.Same(options[0].TreeOptions.Keys.First(), options[1].TreeOptions.Keys.First()); 1593Assert.Same(options[1].TreeOptions.Keys.First(), options[2].TreeOptions.Keys.First()); 1610Assert.Same(options[0].TreeOptions, options[1].TreeOptions); 1611Assert.Same(options[0].AnalyzerOptions, options[1].AnalyzerOptions); 1612Assert.Same(options[1].TreeOptions, options[2].TreeOptions); 1613Assert.Same(options[1].AnalyzerOptions, options[2].AnalyzerOptions);
CachingLookupTests.cs (2)
303Assert.Same(item, getItem()); 341Assert.Same(item, getItem());
Collections\BoxesTest.cs (19)
17Assert.Same(Boxes.Box(true), Boxes.Box(true)); 18Assert.Same(Boxes.Box(false), Boxes.Box(false)); 22Assert.Same(Boxes.Box((byte)0), Boxes.Box((byte)0)); 26Assert.Same(Boxes.Box((sbyte)0), Boxes.Box((sbyte)0)); 30Assert.Same(Boxes.Box((short)0), Boxes.Box((short)0)); 34Assert.Same(Boxes.Box((ushort)0), Boxes.Box((ushort)0)); 38Assert.Same(Boxes.Box(0), Boxes.Box(0)); 39Assert.Same(Boxes.Box(1), Boxes.Box(1)); 40Assert.Same(Boxes.BoxedInt32Zero, Boxes.Box(0)); 41Assert.Same(Boxes.BoxedInt32One, Boxes.Box(1)); 45Assert.Same(Boxes.Box(0u), Boxes.Box(0u)); 49Assert.Same(Boxes.Box(0L), Boxes.Box(0L)); 53Assert.Same(Boxes.Box(0UL), Boxes.Box(0UL)); 57Assert.Same(Boxes.Box(0.0f), Boxes.Box(0.0f)); 62Assert.Same(Boxes.Box(0.0), Boxes.Box(0.0)); 67Assert.Same(Boxes.Box(decimal.Zero), Boxes.Box(0m)); 74Assert.Same(Boxes.Box('\0'), Boxes.Box('\0')); 75Assert.Same(Boxes.Box('*'), Boxes.Box('*')); 76Assert.Same(Boxes.Box('0'), Boxes.Box('0'));
Collections\HashSet\SegmentedHashSet_Generic_Tests`1.cs (2)
450Assert.Same((object)value, (object?)actualValue); 467Assert.Same((object)value, (object?)actualValue);
Collections\ImmutableDictionaryBuilderTestBase.cs (1)
257Assert.Same(collection.SyncRoot, collection.SyncRoot);
Collections\ImmutableDictionaryTestBase.cs (2)
145Assert.Same(dictionary.SyncRoot, dictionary.SyncRoot); 245Assert.Same(EqualityComparer<V>.Default, GetValueComparer(empty));
Collections\ImmutableDictionaryTestBase.nonnetstandard.cs (1)
295Assert.Same(nonGeneric.SyncRoot, nonGeneric.SyncRoot);
Collections\ImmutableListTestBase.cs (1)
514Assert.Same(collection.SyncRoot, collection.SyncRoot);
Collections\ImmutableSegmentedDictionaryTest.cs (4)
120Assert.Same(EqualityComparer<string>.Default, dictionary.KeyComparer); 124Assert.Same(keyComparer, dictionary.KeyComparer); 130Assert.Same(EqualityComparer<string>.Default, dictionary.KeyComparer); 136Assert.Same(keyComparer, dictionary.KeyComparer);
Collections\ImmutableSegmentedDictionaryTest.nonnetstandard.cs (1)
39Assert.Same(EqualityComparer<TKey>.Default, empty.GetKeyComparer());
Collections\ImmutableSegmentedHashSetTest.nonnetstandard.cs (1)
46Assert.Same(comparer ?? EqualityComparer<T>.Default, GetEqualityComparer(emptySet));
Collections\ImmutableSetTest.cs (1)
204Assert.Same(builder.SyncRoot, builder.SyncRoot);
Collections\ImmutableSetTest.nonnetstandard.cs (1)
101Assert.Same(expected, actual);
Collections\ImmutablesTestBase.cs (1)
40Assert.Same((object?)expected, (object?)actual); //, message, formattingArgs);
Collections\List\ICollection.NonGeneric.Tests.cs (1)
150Assert.Same(collection.SyncRoot, collection.SyncRoot);
Collections\List\SegmentedList.Generic.Tests.Capacity.cs (2)
81Assert.Same(resizedSegments[i], oldSegments[i]); 106Assert.Same(resizedSegments[0], oldSegments[0]);
Collections\SegmentedArrayTests.cs (2)
99Assert.Same(Array.Empty<byte[]>(), SegmentedCollectionsMarshal.AsSegments(new SegmentedArray<byte>(0))); 129Assert.Same(SegmentedCollectionsMarshal.AsSegments(data), data.SyncRoot);
CommonCommandLineParserTests.cs (1)
1266Assert.Same(arg, memoryString);
Emit\EmitOptionsTests.cs (1)
38Assert.Same(newOpt1_alias, newOpt1);
InternalUtilities\ConcurrentDictionaryExtensionsTests.cs (4)
31Assert.Same(first, dictionary.GetOrAdd(0, static (key, arg) => arg, first)); 32Assert.Same(first, dictionary[0]); 34Assert.Same(first, dictionary.GetOrAdd(0, static (key, arg) => arg, second)); 35Assert.Same(first, dictionary[0]);
InternalUtilities\WeakListTests.cs (1)
95Assert.Same(b.GetReference(), nonWeakList[0]);
MetadataReferences\MetadataReferenceTests.cs (19)
214Assert.Same(DocumentationProvider.Default, r.DocumentationProvider); 231Assert.Same(doc, r.DocumentationProvider); 258Assert.Same(doc, r.DocumentationProvider); 259Assert.Same(doc, r.DocumentationProvider); 267Assert.Same(r, r1); 271Assert.Same(r, r2); 275Assert.Same(r, r3); 297Assert.Same(doc, r.DocumentationProvider); 298Assert.Same(doc, r.DocumentationProvider); 310Assert.Same(r.DocumentationProvider, r3.DocumentationProvider); 311Assert.Same(r.GetMetadataNoCopy(), r3.GetMetadataNoCopy()); 318Assert.Same(r.DocumentationProvider, r4.DocumentationProvider); 319Assert.Same(r.GetMetadataNoCopy(), r4.GetMetadataNoCopy()); 347Assert.Same(c, r1.Compilation); 353Assert.Same(c, r2.Compilation); 359Assert.Same(c, r3.Compilation); 378Assert.Same(c, r1.Compilation); 384Assert.Same(c, r2.Compilation); 390Assert.Same(c, r3.Compilation);
StringTableTests.cs (9)
25Assert.Same(s1, s2); 46Assert.Same(s1, s2); 49Assert.Same(s2, s3); 52Assert.Same(s3, s4); 55Assert.Same(s4, s5); 64Assert.Same(s1, s2); 74Assert.Same(s1, s2); 84Assert.Same(s1, s2); 139Assert.Same(s1, s2);
Text\SourceTextTests.cs (9)
46Assert.Same(string.Empty, text.ToString()); 56Assert.Same(s_utf8, SourceText.From(HelloWorld, s_utf8).Encoding); 57Assert.Same(s_unicode, SourceText.From(HelloWorld, s_unicode).Encoding); 60Assert.Same(s_unicode, SourceText.From(bytes, bytes.Length, s_unicode).Encoding); 64Assert.Same(s_unicode, SourceText.From(stream, s_unicode).Encoding); 360Assert.Same(s_utf8, SourceText.From(actual, expected.Length, s_utf8).Encoding); 361Assert.Same(s_unicode, SourceText.From(actual, expected.Length, s_unicode).Encoding); 379Assert.Same(s_utf8, SourceText.From(actual, expected.Length, s_utf8).Encoding); 380Assert.Same(s_unicode, SourceText.From(actual, expected.Length, s_unicode).Encoding);
Text\TextChangeTests.cs (5)
221Assert.Same(Encoding.Unicode, subText.Encoding); 264Assert.Same(Encoding.Unicode, newText.Encoding); 608Assert.Same(chunk1, GetChunks(newText)[0]); 662Assert.Same(change1, change2); // this was a no-op and returned the same instance 673Assert.Same(change1, change2); // this was a no-op and returned the same instance
Microsoft.CodeAnalysis.VisualBasic.Scripting.UnitTests (1)
ScriptTests.vb (1)
48Assert.Same(script, state.Script)
Microsoft.CodeAnalysis.VisualBasic.Test.Utilities (2)
BasicTestBase.vb (2)
804Assert.Same(semanticModel, operation.SemanticModel) 936Assert.Same(semanticModel, operation.SemanticModel)
Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (8)
VisualStudioMSBuildWorkspaceTests.cs (8)
132Assert.Same(p0mscorlib, p1mscorlib); 170Assert.Same(p1Sys1, p2Sys1); 183Assert.Same(mdp1Sys1.Id, mdp1Sys2.Id); 184Assert.Same(mdp1Sys1.Id, mdp2Sys1.Id); 185Assert.Same(mdp1Sys1.Id, mdp2Sys3.Id); 2884Assert.Same(text.Encoding, doc3text.Encoding); 2886Assert.Same(text.Encoding, doc3tree.Encoding); 2887Assert.Same(text.Encoding, doc3tree.GetText().Encoding);
Microsoft.CodeAnalysis.Workspaces.UnitTests (96)
ObjectSerializationTests.cs (3)
737Assert.Same(string1, string6); 738Assert.Same(string2, string5); 739Assert.Same(string3, string4);
Options\CodeStyleOptionTests.cs (4)
15Assert.Same(CodeStyleOption2.FalseWithSilentEnforcement.WithValue(true), CodeStyleOption2.TrueWithSilentEnforcement); 16Assert.Same(CodeStyleOption2.TrueWithSilentEnforcement.WithValue(false), CodeStyleOption2.FalseWithSilentEnforcement); 18Assert.Same(CodeStyleOption2.FalseWithSuggestionEnforcement.WithValue(true), CodeStyleOption2.TrueWithSuggestionEnforcement); 19Assert.Same(CodeStyleOption2.TrueWithSuggestionEnforcement.WithValue(false), CodeStyleOption2.FalseWithSuggestionEnforcement);
Options\OptionKeyTests.cs (6)
46Assert.Same(storage1, option.StorageLocations[0]); 47Assert.Same(storage2, option.StorageLocations[1]); 48Assert.Same(storage3, option.StorageLocations[2]); 59Assert.Same(storage1, option.StorageLocations[0]); 60Assert.Same(storage2, option.StorageLocations[1]); 61Assert.Same(storage3, option.StorageLocations[2]);
SolutionTests\ProjectInfoTests.cs (4)
77Assert.Same(documentInfo, ((ImmutableArray<DocumentInfo>)info1.Documents).Single()); 96Assert.Same(documentInfo, ((ImmutableArray<DocumentInfo>)info1.AdditionalDocuments).Single()); 115Assert.Same(projectReference, ((ImmutableArray<ProjectReference>)info1.ProjectReferences).Single()); 134Assert.Same(metadataReference, ((ImmutableArray<MetadataReference>)info1.MetadataReferences).Single());
SolutionTests\SolutionInfoTests.cs (1)
35Assert.Same(projectInfo, ((ImmutableArray<ProjectInfo>)info1.Projects).Single());
SolutionTests\SolutionTestHelpers.cs (6)
34Assert.Same(instanceWithValue2, instanceWithValue); 58Assert.Same(boxedItems, getter(instanceWithItem)); 60Assert.Same(instanceWithNoItem, factory(instanceWithNoItem, null)); 61Assert.Same(instanceWithNoItem, factory(instanceWithNoItem, [])); 62Assert.Same(instanceWithNoItem, factory(instanceWithNoItem, [])); 77Assert.Same(boxedDupItems, getter(factory(instanceWithNoItem, boxedDupItems)));
SolutionTests\SolutionTests.cs (54)
180Assert.Same(newSolution1, newSolution2); 200Assert.Same(newSolution2, newSolution1); 207Assert.Same(newSolution3, newSolution4); 210Assert.Same(newSolution3, newSolution5); 232Assert.Same(newSolution1, newSolution2); 253Assert.Same(solution, solution.WithDocumentSourceCodeKind(documentId, SourceCodeKind.Regular)); 315Assert.Same(newSolution1, newSolution2); 357Assert.Same(newSolution1, newSolution2); 377Assert.Same(textAndVersion.Text, actualText); 381Assert.Same(newSolution1, newSolution2); 400Assert.Same(text, actualText); 403Assert.Same(newSolution1, newSolution2); 406Assert.Same(solution, solution.WithDocumentText([null!], text)); 407Assert.Same(solution, solution.WithDocumentText([s_unrelatedDocumentId], text)); 922Assert.Same(text, actualText); 925Assert.Same(newSolution1, newSolution2); 945Assert.Same(textAndVersion.Text, actualText); 949Assert.Same(newSolution1, newSolution2); 968Assert.Same(text, actualText); 971Assert.Same(newSolution1, newSolution2); 991Assert.Same(textAndVersion.Text, actualText); 995Assert.Same(newSolution1, newSolution2); 1445Assert.Same(newSolution, newSolution.WithProjectAssemblyName(projectId, assemblyName)); 1930Assert.Same(projectRefs, solution2.GetProject(projectId)!.AllProjectReferences); 1950Assert.Same(projectRefs, newSolution1.GetProject(projectId)!.AllProjectReferences); 1976Assert.Same(solution, solution2); 2095Assert.Same(solution, solution2); 2165Assert.Same(solution, solution2); 2175Assert.Same(solution, solution2); 2233Assert.Same(solution, solution2); 2243Assert.Same(solution, solution2); 2703Assert.Same(solution, solution.RemoveDocuments([])); 3076Assert.Same(newParseOptions, newUpdatedParseOptions); 3276Assert.Same(tree, tree.WithRootAndOptions(root, tree.Options)); 3277Assert.Same(tree, tree.WithFilePath(tree.FilePath)); 3809Assert.Same(tree2, tree2.GetRoot().SyntaxTree); 3810Assert.Same(tree.Options, tree2.Options); 3811Assert.Same(tree.Encoding, tree2.Encoding); 3816Assert.Same(tree, tree.WithFilePath("old path")); 3837Assert.Same(tree3, tree3.GetRoot().SyntaxTree); 3838Assert.Same(tree.Options, tree3.Options); 3839Assert.Same(tree.Encoding, tree3.Encoding); 3848Assert.Same(tree4, tree4.GetRoot().SyntaxTree); 3849Assert.Same(newOptions, tree4.Options); 3850Assert.Same(tree.Encoding, tree4.Encoding); 3855Assert.Same(tree, tree.WithRootAndOptions(tree.GetRoot(), tree.Options)); 4156Assert.Same(frozenDocument, frozenDocument2); 4317Assert.Same(await frozenDocument.GetSyntaxTreeAsync(), singleTree); 4735Assert.Same(originalSyntaxTree, newSyntaxTree); 4902Assert.Same(originalSyntaxTree, newSyntaxTree); 5099Assert.Same(compilation1, compilation1New); 5275Assert.Same(compilation1, compilation1New); 5502Assert.Same(newDocText, sameText); 5506Assert.Same(newDocText, treeText);
SolutionTests\SolutionWithSourceGeneratorTests.cs (7)
355Assert.Same(partialProject, project); 494Assert.Same(generatedTreeBeforeChange, generatedTreeAfterChange); 554Assert.Same(cachedStateAfterFirstChange, cachedStateAfterSecondChange); 601Assert.Same(differentOpenTextContainer.CurrentText, await generatedDocument.GetTextAsync()); 625Assert.Same(workspace.CurrentSolution, generatedDocument!.Project.Solution); 649Assert.Same(differentOpenTextContainer.CurrentText, await generatedDocument.GetTextAsync()); 937Assert.Same(project.Solution, frozenSolution.Project.Solution);
SolutionTests\TextLoaderTests.cs (3)
119Assert.Same(LoaderOverridesObsolete.Value, await loader.LoadTextAndVersionAsync(workspace: null, documentId: null, CancellationToken.None)); 127Assert.Same(LoaderOverridesObsolete2.Value, await loader.LoadTextAndVersionAsync(workspace: null, documentId: null, CancellationToken.None)); 135Assert.Same(LoaderOverridesNew.Value, await loader.LoadTextAndVersionAsync(workspace: null, documentId: null, CancellationToken.None));
TestCompositionTests.cs (1)
20Assert.Same(composition1.ExportProviderFactory, composition2.ExportProviderFactory);
UtilityTest\CancellationSeriesTests.cs (1)
128Assert.Same(exception, aggregateException.InnerExceptions.Single());
WorkspaceServiceTests\ReferenceCountedDisposableTests.cs (1)
30Assert.Same(target, reference.Target);
WorkspaceTests\AdhocWorkspaceTests.cs (5)
49Assert.Same(project, ws.CurrentSolution.Projects.FirstOrDefault()); 94Assert.Same(ws.CurrentSolution, solution); 234Assert.Same(text, currentText); 268Assert.Same(text, currentText); 307Assert.Same(text, currentText);
Microsoft.DotNet.Open.Api.Tools.Tests (1)
OpenApiAddFileTests.cs (1)
98Assert.Same(openApiRefs[0].ParentNode, openApiRefs[1].ParentNode);
Microsoft.DotNet.XUnitAssert.Tests (27)
EqualityAssertsTests.cs (2)
579 Assert.Same(obj2, obj1.Equals_Other); 2918 Assert.Same(obj2, obj1.Equals_Other);
ExceptionAssertsTests.cs (19)
61 Assert.Same(thrown, ex.InnerException); 79 Assert.Same(thrown, ex.InnerException); 144 Assert.Same(thrown, ex.InnerException); 162 Assert.Same(thrown, ex.InnerException); 217 Assert.Same(thrown, ex.InnerException); 235 Assert.Same(thrown, ex.InnerException); 297 Assert.Same(thrown, ex.InnerException); 315 Assert.Same(thrown, ex.InnerException); 386 Assert.Same(thrown, ex.InnerException); 404 Assert.Same(thrown, ex.InnerException); 472 Assert.Same(thrown, ex.InnerException); 490 Assert.Same(thrown, ex.InnerException); 544 Assert.Same(thrown, ex.InnerException); 614 Assert.Same(thrown, ex.InnerException); 674 Assert.Same(thrown, ex.InnerException); 733 Assert.Same(thrown, ex.InnerException); 751 Assert.Same(thrown, ex.InnerException); 819 Assert.Same(thrown, ex.InnerException); 837 Assert.Same(thrown, ex.InnerException);
IdentityAssertsTests.cs (3)
34 Assert.Same(actual, actual); 40 var ex = Record.Exception(() => Assert.Same("bob", "jim")); 55 Assert.Throws<SameException>(() => Assert.Same(0, 0));
TypeAssertsTests.cs (3)
62 Assert.Same(ex, result); 131 Assert.Same(ex, result); 360 Assert.Same(ex, result);
Microsoft.Extensions.AI.Abstractions.Tests (129)
ChatCompletion\ChatClientExtensionsTests.cs (3)
115Assert.Same(expectedOptions, options); 125Assert.Same(expectedResponse, response); 142Assert.Same(expectedOptions, options);
ChatCompletion\ChatClientMetadataTests.cs (1)
26Assert.Same(uri, providerMetadata.ProviderUri);
ChatCompletion\ChatMessageTests.cs (11)
24Assert.Same(message.Contents, message.Contents); 40Assert.Same(message.Contents, message.Contents); 96Assert.Same(message.Contents, message.Contents); 180Assert.Same(contents, message.Contents); 183Assert.Same(contents, message.Contents); 200Assert.Same(raw, message.RawRepresentation); 203Assert.Same(raw, message.RawRepresentation); 209Assert.Same(raw, message.RawRepresentation); 221Assert.Same(props, message.AdditionalProperties); 224Assert.Same(props, message.AdditionalProperties); 230Assert.Same(props, message.AdditionalProperties);
ChatCompletion\ChatOptionsTests.cs (9)
106Assert.Same(ChatResponseFormat.Json, options.ResponseFormat); 108Assert.Same(stopSequences, options.StopSequences); 110Assert.Same(ChatToolMode.RequireAny, options.ToolMode); 111Assert.Same(tools, options.Tools); 112Assert.Same(rawRepresentationFactory, options.RawRepresentationFactory); 113Assert.Same(additionalProps, options.AdditionalProperties); 124Assert.Same(ChatResponseFormat.Json, clone.ResponseFormat); 128Assert.Same(ChatToolMode.RequireAny, clone.ToolMode); 130Assert.Same(rawRepresentationFactory, clone.RawRepresentationFactory);
ChatCompletion\ChatResponseFormatTests.cs (2)
17Assert.Same(ChatResponseFormat.Text, ChatResponseFormat.Text); 18Assert.Same(ChatResponseFormat.Json, ChatResponseFormat.Json);
ChatCompletion\ChatResponseTests.cs (6)
35Assert.Same(response.Messages, response.Messages); 39Assert.Same(messages, response.Messages); 44Assert.Same(messages, response.Messages); 71Assert.Same(usage, response.Usage); 76Assert.Same(raw, response.RawRepresentation); 81Assert.Same(additionalProps, response.AdditionalProperties);
ChatCompletion\ChatResponseUpdateTests.cs (5)
47Assert.Same(update.Contents, update.Contents); 50Assert.Same(newList, update.Contents); 60Assert.Same(raw, update.RawRepresentation); 65Assert.Same(props, update.AdditionalProperties); 108Assert.Same(textContent, update.Contents[3]);
ChatCompletion\ChatToolModeTests.cs (3)
14Assert.Same(ChatToolMode.Auto, ChatToolMode.Auto); 15Assert.Same(ChatToolMode.None, ChatToolMode.None); 16Assert.Same(ChatToolMode.RequireAny, ChatToolMode.RequireAny);
ChatCompletion\DelegatingChatClientTests.cs (10)
33Assert.Same(expectedChatContents, chatContents); 34Assert.Same(expectedChatOptions, options); 49Assert.Same(expectedResponse, await resultTask); 69Assert.Same(expectedChatContents, chatContents); 70Assert.Same(expectedChatOptions, options); 84Assert.Same(expectedResults[0], enumerator.Current); 86Assert.Same(expectedResults[1], enumerator.Current); 109Assert.Same(delegating, client); 129Assert.Same(expectedResult, client); 151Assert.Same(expectedResult, tzi);
Contents\AIContentTests.cs (2)
27Assert.Same(raw, c.RawRepresentation); 32Assert.Same(props, c.AdditionalProperties);
Contents\FunctionCallContentTests..cs (9)
45Assert.Same(args, c.Arguments); 56Assert.Same(raw, c.RawRepresentation); 61Assert.Same(props, c.AdditionalProperties); 68Assert.Same(args, c.Arguments); 73Assert.Same(e, c.Exception); 207Assert.Same(result, arguments); 225Assert.Same(result, arguments); 243Assert.Same(result, arguments); 312Assert.Same(exc, content.Exception.InnerException);
Contents\FunctionResultContentTests.cs (3)
42Assert.Same(raw, c.RawRepresentation); 47Assert.Same(props, c.AdditionalProperties); 58Assert.Same(e, c.Exception);
Contents\TextContentTests.cs (2)
30Assert.Same(raw, c.RawRepresentation); 35Assert.Same(props, c.AdditionalProperties);
Contents\TextReasoningContentTests.cs (2)
30Assert.Same(raw, c.RawRepresentation); 35Assert.Same(props, c.AdditionalProperties);
Contents\UsageContentTests.cs (4)
25Assert.Same(c.Details, c.Details); 41Assert.Same(details, c.Details); 45Assert.Same(details2, c.Details); 58Assert.Same(d, c.Details);
Embeddings\BinaryEmbeddingTests.cs (4)
20Assert.Same(vector, e.Vector); 33Assert.Same(vector, e.Vector); 36Assert.Same(newVector, e.Vector); 50Assert.Same(props, e.AdditionalProperties);
Embeddings\DelegatingEmbeddingGeneratorTests.cs (5)
33Assert.Same(expectedInput, input); 48Assert.Same(expectedEmbedding, await resultTask); 70Assert.Same(delegating, service); 90Assert.Same(expectedResult, service); 112Assert.Same(expectedResult, service);
Embeddings\EmbeddingGenerationOptionsTests.cs (1)
50Assert.Same(additionalProps, options.AdditionalProperties);
Embeddings\EmbeddingGeneratorExtensionsTests.cs (2)
97Assert.Same(result, await service.GenerateAsync("hello")); 125Assert.Same(embeddings[i], results[i].Embedding);
Embeddings\EmbeddingGeneratorMetadataTests.cs (1)
27Assert.Same(uri, metadata.ProviderUri);
Embeddings\EmbeddingTests.cs (2)
31Assert.Same(props, e.AdditionalProperties); 35Assert.Same(floats, array.Array);
Embeddings\GeneratedEmbeddingsTests.cs (16)
69Assert.Same(embeddings[0], generatedEmbeddings[0]); 70Assert.Same(embeddings[1], generatedEmbeddings[1]); 89Assert.Same(e, generatedEmbeddings[2]); 101Assert.Same(usage, embeddings.Usage); 108Assert.Same(props, embeddings.AdditionalProperties); 121Assert.Same(e, embeddings[0]); 135Assert.Same(e1, embeddings[0]); 136Assert.Same(e2, embeddings[1]); 168Assert.Same(e2, embeddings[0]); 172Assert.Same(e2, embeddings[0]); 191Assert.Same(e2, embeddings[0]); 211Assert.Same(e3, embeddings[1]); 212Assert.Same(e2, embeddings[2]); 229Assert.Same(e1, embeddings[0]); 230Assert.Same(e3, embeddings[1]); 262Assert.Same(expectedGeneratedEmbeddings, actual);
Functions\AIFunctionArgumentsTests.cs (1)
58Assert.Same(sp, args.Services);
SpeechToText\DelegatingSpeechToTextClientTests.cs (10)
34Assert.Same(expectedAudioSpeechStream, audioSpeechStream); 35Assert.Same(expectedOptions, options); 50Assert.Same(expectedResponse, await resultTask); 70Assert.Same(expectedAudioSpeechStream, audioSpeechStream); 71Assert.Same(expectedOptions, options); 85Assert.Same(expectedResults[0], enumerator.Current); 87Assert.Same(expectedResults[1], enumerator.Current); 110Assert.Same(delegating, client); 130Assert.Same(expectedResult, client); 152Assert.Same(expectedResult, tzi);
SpeechToText\SpeechToTextClientMetadataTests.cs (1)
26Assert.Same(uri, metadata.ProviderUri);
SpeechToText\SpeechToTextOptionsTests.cs (1)
45Assert.Same(additionalProps, options.AdditionalProperties);
SpeechToText\SpeechToTextResponseTests.cs (7)
27Assert.Same(response.Contents, response.Contents); 44Assert.Same(response.Contents, response.Contents); 81Assert.Same(response.Contents, response.Contents); 116Assert.Same(raw, response.RawRepresentation); 121Assert.Same(additionalProps, response.AdditionalProperties); 135Assert.Same(newContents, response.Contents); 140Assert.Same(usageDetails, response.Usage);
SpeechToText\SpeechToTextResponseUpdateTests.cs (2)
44Assert.Same(newList, update.Contents); 80Assert.Same(textContent, update.Contents[3]);
Utilities\AIJsonSchemaTransformCacheTests.cs (1)
29Assert.Same(options, cache.TransformOptions);
Utilities\AIJsonUtilitiesTests.cs (3)
34Assert.Same(options, AIJsonUtilities.DefaultOptions); 45Assert.Same(JavaScriptEncoder.UnsafeRelaxedJsonEscaping, options.Encoder); 434Assert.Same(options.TypeInfoResolver, AIJsonUtilities.DefaultOptions.TypeInfoResolver);
Microsoft.Extensions.AI.AzureAIInference.Tests (9)
AzureAIInferenceChatClientTests.cs (3)
70Assert.Same(chatClient, chatClient.GetService<IChatClient>()); 71Assert.Same(client, chatClient.GetService<ChatCompletionsClient>()); 86Assert.Same(client, pipeline.GetService<ChatCompletionsClient>());
AzureAIInferenceEmbeddingGeneratorTests.cs (3)
52Assert.Same(embeddingGenerator, embeddingGenerator.GetService<IEmbeddingGenerator<string, Embedding<float>>>()); 53Assert.Same(client, embeddingGenerator.GetService<EmbeddingsClient>()); 65Assert.Same(client, pipeline.GetService<EmbeddingsClient>());
AzureAIInferenceImageEmbeddingGeneratorTests.cs (3)
52Assert.Same(embeddingGenerator, embeddingGenerator.GetService<IEmbeddingGenerator<DataContent, Embedding<float>>>()); 53Assert.Same(client, embeddingGenerator.GetService<ImageEmbeddingsClient>()); 65Assert.Same(client, pipeline.GetService<ImageEmbeddingsClient>());
Microsoft.Extensions.AI.Ollama.Tests (8)
OllamaChatClientTests.cs (5)
35Assert.Same(client.ToolCallJsonSerializerOptions, AIJsonUtilities.DefaultOptions); 40Assert.Same(options, client.ToolCallJsonSerializerOptions); 48Assert.Same(client, client.GetService<OllamaChatClient>()); 49Assert.Same(client, client.GetService<IChatClient>()); 63Assert.Same(client, pipeline.GetService<OllamaChatClient>());
OllamaEmbeddingGeneratorTests.cs (3)
29Assert.Same(generator, generator.GetService<OllamaEmbeddingGenerator>()); 30Assert.Same(generator, generator.GetService<IEmbeddingGenerator<string, Embedding<float>>>()); 42Assert.Same(generator, pipeline.GetService<OllamaEmbeddingGenerator>());
Microsoft.Extensions.AI.OpenAI.Tests (20)
OpenAIAssistantChatClientTests.cs (2)
58Assert.Same(assistantClient, chatClient.GetService<AssistantClient>()); 74Assert.Same(assistantClient, pipeline.GetService<AssistantClient>());
OpenAIChatClientTests.cs (6)
64Assert.Same(chatClient, chatClient.GetService<IChatClient>()); 66Assert.Same(openAIClient, chatClient.GetService<ChatClient>()); 82Assert.Same(openAIClient, pipeline.GetService<ChatClient>()); 92Assert.Same(chatClient, chatClient.GetService<IChatClient>()); 93Assert.Same(openAIClient, chatClient.GetService<ChatClient>()); 107Assert.Same(openAIClient, pipeline.GetService<ChatClient>());
OpenAIEmbeddingGeneratorTests.cs (6)
58Assert.Same(embeddingGenerator, embeddingGenerator.GetService<IEmbeddingGenerator<string, Embedding<float>>>()); 60Assert.Same(openAIClient, embeddingGenerator.GetService<EmbeddingClient>()); 74Assert.Same(openAIClient, pipeline.GetService<EmbeddingClient>()); 84Assert.Same(embeddingGenerator, embeddingGenerator.GetService<IEmbeddingGenerator<string, Embedding<float>>>()); 85Assert.Same(openAIClient, embeddingGenerator.GetService<EmbeddingClient>()); 97Assert.Same(openAIClient, pipeline.GetService<EmbeddingClient>());
OpenAIResponseClientTests.cs (3)
57Assert.Same(chatClient, chatClient.GetService<IChatClient>()); 58Assert.Same(openAIClient, chatClient.GetService<OpenAIResponseClient>()); 72Assert.Same(openAIClient, pipeline.GetService<OpenAIResponseClient>());
OpenAISpeechToTextClientTests.cs (3)
53Assert.Same(speechToTextClient, speechToTextClient.GetService<ISpeechToTextClient>()); 54Assert.Same(audioClient, speechToTextClient.GetService<AudioClient>()); 63Assert.Same(audioClient, pipeline.GetService<AudioClient>());
Microsoft.Extensions.AI.Tests (87)
ChatCompletion\ChatClientBuilderTest.cs (5)
21Assert.Same(expectedServiceProvider, services); 27Assert.Same(expectedServiceProvider, serviceProvider); 28Assert.Same(expectedInnerClient, innerClient); 32Assert.Same(expectedOuterClient, builder.Build(expectedServiceProvider)); 55Assert.Same(expectedInnerClient, third.InnerClient);
ChatCompletion\ConfigureOptionsChatClientTests.cs (4)
45Assert.Same(returnedOptions, options); 52Assert.Same(returnedOptions, options); 77Assert.Same(expectedResponse, response); 84Assert.Same(expectedUpdates[i++], e.Current);
ChatCompletion\DependencyInjectionPatterns.cs (8)
32Assert.Same(instance, instance1Copy); 33Assert.Same(instance, instance2); 56Assert.Same(instance, instance1Copy); 57Assert.Same(instance, instance2); 81Assert.Same(instance, instance1Copy); 82Assert.Same(instance, instance2); 107Assert.Same(instance, instance1Copy); 108Assert.Same(instance, instance2);
ChatCompletion\DistributedCachingChatClientTest.cs (1)
97Assert.Same(expectedResponse, result1);
ChatCompletion\FunctionInvocationContextTests.cs (3)
49Assert.Same(messages, ctx.Messages); 53Assert.Same(function, ctx.Function); 57Assert.Same(callContent, ctx.CallContent);
ChatCompletion\FunctionInvokingChatClientTests.cs (4)
562Assert.Same(activities[activities.Count - 1], activities[i].Parent); 736Assert.Same(function, context.Function); 867Assert.Same(expected, actual); 901Assert.Same(ctx, SynchronizationContext.Current);
ChatCompletion\LoggingChatClientTests.cs (1)
30Assert.Same(innerClient, innerClient.AsBuilder().UseLogging(NullLoggerFactory.Instance).Build().GetService(typeof(IChatClient)));
ChatCompletion\UseDelegateChatClientTests.cs (22)
38Assert.Same(expectedMessages, messages); 39Assert.Same(expectedOptions, options); 47Assert.Same(expectedMessages, messages); 48Assert.Same(expectedOptions, options); 58Assert.Same(expectedMessages, messages); 59Assert.Same(expectedOptions, options); 87Assert.Same(expectedMessages, messages); 88Assert.Same(expectedOptions, options); 98Assert.Same(expectedMessages, messages); 99Assert.Same(expectedOptions, options); 129Assert.Same(expectedMessages, messages); 130Assert.Same(expectedOptions, options); 140Assert.Same(expectedMessages, messages); 141Assert.Same(expectedOptions, options); 180Assert.Same(expectedMessages, messages); 181Assert.Same(expectedOptions, options); 189Assert.Same(expectedMessages, messages); 190Assert.Same(expectedOptions, options); 201Assert.Same(expectedMessages, messages); 202Assert.Same(expectedOptions, options); 211Assert.Same(expectedMessages, messages); 212Assert.Same(expectedOptions, options);
Embeddings\ConfigureOptionsEmbeddingGeneratorTests.cs (2)
42Assert.Same(returnedOptions, options); 67Assert.Same(expectedEmbeddings, embeddings);
Embeddings\EmbeddingGeneratorBuilderTests.cs (3)
21Assert.Same(expectedServiceProvider, services); 27Assert.Same(expectedServiceProvider, services); 54Assert.Same(expectedInnerGenerator, third.InnerGenerator);
Embeddings\LoggingEmbeddingGeneratorTests.cs (1)
29Assert.Same(innerGenerator, innerGenerator.AsBuilder().UseLogging(NullLoggerFactory.Instance).Build().GetService(typeof(IEmbeddingGenerator<string, Embedding<float>>)));
Embeddings\UseDelegateEmbeddingGeneratorTests.cs (5)
37Assert.Same(expectedValues, values); 38Assert.Same(expectedOptions, options); 48Assert.Same(expectedValues, values); 49Assert.Same(expectedOptions, options); 61Assert.Same(expectedEmbeddings, actual);
Functions\AIFunctionFactoryTest.cs (15)
155Assert.Same(dotnetFunc.Method, func.UnderlyingMethod); 161Assert.Same(dotnetFunc2.Method, func.UnderlyingMethod); 167Assert.Same(dotnetFunc3.Method, func.UnderlyingMethod); 190Assert.Same(metadata, options.AdditionalProperties); 191Assert.Same(getBindParameterMode, options.ConfigureParameterBinding); 198Assert.Same(dotnetFunc.Method, func.UnderlyingMethod); 258Assert.Same(sp, services1); 259Assert.Same(sp, services2); 260Assert.Same(sp, services3); 261Assert.Same(sp, services4); 263Assert.Same(arguments, arguments1); 264Assert.Same(arguments, arguments2); 265Assert.Same(arguments, arguments3); 266Assert.Same(arguments, arguments4); 335Assert.Same(mat, result?.Item2);
SpeechToText\ConfigureOptionsSpeechToTextClientTests.cs (4)
46Assert.Same(returnedOptions, options); 53Assert.Same(returnedOptions, options); 79Assert.Same(expectedResponse, response); 87Assert.Same(expectedUpdates[i++], e.Current);
SpeechToText\LoggingSpeechToTextClientTests.cs (1)
32Assert.Same(innerClient, innerClient.AsBuilder().UseLogging(NullLoggerFactory.Instance).Build().GetService(typeof(ISpeechToTextClient)));
SpeechToText\SpeechToTextClientDependencyInjectionPatterns.cs (8)
32Assert.Same(instance, instance1Copy); 33Assert.Same(instance, instance2); 56Assert.Same(instance, instance1Copy); 57Assert.Same(instance, instance2); 81Assert.Same(instance, instance1Copy); 82Assert.Same(instance, instance2); 107Assert.Same(instance, instance1Copy); 108Assert.Same(instance, instance2);
Microsoft.Extensions.AsyncState.Tests (10)
AsyncContextTests.cs (10)
29Assert.Same(obj1, context1.Get()); 53Assert.Same(obj1, context1.Get()); 80Assert.Same(obj1, context1.Get()); 82Assert.Same(obj2, context2.Get()); 108Assert.Same(obj1, ctx1); 133Assert.Same(obj1, context1.Get()); 135Assert.Same(obj2, context2.Get()); 199await Task.Run(() => Assert.Same(obj, context.Get())); 215await Task.Run(() => Assert.Same(obj, context.Get())); 243Assert.Same(obj2, context.Get());
Microsoft.Extensions.Caching.Hybrid.Tests (11)
L2Tests.cs (2)
62Assert.Same(s, x); 84Assert.Same(s, x);
SampleUsage.cs (1)
86Assert.Same(x, y);
SerializerTests.cs (1)
272Assert.Same(expectedOptionsObj, json.Options);
SizeTests.cs (4)
64Assert.Same(expected, actual); 76Assert.Same(expected, actual); 187Assert.Same(first, second); 253Assert.Same(first, second);
StampedeTests.cs (3)
360Assert.Same(first, second); 400Assert.Same(first, second); 408Assert.Same(x, y); // same instance regardless of whether the tasks were shared
Microsoft.Extensions.Caching.SqlServer.Tests (1)
SqlServerCacheServicesExtensionsTest.cs (1)
60Assert.Same(services, services.AddDistributedSqlServerCache(_ => { }));
Microsoft.Extensions.Caching.StackExchangeRedis.Tests (1)
CacheServiceExtensionsTests.cs (1)
65Assert.Same(services, services.AddStackExchangeRedisCache(_ => { }));
Microsoft.Extensions.Diagnostics.HealthChecks.Tests (5)
DefaultHealthCheckServiceTest.cs (3)
112Assert.Same(exception, actual.Value.Exception); 298Assert.Same(thrownException, actual.Value.Exception); 305Assert.Same(faultedException, actual.Value.Exception);
DependencyInjection\HealthChecksBuilderTest.cs (2)
39Assert.Same(instance, registration.Factory(serviceProvider)); 82Assert.Same(instance, registration.Factory(serviceProvider));
Microsoft.Extensions.Diagnostics.Testing.Tests (8)
Metrics\MetricCollectorTests.cs (8)
64Assert.Same(collector.GetMeasurementSnapshot().Last(), collector.LastMeasurement); 74Assert.Same(collector.GetMeasurementSnapshot().Last(), collector.LastMeasurement); 109Assert.Same(collector.GetMeasurementSnapshot().Last(), collector.LastMeasurement); 119Assert.Same(collector.GetMeasurementSnapshot().Last(), collector.LastMeasurement); 156Assert.Same(collector.GetMeasurementSnapshot().Last(), collector.LastMeasurement); 166Assert.Same(collector.GetMeasurementSnapshot().Last(), collector.LastMeasurement); 217Assert.Same(collector.GetMeasurementSnapshot().Last(), collector.LastMeasurement); 227Assert.Same(collector.GetMeasurementSnapshot().Last(), collector.LastMeasurement);
Microsoft.Extensions.FileProviders.Embedded.Tests (2)
Manifest\ManifestEntryTests.cs (2)
47Assert.Same(directory, result); 93Assert.Same(ManifestEntry.UnknownPath, result);
Microsoft.Extensions.Hosting.Testing.Tests (1)
FakeHostBuilderTests.cs (1)
95Assert.Same(properties, builder.Properties);
Microsoft.Extensions.Http.Diagnostics.Tests (3)
Logging\HttpClientLoggerTest.cs (3)
111Assert.Same(exception, actualException); 442Assert.Same(exception, logRecord.Exception); 989Assert.Same(exception, logRecord.Exception);
Microsoft.Extensions.Http.Polly.Tests (25)
DependencyInjection\PollyHttpClientBuilderExtensionsTest.cs (11)
456Assert.Same(registry, services.GetService<IConcurrentPolicyRegistry<string>>()); 457Assert.Same(registry, services.GetService<IReadOnlyPolicyRegistry<string>>()); 472Assert.Same(registry, services.GetService<IConcurrentPolicyRegistry<string>>()); 473Assert.Same(registry, services.GetService<IPolicyRegistry<string>>()); 474Assert.Same(registry, services.GetService<IReadOnlyPolicyRegistry<string>>()); 493Assert.Same(registry, services.GetService<IConcurrentPolicyRegistry<string>>()); 494Assert.Same(registry, services.GetService<IReadOnlyPolicyRegistry<string>>()); 512Assert.Same(existingRegistry, registry); 514Assert.Same(existingRegistry, services.GetService<IPolicyRegistry<string>>()); 515Assert.Same(existingRegistry, services.GetService<IConcurrentPolicyRegistry<string>>()); 516Assert.Same(existingRegistry, services.GetService<IReadOnlyPolicyRegistry<string>>());
HttpRequestMessageExtensionsTest.cs (2)
28Assert.Same(expected, actual); 80Assert.Same(expected, actual);
PolicyHttpMessageHandlerTest.cs (12)
53Assert.Same(expected, response); 98Assert.Same(expected, response); 99Assert.Same(expectedRequest, policySelectorRequest); 146Assert.Same(expected, response); 198Assert.Same(expected, response); 268Assert.Same(expected, response); 284Assert.Same(context, req.GetPolicyExecutionContext()); 296Assert.Same(expected, response); 314Assert.Same(c, req.GetPolicyExecutionContext()); 325Assert.Same(expectedContext, context); 326Assert.Same(expectedContext, request.GetPolicyExecutionContext()); // We don't clean up the context if the caller or earlier delegating handlers had supplied it. 327Assert.Same(expected, response);
Microsoft.Extensions.Http.Resilience.Tests (2)
Resilience\HttpResilienceContextExtensionsTests.cs (2)
45Assert.Same(request, context.GetRequestMessage()); 75Assert.Same(request, actualRequest);
Microsoft.Extensions.Localization.Tests (2)
ResourceManagerStringLocalizerFactoryTest.cs (2)
106Assert.Same(result1, result2); 222Assert.Same(result1, result2);
Microsoft.Extensions.ObjectPool.DependencyInjection.Tests (3)
DependencyInjectionExtensionsTests.cs (3)
246Assert.Same(resolved1, resolved2); 348Assert.Same(resolved1, resolved2); 349Assert.Same(resolved3, resolved4);
Microsoft.Extensions.ObjectPool.Tests (5)
DefaultObjectPoolTest.cs (3)
24Assert.Same(obj1, obj2); 40Assert.Same(list1, list2); 86Assert.Same(r, p.Get());
DisposableObjectPoolTest.cs (2)
25Assert.Same(obj1, obj2); 41Assert.Same(list1, list2);
Microsoft.Extensions.Telemetry.Abstractions.Tests (1)
Logging\LoggerMessageHelperTests.cs (1)
72Assert.Same(lmp1, lmp2);
Microsoft.Extensions.Telemetry.Tests (11)
Buffering\LogBufferingFilterRuleTests.cs (3)
49Assert.Same(rules[11], result); 76Assert.Same(rules.Last(), result); 96Assert.Same(rules[1], result);
Sampling\LogSamplingRuleSelectorTests.cs (8)
44Assert.Same(rules[9], actualResult); 68Assert.Same(rules.Last(), actualResult); 86Assert.Same(rules[1], actualResult); 104Assert.Same(rules[1], actualResult); 122Assert.Same(rules[1], actualResult); 140Assert.Same(rules[1], actualResult); 157Assert.Same(rules[0], actualResult); 174Assert.Same(rules[0], actualResult);
Microsoft.Extensions.Validation.Tests (5)
ValidatableTypeInfoTests.cs (5)
92Assert.Same(context.Container, personWithMissingRequiredFields); 99Assert.Same(context.Container, personWithMissingRequiredFields); 106Assert.Same(context.Container, personWithMissingRequiredFields.Address); 113Assert.Same(context.Container, personWithMissingRequiredFields.Address); 163Assert.Same(errorContext.Container, employee);
Microsoft.Extensions.WebEncoders.Tests (9)
EncoderServiceCollectionExtensionsTests.cs (9)
24Assert.Same(HtmlEncoder.Default, serviceProvider.GetRequiredService<HtmlEncoder>()); // default encoder 25Assert.Same(HtmlEncoder.Default, serviceProvider.GetRequiredService<HtmlEncoder>()); // as singleton instance 26Assert.Same(JavaScriptEncoder.Default, serviceProvider.GetRequiredService<JavaScriptEncoder>()); // default encoder 27Assert.Same(JavaScriptEncoder.Default, serviceProvider.GetRequiredService<JavaScriptEncoder>()); // as singleton instance 28Assert.Same(UrlEncoder.Default, serviceProvider.GetRequiredService<UrlEncoder>()); // default encoder 29Assert.Same(UrlEncoder.Default, serviceProvider.GetRequiredService<UrlEncoder>()); // as singleton instance 50Assert.Same(htmlEncoder, serviceProvider.GetRequiredService<HtmlEncoder>()); // as singleton instance 54Assert.Same(javaScriptEncoder, serviceProvider.GetRequiredService<JavaScriptEncoder>()); // as singleton instance 58Assert.Same(urlEncoder, serviceProvider.GetRequiredService<UrlEncoder>()); // as singleton instance
Microsoft.Gen.Logging.Unit.Tests (1)
ParserUtilitiesTests.cs (1)
111Assert.Same(locationMock, result);
Microsoft.JSInterop.Tests (18)
DotNetObjectReferenceTest.cs (3)
12Assert.Same(obj, DotNetObjectReference.Create(obj).Value); 74Assert.Same(objRef, jsRuntime.GetObjectReference(objectId)); 92Assert.Same(objRef, jsRuntime.GetObjectReference(objectId));
Infrastructure\ByteArrayJsonConverterTest.cs (2)
213Assert.Same(byteArray3, deserialized[0]); 214Assert.Same(byteArray2, deserialized[1]);
Infrastructure\DotNetObjectReferenceJsonConverterTest.cs (4)
85Assert.Same(input, deserialized.Value); 105Assert.Same(instance1, deserialized[0].Value); 106Assert.Same(instance2, deserialized[1].Value); 126Assert.Same(input, deserialized.Value);
JSInProcessRuntimeTest.cs (3)
59Assert.Same(obj1, runtime.GetObjectReference(1).Value); 60Assert.Same(obj2, runtime.GetObjectReference(2).Value); 61Assert.Same(obj3, runtime.GetObjectReference(3).Value);
JSRuntimeTest.cs (6)
289Assert.Same(obj1Ref, runtime.GetObjectReference(1)); 290Assert.Same(obj1, obj1Ref.Value); 292Assert.Same(obj2, runtime.GetObjectReference(2).Value); 293Assert.Same(obj3, runtime.GetObjectReference(3).Value); 294Assert.Same(obj1, runtime.GetObjectReference(4).Value); 315Assert.Same(exception, error.InnerException);
Microsoft.Net.Http.Headers.Tests (19)
MediaTypeHeaderValueTest.cs (11)
132Assert.Same(mediaType0.MediaType.Value, mediaType1.MediaType.Value); 143Assert.Same(mediaType0.MediaType.Value, mediaType1.MediaType.Value); 159Assert.Same(mediaType0.MediaType.Value, mediaType1.MediaType.Value); 165Assert.Same(pair0.Name.Value, pair1.Name.Value); 166Assert.Same(pair0.Value.Value, pair1.Value.Value); 178Assert.Same(mediaType0.MediaType.Value, mediaType1.MediaType.Value); 193Assert.Same(pair0.Name.Value, pair1.Name.Value); 194Assert.Same(pair0.Value.Value, pair1.Value.Value); 206Assert.Same(mediaType2.MediaType.Value, mediaType1.MediaType.Value); 216Assert.Same(pair2.Name.Value, pair1.Name.Value); 217Assert.Same(pair2.Value.Value, pair1.Value.Value);
NameValueHeaderValueTest.cs (8)
63Assert.Same(pair0.Name.Value, pair1.Name.Value); 79Assert.Same(pair0.Name.Value, pair1.Name.Value); 98Assert.Same(pair0.Name.Value, pair1.Name.Value); 99Assert.Same(pair0.Value.Value, pair1.Value.Value); 113Assert.Same(pair0.Name.Value, pair1.Name.Value); 114Assert.Same(pair0.Value.Value, pair1.Value.Value); 132Assert.Same(pair0.Name.Value, pair1.Name.Value); 133Assert.Same(pair0.Value.Value, pair1.Value.Value);
Mvc.Analyzers.Test (7)
CodeAnalysisExtensionsTest.cs (7)
317Assert.Same(attribute, attributeData.AttributeClass); 322Assert.Same(attribute, attributeData.AttributeClass); 360Assert.Same(attribute, attributeData.AttributeClass); 365Assert.Same(attribute, attributeData.AttributeClass); 370Assert.Same(attribute, attributeData.AttributeClass); 408Assert.Same(attribute, attributeData.AttributeClass); 446Assert.Same(attribute, attributeData.AttributeClass);
Mvc.Api.Analyzers.Test (7)
ApiActionsDoNotRequireExplicitModelValidationCheckAnalyzerIntegrationTest.cs (1)
78Assert.Same(descriptor, diagnostic.Descriptor);
ApiConventionAnalyzerIntegrationTest.cs (1)
294Assert.Same(descriptor, diagnostic.Descriptor);
SymbolApiResponseMetadataProviderTest.cs (5)
285Assert.Same(method, metadata.AttributeSource); 415Assert.Same(expected, result); 433Assert.Same(expected, result); 451Assert.Same(expected, result); 469Assert.Same(expected, result);
Shared.Tests (9)
EmptyCollections\EmptyReadOnlyListTests.cs (4)
18Assert.Same(EmptyReadOnlyList<int>.Instance, EmptyReadOnlyList<int>.Instance); 23Assert.Same(instance.GetEnumerator(), instance.GetEnumerator()); 24Assert.Same(instance.GetEnumerator(), instance.GetEnumerator()); 25Assert.Same(((IEnumerable)instance).GetEnumerator(), ((IEnumerable)instance).GetEnumerator());
JsonSchemaExporter\JsonSchemaExporterConfigurationTests.cs (1)
24Assert.Same(JsonSchemaExporterOptions.Default, JsonSchemaExporterOptions.Default);
Pools\PoolTests.cs (4)
157Assert.Same(l, l2); 172Assert.Same(d, d2); 187Assert.Same(s, s2); 201Assert.Same(s, s2);
System.Xaml.Tests (68)
System\Windows\Markup\ArrayExtensionTests.cs (3)
18Assert.Same(extension.Items, extension.Items); 29Assert.Same(extension.Items, extension.Items); 57Assert.Same(extension.Items, extension.Items);
System\Windows\Markup\ContentWrapperAttributeTests.cs (1)
59Assert.Same(attribute, attribute.TypeId);
System\Windows\Markup\DependsOnAttributeTests.cs (1)
24Assert.Same(attribute, attribute.TypeId);
System\Windows\Markup\PropertyDefinitionTests.cs (1)
24Assert.Same(definition.Attributes, definition.Attributes);
System\Windows\Markup\ValueSerializerTests.cs (2)
244Assert.Same(serializer, ValueSerializer.GetSerializerFor(typeof(int), context)); 311Assert.Same(serializer, ValueSerializer.GetSerializerFor(descriptor, context));
System\Windows\Markup\XDataTests.cs (2)
36Assert.Same(data.XmlReader, reader); 56Assert.Same(reader, data.XmlReader);
System\Xaml\Schema\XamlMemberInvokerTests.cs (1)
52Assert.Same(invoker, XamlMemberInvoker.UnknownInvoker);
System\Xaml\Schema\XamlTypeInvokerTests.cs (1)
43Assert.Same(invoker, XamlTypeInvoker.UnknownInvoker);
System\Xaml\Schema\XamlValueConverterTests.cs (2)
62Assert.Same(instance, converter.ConverterInstance); 71Assert.Same(instance, converter.ConverterInstance);
System\Xaml\XamlDirectiveTests.cs (1)
165Assert.Same(directive.LookupInvokerEntry(), directive.LookupInvokerEntry());
System\Xaml\XamlLanguageTests.cs (47)
32Assert.Same(type, XamlLanguage.Array); 43Assert.Same(type, XamlLanguage.Member); 54Assert.Same(type, XamlLanguage.Null); 65Assert.Same(type, XamlLanguage.Property); 76Assert.Same(type, XamlLanguage.Reference); 87Assert.Same(type, XamlLanguage.Static); 98Assert.Same(type, XamlLanguage.Type); 109Assert.Same(type, XamlLanguage.String); 120Assert.Same(type, XamlLanguage.Double); 131Assert.Same(type, XamlLanguage.Int32); 142Assert.Same(type, XamlLanguage.Boolean); 153Assert.Same(type, XamlLanguage.XData); 164Assert.Same(type, XamlLanguage.Object); 175Assert.Same(type, XamlLanguage.Char); 186Assert.Same(type, XamlLanguage.Single); 197Assert.Same(type, XamlLanguage.Byte); 208Assert.Same(type, XamlLanguage.Int16); 219Assert.Same(type, XamlLanguage.Int64); 230Assert.Same(type, XamlLanguage.Decimal); 241Assert.Same(type, XamlLanguage.Uri); 252Assert.Same(type, XamlLanguage.TimeSpan); 263Assert.Same(types, XamlLanguage.AllTypes); 271Assert.Same(directive, XamlLanguage.Arguments); 284Assert.Same(directive, XamlLanguage.AsyncRecords); 297Assert.Same(directive, XamlLanguage.Class); 310Assert.Same(directive, XamlLanguage.ClassModifier); 323Assert.Same(directive, XamlLanguage.Code); 336Assert.Same(directive, XamlLanguage.ConnectionId); 349Assert.Same(directive, XamlLanguage.FactoryMethod); 362Assert.Same(directive, XamlLanguage.FieldModifier); 375Assert.Same(directive, XamlLanguage.Items); 388Assert.Same(directive, XamlLanguage.Initialization); 401Assert.Same(directive, XamlLanguage.Key); 414Assert.Same(directive, XamlLanguage.Members); 427Assert.Same(directive, XamlLanguage.ClassAttributes); 440Assert.Same(directive, XamlLanguage.Name); 453Assert.Same(directive, XamlLanguage.PositionalParameters); 466Assert.Same(directive, XamlLanguage.Shared); 479Assert.Same(directive, XamlLanguage.Subclass); 492Assert.Same(directive, XamlLanguage.SynchronousMode); 505Assert.Same(directive, XamlLanguage.TypeArguments); 518Assert.Same(directive, XamlLanguage.Uid); 531Assert.Same(directive, XamlLanguage.UnknownContent); 544Assert.Same(directive, XamlLanguage.Base); 557Assert.Same(directive, XamlLanguage.Lang); 570Assert.Same(directive, XamlLanguage.Space); 583Assert.Same(directives, XamlLanguage.AllDirectives);
System\Xaml\XamlNodeListTests.cs (1)
235Assert.Same(writer, list.Writer);
System\Xaml\XamlNodeQueueTests.cs (2)
35Assert.Same(reader, queue.Reader); 92Assert.Same(writer, queue.Writer);
System\Xaml\XamlSchemaContextTests.cs (2)
808Assert.Same(actual, context.GetXamlType(xamlTypeName)); 999Assert.Same(type, context.GetXamlType(underlyingType));
System\Xaml\XamlTypeTests.cs (1)
615Assert.Same(actual, type.GetAliasedProperty(directive));
WindowsBase.Tests (1534)
System\Collections\Specialized\CollectionChangedEventManagerTests.cs (8)
25Assert.Same(source, actualSender); 26Assert.Same(e, actualE); 34Assert.Same(source, actualSender); 35Assert.Same(e, actualE); 197Assert.Same(source, actualSender); 198Assert.Same(e, actualE); 207Assert.Same(source, actualSender); 208Assert.Same(e, actualE);
System\ComponentModel\CurrentChangedEventManagerTests.cs (8)
30Assert.Same(source, actualSender); 31Assert.Same(e, actualE); 39Assert.Same(source, actualSender); 40Assert.Same(e, actualE); 210Assert.Same(source, actualSender); 211Assert.Same(e, actualE); 220Assert.Same(source, actualSender); 221Assert.Same(e, actualE);
System\ComponentModel\CurrentChangingEventManagerTests.cs (8)
29Assert.Same(source, actualSender); 30Assert.Same(e, actualE); 38Assert.Same(source, actualSender); 39Assert.Same(e, actualE); 201Assert.Same(source, actualSender); 202Assert.Same(e, actualE); 211Assert.Same(source, actualSender); 212Assert.Same(e, actualE);
System\ComponentModel\ErrorsChangedEventManagerTests.cs (4)
28Assert.Same(source, actualSender); 29Assert.Same(e, actualE); 37Assert.Same(source, actualSender); 38Assert.Same(e, actualE);
System\ComponentModel\GroupDescriptionTests.cs (24)
19Assert.Same(description.GroupNames, description.GroupNames); 21Assert.Same(description.SortDescriptions, description.SortDescriptions); 38Assert.Same(value, description.CustomSort); 43Assert.Same(value, description.CustomSort); 57Assert.Same(value, description.CustomSort); 62Assert.Same(value, description.CustomSort); 75Assert.Same(value, description.CustomSort); 80Assert.Same(value, description.CustomSort); 93Assert.Same(value, description.CustomSort); 98Assert.Same(value, description.CustomSort); 109Assert.Same(description, sender); 142Assert.Same(description, sender); 178Assert.Same(description, sender); 230Assert.Same(collection, description.GroupNames); 245Assert.Same(description, sender); 292Assert.Same(description, sender); 300Assert.Same(collection, description.SortDescriptions); 320Assert.Same(description, sender); 328Assert.Same(collection, description.SortDescriptions); 348Assert.Same(collection, description.SortDescriptions); 399Assert.Same(description, sender); 438Assert.Same(description, sender); 544Assert.Same(description, sender); 545Assert.Same(eventArgs, e);
System\ComponentModel\PropertyChangedEventManagerTests.cs (4)
18Assert.Same(source, actualSender); 26Assert.Same(source, actualSender); 429Assert.Same(source, actualSender); 438Assert.Same(source, actualSender);
System\ComponentModel\PropertyFilterAttributeTests.cs (1)
25Assert.Same(attribute, PropertyFilterAttribute.Default);
System\ComponentModel\SortDescriptionCollectionTests.cs (10)
78Assert.Same(collection, s); 164Assert.Same(collection, s); 243Assert.Same(collection, s); 332Assert.Same(collection, s); 414Assert.Same(collection, s); 486Assert.Same(collection, s); 568Assert.Same(collection, s); 654Assert.Same(collection, s); 734Assert.Same(collection, s); 781Assert.Same(SortDescriptionCollection.Empty, collection);
System\Diagnostics\PresentationTraceSourcesTests.cs (13)
15Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 25Assert.Same(property, PresentationTraceSources.TraceLevelProperty); 73Assert.Same(source, PresentationTraceSources.AnimationSource); 83Assert.Same(source, PresentationTraceSources.DataBindingSource); 93Assert.Same(source, PresentationTraceSources.DependencyPropertySource); 103Assert.Same(source, PresentationTraceSources.DocumentsSource); 113Assert.Same(source, PresentationTraceSources.FreezableSource); 123Assert.Same(source, PresentationTraceSources.HwndHostSource); 133Assert.Same(source, PresentationTraceSources.MarkupSource); 143Assert.Same(source, PresentationTraceSources.NameScopeSource); 153Assert.Same(source, PresentationTraceSources.ResourceDictionarySource); 163Assert.Same(source, PresentationTraceSources.RoutedEventSource); 173Assert.Same(source, PresentationTraceSources.ShellSource);
System\IO\Packaging\PackageDigitalSignatureManagerTests.cs (6)
31Assert.Same(manager.Signatures, manager.Signatures); 34Assert.Same(manager.TransformMapping, manager.TransformMapping); 283Assert.Same(manager.Signatures, manager.Signatures); 290Assert.Same(manager.Signatures, manager.Signatures); 305Assert.Same(manager.Signatures, manager.Signatures); 311Assert.Same(manager.Signatures, manager.Signatures);
System\Security\RightsManagement\ContentUserTests.cs (2)
62Assert.Same(user, ContentUser.AnyoneUser); 71Assert.Same(user, ContentUser.OwnerUser);
System\Security\RightsManagement\RightsManagementExceptionTests.cs (5)
81Assert.Same(innerException, exception.InnerException); 132Assert.Same(innerException, exception.InnerException); 153Assert.Same(innerException, exception.InnerException); 177Assert.Same(innerException, exception.InnerException); 201Assert.Same(innerException, exception.InnerException);
System\Security\RightsManagement\UnsignedPublishLicenseTests.cs (2)
14Assert.Same(license.Grants, license.Grants); 16Assert.Same(license.LocalizedNameDescriptionDictionary, license.LocalizedNameDescriptionDictionary);
System\Windows\AttachedPropertyBrowsableForTypeAttributeTests.cs (1)
17Assert.Same(attribute, attribute.TypeId);
System\Windows\Data\DataSourceProviderTests.cs (56)
18Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 117Assert.Same(value, provider.Dispatcher); 121Assert.Same(value, provider.Dispatcher); 144Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 203Assert.Same(provider, sender); 1155Assert.Same(provider, sender); 1156Assert.Same(eventArgs, e); 1179Assert.Same(newData, provider.Data); 1181Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1188Assert.Same(newData, provider.Data); 1190Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1199Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1221Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1246Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1260Assert.Same(provider, sender); 1262Assert.Same(newData, provider.Data); 1296Assert.Same(provider, sender); 1297Assert.Same(EventArgs.Empty, e); 1298Assert.Same(newData, provider.Data); 1334Assert.Same(provider, sender); 1342Assert.Same(provider, sender); 1343Assert.Same(EventArgs.Empty, e); 1434Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1443Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1463Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1464Assert.Same(error, provider.Error); 1472Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1473Assert.Same(error, provider.Error); 1481Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1498Assert.Same(callbackArg, arg); 1509Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1519Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1544Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1545Assert.Same(error, provider.Error); 1558Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1559Assert.Same(error, provider.Error); 1585Assert.Same(Dispatcher.CurrentDispatcher, provider.Dispatcher); 1607Assert.Same(provider, sender); 1609Assert.Same(newData, provider.Data); 1616Assert.Same(callbackArguments, arg); 1617Assert.Same(newData, provider.Data); 1657Assert.Same(provider, sender); 1675Assert.Same(error1, provider.Error); 1681Assert.Same(error1, provider.Error); 1688Assert.Same(error2, provider.Error); 1702Assert.Same(error1, provider.Error); 1715Assert.Same(provider, sender); 1716Assert.Same(EventArgs.Empty, e); 1717Assert.Same(newData, provider.Data); 1724Assert.Same(callbackArguments, arg); 1725Assert.Same(newData, provider.Data); 1768Assert.Same(provider, sender); 1777Assert.Same(provider, sender); 1778Assert.Same(EventArgs.Empty, e); 1786Assert.Same(callbackArguments, arg); 1787Assert.Same(newData, provider.Data);
System\Windows\DependencyObjectTests.cs (135)
17Assert.Same(obj.DependencyObjectType, obj.DependencyObjectType); 18Assert.Same(DependencyObjectType.FromSystemType(typeof(DependencyObject)), obj.DependencyObjectType); 19Assert.Same(Dispatcher.CurrentDispatcher, obj.Dispatcher); 28Assert.Same(obj.DependencyObjectType, obj.DependencyObjectType); 29Assert.Same(DependencyObjectType.FromSystemType(typeof(DependencyObject)), obj.DependencyObjectType); 39Assert.Same(obj.DependencyObjectType, obj.DependencyObjectType); 40Assert.Same(DependencyObjectType.FromSystemType(typeof(DependencyObject)), obj.DependencyObjectType); 48Assert.Same(Dispatcher.CurrentDispatcher, obj.Dispatcher); 58Assert.Same(expected, obj.Dispatcher); 206Assert.Same(obj, d); 207Assert.Same(expectedProperty, e.Property); 208Assert.Same(expectedOldValue, e.OldValue); 209Assert.Same(expectedNewValue, e.NewValue); 254Assert.Same(obj, d); 255Assert.Same(expectedNewValue, baseValue); 299Assert.Same(obj, d); 300Assert.Same(expectedProperty, e.Property); 301Assert.Same(expectedOldValue, e.OldValue); 302Assert.Same(expectedNewValue, e.NewValue); 308Assert.Same(obj, d); 309Assert.Same(expectedNewValue, baseValue); 358Assert.Same(expectedProperty, e.Property); 359Assert.Same(expectedOldValue, e.OldValue); 360Assert.Same(expectedNewValue, e.NewValue); 367Assert.Same(obj, d); 368Assert.Same(expectedProperty, e.Property); 369Assert.Same(expectedOldValue, e.OldValue); 370Assert.Same(expectedNewValue, e.NewValue); 565Assert.Same(obj, d); 566Assert.Same(expectedProperty, e.Property); 567Assert.Same(expectedOldValue, e.OldValue); 568Assert.Same(expectedNewValue, e.NewValue); 614Assert.Same(obj, d); 615Assert.Same(expectedNewValue, baseValue); 660Assert.Same(obj, d); 661Assert.Same(expectedProperty, e.Property); 662Assert.Same(expectedOldValue, e.OldValue); 663Assert.Same(expectedNewValue, e.NewValue); 669Assert.Same(obj, d); 670Assert.Same(expectedNewValue, baseValue); 720Assert.Same(expectedProperty, e.Property); 721Assert.Same(expectedOldValue, e.OldValue); 722Assert.Same(expectedNewValue, e.NewValue); 729Assert.Same(obj, d); 730Assert.Same(expectedProperty, e.Property); 731Assert.Same(expectedOldValue, e.OldValue); 732Assert.Same(expectedNewValue, e.NewValue); 917Assert.Same(obj, d); 918Assert.Same(expectedProperty, e.Property); 919Assert.Same(expectedOldValue, e.OldValue); 920Assert.Same(expectedNewValue, e.NewValue); 963Assert.Same(obj, d); 964Assert.Same(expectedNewValue, baseValue); 1010Assert.Same(obj, d); 1011Assert.Same(expectedNewValue, baseValue); 1056Assert.Same(obj, d); 1057Assert.Same(expectedBaseValue, baseValue); 1094Assert.Same(obj, d); 1095Assert.Same(expectedProperty, e.Property); 1096Assert.Same(expectedOldValue, e.OldValue); 1097Assert.Same(expectedNewValue, e.NewValue); 1103Assert.Same(obj, d); 1104Assert.Same(expectedNewValue, baseValue); 1179Assert.Same(obj, d); 1211Assert.Same(obj, d); 1307Assert.Same(property, entry.Property); 1311Assert.Same(property, entry.Property); 1350Assert.Same(property, entry.Property); 1354Assert.Same(property, entry.Property); 1768Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1771Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1780Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1783Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1792Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1795Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1804Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1807Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1817Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1820Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1912Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1915Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1925Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1928Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1938Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1941Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1965Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1968Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1978Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1981Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1991Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 1994Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 2004Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 2007Assert.Same(DependencyProperty.UnsetValue, obj.ReadLocalValue(property)); 2129Assert.Same(obj, d); 2130Assert.Same(expectedProperty, e.Property); 2131Assert.Same(expectedOldValue, e.OldValue); 2132Assert.Same(expectedNewValue, e.NewValue); 2179Assert.Same(obj, d); 2180Assert.Same(expectedNewValue, baseValue); 2225Assert.Same(obj, d); 2226Assert.Same(expectedNewValue, baseValue); 2272Assert.Same(obj, d); 2273Assert.Same(expectedProperty, e.Property); 2274Assert.Same(expectedOldValue, e.OldValue); 2275Assert.Same(expectedNewValue, e.NewValue); 2281Assert.Same(obj, d); 2282Assert.Same(expectedNewValue, baseValue); 2334Assert.Same(expectedProperty, e.Property); 2335Assert.Same(expectedOldValue, e.OldValue); 2336Assert.Same(expectedNewValue, e.NewValue); 2344Assert.Same(obj, d); 2345Assert.Same(expectedProperty, e.Property); 2346Assert.Same(expectedOldValue, e.OldValue); 2347Assert.Same(expectedNewValue, e.NewValue); 2552Assert.Same(obj, d); 2553Assert.Same(expectedProperty, e.Property); 2554Assert.Same(expectedOldValue, e.OldValue); 2555Assert.Same(expectedNewValue, e.NewValue); 2603Assert.Same(obj, d); 2604Assert.Same(expectedNewValue, baseValue); 2650Assert.Same(obj, d); 2651Assert.Same(expectedNewValue, baseValue); 2698Assert.Same(obj, d); 2699Assert.Same(expectedProperty, e.Property); 2700Assert.Same(expectedOldValue, e.OldValue); 2701Assert.Same(expectedNewValue, e.NewValue); 2707Assert.Same(obj, d); 2708Assert.Same(expectedNewValue, baseValue); 2761Assert.Same(expectedProperty, e.Property); 2762Assert.Same(expectedOldValue, e.OldValue); 2763Assert.Same(expectedNewValue, e.NewValue); 2771Assert.Same(obj, d); 2772Assert.Same(expectedProperty, e.Property); 2773Assert.Same(expectedOldValue, e.OldValue); 2774Assert.Same(expectedNewValue, e.NewValue);
System\Windows\DependencyObjectTypeTests.cs (3)
13Assert.Same(type, DependencyObjectType.FromSystemType(typeof(DependencyObject))); 25Assert.Same(type, DependencyObjectType.FromSystemType(typeof(SubDependencyObject))); 27Assert.Same(DependencyObjectType.FromSystemType(typeof(DependencyObject)), type.BaseType);
System\Windows\DependencyPropertyChangedEventArgsTests.cs (1)
25Assert.Same(property, args.Property);
System\Windows\DependencyPropertyTests.cs (24)
29Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 81Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 140Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 149Assert.Same(validateValueCallback, property.ValidateValueCallback); 193Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 340Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 394Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 453Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 462Assert.Same(validateValueCallback, property.ValidateValueCallback); 506Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 668Assert.Same(key.DependencyProperty, key.DependencyProperty); 672Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 731Assert.Same(key.DependencyProperty, key.DependencyProperty); 735Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 744Assert.Same(validateValueCallback, property.ValidateValueCallback); 788Assert.Same(key.DependencyProperty, key.DependencyProperty); 792Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 963Assert.Same(key.DependencyProperty, key.DependencyProperty); 967Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 1026Assert.Same(key.DependencyProperty, key.DependencyProperty); 1030Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 1039Assert.Same(validateValueCallback, property.ValidateValueCallback); 1083Assert.Same(key.DependencyProperty, key.DependencyProperty); 1087Assert.Same(property.DefaultMetadata, property.DefaultMetadata);
System\Windows\FreezableTests.cs (481)
17Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 18Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 19Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 249Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 250Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), dependencyObjectType); 261Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 262Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), dependencyObjectType); 273Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 274Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), dependencyObjectType); 288Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 289Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), dependencyObjectType); 307Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 319Assert.Same(expected, dispatcher); 515Assert.Same(obj, d); 516Assert.Same(expectedProperty, e.Property); 517Assert.Same(expectedOldValue, e.OldValue); 518Assert.Same(expectedNewValue, e.NewValue); 563Assert.Same(obj, d); 564Assert.Same(expectedNewValue, baseValue); 608Assert.Same(obj, d); 609Assert.Same(expectedProperty, e.Property); 610Assert.Same(expectedOldValue, e.OldValue); 611Assert.Same(expectedNewValue, e.NewValue); 617Assert.Same(obj, d); 618Assert.Same(expectedNewValue, baseValue); 667Assert.Same(expectedProperty, e.Property); 668Assert.Same(expectedOldValue, e.OldValue); 669Assert.Same(expectedNewValue, e.NewValue); 676Assert.Same(obj, d); 677Assert.Same(expectedProperty, e.Property); 678Assert.Same(expectedOldValue, e.OldValue); 679Assert.Same(expectedNewValue, e.NewValue); 724Assert.Same(freezable, sender); 725Assert.Same(EventArgs.Empty, e); 772Assert.Same(freezable, sender); 773Assert.Same(EventArgs.Empty, e); 985Assert.Same(obj, d); 986Assert.Same(expectedProperty, e.Property); 987Assert.Same(expectedOldValue, e.OldValue); 988Assert.Same(expectedNewValue, e.NewValue); 1034Assert.Same(obj, d); 1035Assert.Same(expectedNewValue, baseValue); 1080Assert.Same(obj, d); 1081Assert.Same(expectedProperty, e.Property); 1082Assert.Same(expectedOldValue, e.OldValue); 1083Assert.Same(expectedNewValue, e.NewValue); 1089Assert.Same(obj, d); 1090Assert.Same(expectedNewValue, baseValue); 1140Assert.Same(expectedProperty, e.Property); 1141Assert.Same(expectedOldValue, e.OldValue); 1142Assert.Same(expectedNewValue, e.NewValue); 1149Assert.Same(obj, d); 1150Assert.Same(expectedProperty, e.Property); 1151Assert.Same(expectedOldValue, e.OldValue); 1152Assert.Same(expectedNewValue, e.NewValue); 1198Assert.Same(freezable, sender); 1199Assert.Same(EventArgs.Empty, e); 1246Assert.Same(freezable, sender); 1247Assert.Same(EventArgs.Empty, e); 1334Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 1335Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 1337Assert.Same(Dispatcher.CurrentDispatcher, clone.Dispatcher); 1342Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 1343Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 1344Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 1356Assert.Same(clone2.DependencyObjectType, clone2.DependencyObjectType); 1357Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone2.DependencyObjectType); 1359Assert.Same(Dispatcher.CurrentDispatcher, clone2.Dispatcher); 1363Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 1364Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 1366Assert.Same(Dispatcher.CurrentDispatcher, clone.Dispatcher); 1371Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 1372Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 1373Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 1438Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 1439Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 1441Assert.Same(Dispatcher.CurrentDispatcher, clone.Dispatcher); 1507Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 1509Assert.Same(Dispatcher.CurrentDispatcher, clone.Dispatcher); 1543Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 1544Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 1546Assert.Same(Dispatcher.CurrentDispatcher, clone.Dispatcher); 1609Assert.Same(clone, freezable.Clone()); 1613Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 1614Assert.Same(DependencyObjectType.FromSystemType(typeof(CustomFreezable)), clone.DependencyObjectType); 1616Assert.Same(Dispatcher.CurrentDispatcher, clone.Dispatcher); 1646Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 1647Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 1649Assert.Same(Dispatcher.CurrentDispatcher, clone.Dispatcher); 1665Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 1666Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 1667Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 1675Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 1676Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 1677Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 1734Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 1736Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 1737Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 1767Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 1768Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 1769Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 1777Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 1778Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 1779Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 1838Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 1840Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 1841Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 1857Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 1858Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 1867Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 1868Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 1923Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 1924Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 1941Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 1942Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 1943Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 1951Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 1952Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 1953Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2008Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2010Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2011Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2029Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2030Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2031Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2039Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2040Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2041Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2098Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2100Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2101Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2119Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2120Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2129Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2130Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2189Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2190Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2220Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 2221Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 2223Assert.Same(Dispatcher.CurrentDispatcher, clone.Dispatcher); 2228Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2229Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2230Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2242Assert.Same(clone2.DependencyObjectType, clone2.DependencyObjectType); 2243Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone2.DependencyObjectType); 2245Assert.Same(Dispatcher.CurrentDispatcher, clone2.Dispatcher); 2249Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 2250Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 2252Assert.Same(Dispatcher.CurrentDispatcher, clone.Dispatcher); 2257Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2258Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2259Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2324Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 2325Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 2327Assert.Same(Dispatcher.CurrentDispatcher, clone.Dispatcher); 2393Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 2395Assert.Same(Dispatcher.CurrentDispatcher, clone.Dispatcher); 2429Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 2430Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 2432Assert.Same(Dispatcher.CurrentDispatcher, clone.Dispatcher); 2492Assert.Same(clone, freezable.CloneCurrentValue()); 2496Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 2497Assert.Same(DependencyObjectType.FromSystemType(typeof(CustomFreezable)), clone.DependencyObjectType); 2499Assert.Same(Dispatcher.CurrentDispatcher, clone.Dispatcher); 2529Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 2530Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 2532Assert.Same(Dispatcher.CurrentDispatcher, clone.Dispatcher); 2548Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2549Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2550Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2558Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2559Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2560Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2617Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2619Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2620Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2650Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2651Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2652Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2660Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2661Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2662Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2721Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2723Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2724Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2740Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2741Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2750Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2751Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2806Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2807Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2825Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2826Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2827Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2835Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2836Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2837Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2892Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2894Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2895Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2914Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2915Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2916Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2924Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2925Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 2926Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2983Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 2985Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 2986Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 3005Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3006Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 3015Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3016Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 3075Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3076Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 3119Assert.Same(result, freezable.CreateInstance()); 3123Assert.Same(result, freezable.CreateInstance()); 3320Assert.Same(obj, d); 3321Assert.Same(expectedProperty, e.Property); 3322Assert.Same(expectedOldValue, e.OldValue); 3323Assert.Same(expectedNewValue, e.NewValue); 3366Assert.Same(obj, d); 3367Assert.Same(expectedNewValue, baseValue); 3413Assert.Same(obj, d); 3414Assert.Same(expectedNewValue, baseValue); 3459Assert.Same(obj, d); 3460Assert.Same(expectedBaseValue, baseValue); 3497Assert.Same(obj, d); 3498Assert.Same(expectedProperty, e.Property); 3499Assert.Same(expectedOldValue, e.OldValue); 3500Assert.Same(expectedNewValue, e.NewValue); 3506Assert.Same(obj, d); 3507Assert.Same(expectedNewValue, baseValue); 3582Assert.Same(obj, d); 3614Assert.Same(obj, d); 3702Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3703Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 3712Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3713Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 3748Assert.Same(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 3751Assert.Same(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7))); 3754Assert.Same(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 3760Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3761Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 3772Assert.Same(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 3775Assert.Same(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7))); 3778Assert.Same(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 3784Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3785Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 3825Assert.Same(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 3828Assert.Same(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7))); 3831Assert.Same(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 3836Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3837Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 3838Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 3851Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3852Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 3853Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 3875Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3876Assert.Same(DependencyObjectType.FromSystemType(typeof(CustomFreezable)), freezable.DependencyObjectType); 3886Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3887Assert.Same(DependencyObjectType.FromSystemType(typeof(CustomFreezable)), freezable.DependencyObjectType); 3901Assert.Same(freezable, sender); 3902Assert.Same(EventArgs.Empty, e); 3915Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3916Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 3926Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3927Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 3950Assert.Same(freezable, sender); 3951Assert.Same(EventArgs.Empty, e); 3964Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3965Assert.Same(DependencyObjectType.FromSystemType(typeof(CustomFreezable)), freezable.DependencyObjectType); 3976Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 3977Assert.Same(DependencyObjectType.FromSystemType(typeof(CustomFreezable)), freezable.DependencyObjectType); 4031Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4032Assert.Same(DependencyObjectType.FromSystemType(typeof(CustomFreezable)), freezable.DependencyObjectType); 4050Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4051Assert.Same(DependencyObjectType.FromSystemType(typeof(CustomFreezable)), freezable.DependencyObjectType); 4092Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4093Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4094Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4102Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4103Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4104Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4141Assert.Same(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 4144Assert.Same(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7))); 4147Assert.Same(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 4152Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4153Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4154Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4165Assert.Same(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 4168Assert.Same(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7))); 4171Assert.Same(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 4176Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4177Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4178Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4220Assert.Same(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 4223Assert.Same(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7))); 4226Assert.Same(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 4229Assert.Same(anotherFreezable4, freezable.GetValue(SubFreezable.Property9)); 4234Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4235Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4236Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4247Assert.Same(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 4250Assert.Same(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7))); 4253Assert.Same(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 4258Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4259Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4260Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4281Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4282Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4283Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4292Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4293Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4294Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4366Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 4367Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 4373Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4374Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4375Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4387Assert.Same(clone2.DependencyObjectType, clone2.DependencyObjectType); 4388Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone2.DependencyObjectType); 4393Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 4394Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 4400Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4401Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4402Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4462Assert.Same(anotherFreezable3, ((SubFreezable)clone.GetValue(SubFreezable.Property8))); 4467Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 4468Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 4530Assert.Same(anotherFreezable3, ((SubFreezable)clone.GetValue(SubFreezable.Property8))); 4535Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 4536Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 4563Assert.Same(freezable, freezable.GetAsFrozen()); 4594Assert.Same(freezable, freezable.GetAsFrozen()); 4647Assert.Same(freezable, freezable.GetAsFrozen()); 4661Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4662Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4663Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4671Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4672Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4673Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4725Assert.Same(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 4730Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4732Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4733Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4763Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4764Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4765Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4773Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4774Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4775Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4823Assert.Same(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 4826Assert.Same(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7))); 4829Assert.Same(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 4834Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4836Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4837Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4853Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4854Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4863Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4864Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4919Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4920Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4938Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4939Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4940Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 4948Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 4949Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 4950Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5005Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5007Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5008Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5027Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5028Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5029Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5037Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5038Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5039Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5096Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5098Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5099Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5118Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5119Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5128Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5129Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5188Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5189Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5219Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 5220Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 5226Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5227Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5228Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5240Assert.Same(clone2.DependencyObjectType, clone2.DependencyObjectType); 5241Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone2.DependencyObjectType); 5246Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 5247Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 5253Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5254Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5255Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5315Assert.Same(anotherFreezable3, ((SubFreezable)clone.GetValue(SubFreezable.Property8))); 5320Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 5321Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 5383Assert.Same(anotherFreezable3, ((SubFreezable)clone.GetValue(SubFreezable.Property8))); 5388Assert.Same(clone.DependencyObjectType, clone.DependencyObjectType); 5389Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), clone.DependencyObjectType); 5416Assert.Same(freezable, freezable.GetCurrentValueAsFrozen()); 5447Assert.Same(freezable, freezable.GetCurrentValueAsFrozen()); 5500Assert.Same(freezable, freezable.GetCurrentValueAsFrozen()); 5514Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5515Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5516Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5524Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5525Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5526Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5578Assert.Same(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 5583Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5585Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5586Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5616Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5617Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5618Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5626Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5627Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5628Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5676Assert.Same(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 5679Assert.Same(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7))); 5682Assert.Same(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 5687Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5689Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5690Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5706Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5707Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5716Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5717Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5772Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5773Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5791Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5792Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5793Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5801Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5802Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5803Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5858Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5860Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5861Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5880Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5881Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5882Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5890Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5891Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5892Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5948Assert.Same(Dispatcher.CurrentDispatcher, freezable.Dispatcher); 5950Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5951Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5970Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5971Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 5980Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 5981Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 6039Assert.Same(freezable.DependencyObjectType, freezable.DependencyObjectType); 6040Assert.Same(DependencyObjectType.FromSystemType(typeof(SubFreezable)), freezable.DependencyObjectType); 6725Assert.Same(freezable, sender); 6726Assert.Same(EventArgs.Empty, e); 6769Assert.Same(freezable, sender); 6770Assert.Same(EventArgs.Empty, e); 6924Assert.Same(freezable, sender); 6925Assert.Same(EventArgs.Empty, e); 6979Assert.Same(freezable, sender); 6980Assert.Same(EventArgs.Empty, e); 6985Assert.Same(freezable, sender); 6986Assert.Same(EventArgs.Empty, e); 6991Assert.Same(freezable, sender); 6992Assert.Same(EventArgs.Empty, e); 7025Assert.Same(freezable, sender); 7026Assert.Same(EventArgs.Empty, e); 7032Assert.Same(freezable, sender); 7033Assert.Same(EventArgs.Empty, e); 7072Assert.Same(freezable, sender); 7073Assert.Same(EventArgs.Empty, e); 7164Assert.Same(freezable, sender); 7165Assert.Same(EventArgs.Empty, e);
System\Windows\Interop\ComponentDispatcherTests.cs (1)
162Assert.Same(EventArgs.Empty, e);
System\Windows\Markup\Primitives\MarkupObjectTests.cs (46)
21Assert.Same(obj.Attributes, obj.Attributes); 22Assert.Same(instance, obj.Instance); 35Assert.Same(obj.Attributes, obj.Attributes); 44Assert.Same(properties[0].Attributes, properties[0].Attributes); 57Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 69Assert.Same(obj.Attributes, obj.Attributes); 78Assert.Same(properties[0].Attributes, properties[0].Attributes); 91Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 104Assert.Same(obj.Attributes, obj.Attributes); 113Assert.Same(properties[0].Attributes, properties[0].Attributes); 126Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 132Assert.Same(properties[1].Attributes, properties[1].Attributes); 145Assert.Same(properties[1].TypeReferences, properties[1].TypeReferences); 148Assert.Same(instance, properties[1].Value); 163Assert.Same(obj.Attributes, obj.Attributes); 172Assert.Same(properties[0].Attributes, properties[0].Attributes); 185Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 188Assert.Same(instance, properties[0].Value); 199Assert.Same(obj.Attributes, obj.Attributes); 208Assert.Same(properties[0].Attributes, properties[0].Attributes); 221Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 224Assert.Same(instance, properties[0].Value); 237Assert.Same(obj.Attributes, obj.Attributes); 238Assert.Same(instance, obj.Instance); 246Assert.Same(properties[0].Attributes, properties[0].Attributes); 259Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 276Assert.Same(obj.Attributes, obj.Attributes); 277Assert.Same(instance, obj.Instance); 285Assert.Same(properties[0].Attributes, properties[0].Attributes); 298Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 315Assert.Same(obj.Attributes, obj.Attributes); 316Assert.Same(instance, obj.Instance); 324Assert.Same(properties[0].Attributes, properties[0].Attributes); 337Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 359Assert.Same(obj.Attributes, obj.Attributes); 360Assert.Same(instance, obj.Instance); 368Assert.Same(properties[0].Attributes, properties[0].Attributes); 381Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 394Assert.Same(obj.Attributes, obj.Attributes); 395Assert.Same(instance, obj.Instance); 408Assert.Same(obj.Attributes, obj.Attributes); 409Assert.Same(instance, obj.Instance); 417Assert.Same(properties[0].Attributes, properties[0].Attributes); 430Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 436Assert.Same(properties[1].Attributes, properties[1].Attributes); 449Assert.Same(properties[1].TypeReferences, properties[1].TypeReferences);
System\Windows\Markup\Primitives\MarkupPropertyTests.cs (42)
22Assert.Same(obj.Attributes, obj.Attributes); 31Assert.Same(properties[0].Attributes, properties[0].Attributes); 44Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 56Assert.Same(obj.Attributes, obj.Attributes); 65Assert.Same(properties[0].Attributes, properties[0].Attributes); 78Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 91Assert.Same(obj.Attributes, obj.Attributes); 100Assert.Same(properties[0].Attributes, properties[0].Attributes); 113Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 119Assert.Same(properties[1].Attributes, properties[1].Attributes); 132Assert.Same(properties[1].TypeReferences, properties[1].TypeReferences); 135Assert.Same(instance, properties[1].Value); 150Assert.Same(obj.Attributes, obj.Attributes); 159Assert.Same(properties[0].Attributes, properties[0].Attributes); 172Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 175Assert.Same(instance, properties[0].Value); 186Assert.Same(obj.Attributes, obj.Attributes); 195Assert.Same(properties[0].Attributes, properties[0].Attributes); 208Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 211Assert.Same(instance, properties[0].Value); 224Assert.Same(obj.Attributes, obj.Attributes); 225Assert.Same(instance, obj.Instance); 233Assert.Same(properties[0].Attributes, properties[0].Attributes); 246Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 263Assert.Same(obj.Attributes, obj.Attributes); 264Assert.Same(instance, obj.Instance); 272Assert.Same(properties[0].Attributes, properties[0].Attributes); 285Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 302Assert.Same(obj.Attributes, obj.Attributes); 303Assert.Same(instance, obj.Instance); 311Assert.Same(properties[0].Attributes, properties[0].Attributes); 324Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 346Assert.Same(obj.Attributes, obj.Attributes); 347Assert.Same(instance, obj.Instance); 355Assert.Same(properties[0].Attributes, properties[0].Attributes); 368Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 381Assert.Same(obj.Attributes, obj.Attributes); 382Assert.Same(instance, obj.Instance); 390Assert.Same(properties[0].Attributes, properties[0].Attributes); 403Assert.Same(properties[0].TypeReferences, properties[0].TypeReferences); 409Assert.Same(properties[1].Attributes, properties[1].Attributes); 422Assert.Same(properties[1].TypeReferences, properties[1].TypeReferences);
System\Windows\Markup\ServiceProvidersTests.cs (4)
15Assert.Same(service1, serviceProviders.GetService(typeof(object))); 19Assert.Same(service1, serviceProviders.GetService(typeof(object))); 24Assert.Same(service1, serviceProviders.GetService(typeof(object))); 25Assert.Same(service2, serviceProviders.GetService(typeof(string)));
System\Windows\NameScopeTests.cs (42)
47Assert.Same(nameScope1, NameScope.GetNameScope(dependencyObject)); 51Assert.Same(nameScope1, NameScope.GetNameScope(dependencyObject)); 55Assert.Same(nameScope2, NameScope.GetNameScope(dependencyObject)); 71Assert.Same(scopedElement, nameScope["name"]); 130Assert.Same(scopedElement, nameScope.FindName(name)); 143Assert.Same(scopedElement, nameScope.FindName(name)); 162Assert.Same(scopedElement1, nameScope.FindName("name1")); 166Assert.Same(scopedElement1, nameScope.FindName("name1")); 167Assert.Same(scopedElement2, nameScope.FindName("NAME1")); 171Assert.Same(scopedElement1, nameScope.FindName("name1")); 172Assert.Same(scopedElement2, nameScope.FindName("NAME1")); 173Assert.Same(scopedElement2, nameScope.FindName("name2")); 225Assert.Same(property.DefaultMetadata, property.DefaultMetadata); 235Assert.Same(property, NameScope.NameScopeProperty); 251Assert.Same(scopedElement, nameScope.FindName(name)); 264Assert.Same(scopedElement, nameScope.FindName(name)); 283Assert.Same(scopedElement1, nameScope.FindName("name1")); 287Assert.Same(scopedElement1, nameScope.FindName("name1")); 288Assert.Same(scopedElement2, nameScope.FindName("NAME1")); 292Assert.Same(scopedElement1, nameScope.FindName("name1")); 293Assert.Same(scopedElement2, nameScope.FindName("NAME1")); 294Assert.Same(scopedElement2, nameScope.FindName("name2")); 345Assert.Same(scopedElement, nameScope.FindName(name)); 358Assert.Same(scopedElement, nameScope.FindName(name)); 377Assert.Same(scopedElement1, nameScope.FindName("name1")); 381Assert.Same(scopedElement1, nameScope.FindName("name1")); 382Assert.Same(scopedElement2, nameScope.FindName("NAME1")); 386Assert.Same(scopedElement1, nameScope.FindName("name1")); 387Assert.Same(scopedElement2, nameScope.FindName("NAME1")); 388Assert.Same(scopedElement2, nameScope.FindName("name2")); 682Assert.Same(scopedElement, nameScope.FindName("name")); 740Assert.Same(scopedElement, enumerator.Current.Value); 796Assert.Same(scopedElement, ((KeyValuePair<string, object>)enumerator.Current).Value); 848Assert.Same(scopedElement, nameScope.FindName(name)); 861Assert.Same(scopedElement, nameScope.FindName(name)); 880Assert.Same(scopedElement1, nameScope.FindName("name1")); 884Assert.Same(scopedElement1, nameScope.FindName("name1")); 885Assert.Same(scopedElement2, nameScope.FindName("NAME1")); 889Assert.Same(scopedElement1, nameScope.FindName("name1")); 890Assert.Same(scopedElement2, nameScope.FindName("NAME1")); 891Assert.Same(scopedElement2, nameScope.FindName("name2")); 1077Assert.Same(scopedElement, value);
System\Windows\PropertyMetadataTests.cs (3)
340Assert.Same(metadata.PropertyChangedCallback, metadata.PropertyChangedCallback); 376Assert.Same(coerceValueCallback, metadata.CoerceValueCallback); 377Assert.Same(defaultValue, metadata.DefaultValue);
System\Windows\Threading\DispatcherFrameTests.cs (4)
14Assert.Same(frame.Dispatcher, frame.Dispatcher); 15Assert.Same(Dispatcher.CurrentDispatcher, frame.Dispatcher); 26Assert.Same(frame.Dispatcher, frame.Dispatcher); 27Assert.Same(Dispatcher.CurrentDispatcher, frame.Dispatcher);
System\Windows\Threading\DispatcherHookEventArgsTests.cs (2)
15Assert.Same(dispatcher, args.Dispatcher); 16Assert.Same(operation, args.Operation);
System\Windows\Threading\DispatcherObjectTests.cs (2)
15Assert.Same(obj.Dispatcher, obj.Dispatcher); 16Assert.Same(Dispatcher.CurrentDispatcher, obj.Dispatcher);
System\Windows\Threading\DispatcherOperationTests.cs (4)
167Assert.Same(operation, sender); 265Assert.Same(result, operation.Result); 271Assert.Same(result, operation.Result); 291Assert.Same(operation, sender);
System\Windows\Threading\DispatcherTests.cs (7)
16Assert.Same(dispatcher, Dispatcher.CurrentDispatcher); 20Assert.Same(dispatcher.Hooks, dispatcher.Hooks); 21Assert.Same(Thread.CurrentThread, dispatcher.Thread); 35Assert.Same(dispatcher, Dispatcher.CurrentDispatcher); 39Assert.Same(dispatcher.Hooks, dispatcher.Hooks); 40Assert.Same(Thread.CurrentThread, dispatcher.Thread); 131Assert.Same(dispatcher, operation.Dispatcher);
System\Windows\Threading\DispatcherTimerTests.cs (6)
14Assert.Same(Dispatcher.CurrentDispatcher, timer.Dispatcher); 34Assert.Same(Dispatcher.CurrentDispatcher, timer.Dispatcher); 54Assert.Same(Dispatcher.CurrentDispatcher, timer.Dispatcher); 80Assert.Same(Dispatcher.CurrentDispatcher, timer.Dispatcher); 216Assert.Same(value, timer.Tag); 220Assert.Same(value, timer.Tag);
System\Windows\WeakEventManagerTests.cs (571)
19Assert.Same(manager.Dispatcher, manager.Dispatcher); 20Assert.Same(Dispatcher.CurrentDispatcher, manager.Dispatcher); 58Assert.Same(listener, list[0]); 158Assert.Same(typeof(SubWeakEventManager), t); 159Assert.Same(source, s); 160Assert.Same(args, e); 169Assert.Same(typeof(SubWeakEventManager), t); 170Assert.Same(source, s); 171Assert.Same(args, e); 197Assert.Same(source, s); 198Assert.Same(args, e); 206Assert.Same(source, s); 207Assert.Same(args, e); 235Assert.Same(source, s); 236Assert.Same(args, e); 244Assert.Same(typeof(SubWeakEventManager), t); 245Assert.Same(source, s); 246Assert.Same(args, e); 255Assert.Same(source, s); 256Assert.Same(args, e); 264Assert.Same(typeof(SubWeakEventManager), t); 265Assert.Same(source, s); 266Assert.Same(args, e); 297Assert.Same(typeof(SubWeakEventManager), t); 298Assert.Same(source1, s); 299Assert.Same(args, e); 308Assert.Same(typeof(SubWeakEventManager), t); 309Assert.Same(source2, s); 310Assert.Same(args, e); 448Assert.Same(sender, s); 449Assert.Same(args, e); 459Assert.Same(sender, s); 460Assert.Same(args, e); 484Assert.Same(sender, s); 485Assert.Same(args, e); 493Assert.Same(sender, s); 494Assert.Same(args, e); 519Assert.Same(sender, s); 520Assert.Same(args, e); 529Assert.Same(sender, s); 530Assert.Same(args, e); 539Assert.Same(sender, s); 540Assert.Same(args, e); 549Assert.Same(sender, s); 550Assert.Same(args, e); 682Assert.Same(sender, s); 683Assert.Same(args, a); 721Assert.Same(sender, s); 722Assert.Same(args, a); 774Assert.Same(expectedSource, actualSource); 792Assert.Same(target1, list[0]); 800Assert.Same(target1, list[0]); 811Assert.Same(target1, list[0]); 825Assert.Same(target1, list[0]); 843Assert.Same(expectedSource, actualSource); 865Assert.Same(target1, list[0]); 873Assert.Same(target1, list[0]); 874Assert.Same(target2, list[1]); 882Assert.Same(target1, list[0]); 883Assert.Same(target2, list[1]); 884Assert.Same(target1, list[2]); 892Assert.Same(target1, list[0]); 893Assert.Same(target2, list[1]); 894Assert.Same(target1, list[2]); 895Assert.Same(target1, list[3]); 903Assert.Same(target1, list[0]); 904Assert.Same(target2, list[1]); 905Assert.Same(target1, list[2]); 906Assert.Same(target1, list[3]); 907Assert.Same(target1, list[4]); 915Assert.Same(target1, list[0]); 916Assert.Same(target2, list[1]); 917Assert.Same(target1, list[2]); 918Assert.Same(target1, list[3]); 919Assert.Same(target1, list[4]); 920Assert.Same(target2, list[5]); 928Assert.Same(target1, list[0]); 929Assert.Same(target2, list[1]); 930Assert.Same(target1, list[2]); 931Assert.Same(target1, list[3]); 932Assert.Same(target1, list[4]); 933Assert.Same(target2, list[5]); 934Assert.Same(target2, list[6]); 985Assert.Same(expectedSource, actualSource); 1001Assert.Same(listener, list[0]); 1009Assert.Same(listener, list[0]); 1010Assert.Same(target, list[1]); 1021Assert.Same(expectedSource, actualSource); 1036Assert.Same(target, list[0]); 1044Assert.Same(target, list[0]); 1045Assert.Same(target, list[1]); 1056Assert.Same(expectedSource, actualSource); 1071Assert.Same(target, list[0]); 1081Assert.Same(target, list[0]); 1085Assert.Same(target, list[0]); 1105Assert.Same(target1, list1[0]); 1110Assert.Same(list2, list1); 1113Assert.Same(target1, list2[0]); 1114Assert.Same(target2, list2[1]); 1134Assert.Same(target1, list1[0]); 1145Assert.Same(target1, list1[0]); 1148Assert.Same(target1, list2[0]); 1149Assert.Same(target2, list2[1]); 1169Assert.Same(target1, list1[0]); 1180Assert.Same(list2, list1); 1183Assert.Same(target1, list2[0]); 1184Assert.Same(target2, list2[1]); 1215Assert.Same(handlers[j].Target, list[j]); 1248Assert.Same(expectedSource, actualSource); 1265Assert.Same(listener1, list[0]); 1273Assert.Same(listener1, list[0]); 1274Assert.Same(listener2, list[1]); 1284Assert.Same(listener1, list[0]); 1285Assert.Same(listener2, list[1]); 1289Assert.Same(listener3, list[0]); 1298Assert.Same(listener1, list[0]); 1299Assert.Same(listener2, list[1]); 1303Assert.Same(listener3, list[0]); 1336Assert.Same(listener1, list[0]); 1345Assert.Same(listener1, list[0]); 1346Assert.Same(listener2, list[1]); 1360Assert.Same(expectedSource, actualSource); 1384Assert.Same(listener, list[1]); 1395Assert.Same(expectedSource, actualSource); 1409Assert.Same(listener, list[0]); 1417Assert.Same(listener, list[0]); 1418Assert.Same(listener, list[1]); 1429Assert.Same(expectedSource, actualSource); 1443Assert.Same(listener, list[0]); 1453Assert.Same(listener, list[0]); 1457Assert.Same(listener, list[0]); 1475Assert.Same(listener1, list1[0]); 1480Assert.Same(list2, list1); 1483Assert.Same(listener1, list2[0]); 1484Assert.Same(listener2, list2[1]); 1502Assert.Same(listener1, list1[0]); 1513Assert.Same(listener1, list1[0]); 1516Assert.Same(listener1, list2[0]); 1517Assert.Same(listener2, list2[1]); 1535Assert.Same(listener1, list1[0]); 1546Assert.Same(list2, list1); 1549Assert.Same(listener1, list2[0]); 1550Assert.Same(listener2, list2[1]); 1581Assert.Same(listeners[j], list[j]); 1614Assert.Same(expectedSource, source); 1636Assert.Same(target1, list[0]); 1649Assert.Same(target1, list[0]); 1733Assert.Same(expectedSource, source); 1844Assert.Same(listener, list[0]); 1869Assert.Same(list2, list1); 1872Assert.Same(target2, list2[0]); 1873Assert.Same(target3, list2[1]); 1878Assert.Same(list3, list1); 1881Assert.Same(target3, list3[0]); 1910Assert.Same(list2, list1); 1913Assert.Same(target2, list2[0]); 1914Assert.Same(target3, list2[1]); 1925Assert.Same(target2, list1[0]); 1926Assert.Same(target3, list1[1]); 1929Assert.Same(target3, list3[0]); 1937Assert.Same(target2, list1[0]); 1938Assert.Same(target3, list1[1]); 1965Assert.Same(list2, list1); 1968Assert.Same(target2, list1[0]); 1969Assert.Same(target3, list1[1]); 1980Assert.Same(list3, list1); 1983Assert.Same(target3, list3[0]); 1988Assert.Same(list3, list1); 2020Assert.Same(target, list[0]); 2027Assert.Same(target, list[0]); 2045Assert.Same(target, list[0]); 2052Assert.Same(target, list[0]); 2107Assert.Same(expectedHandlers[i].Target, list[i]); 2153Assert.Same(expectedSource, source); 2174Assert.Same(listener1, list[0]); 2178Assert.Same(listener3, list[0]); 2179Assert.Same(listener4, list[1]); 2187Assert.Same(listener1, list[0]); 2191Assert.Same(listener3, list[0]); 2192Assert.Same(listener4, list[1]); 2202Assert.Same(listener3, list[0]); 2203Assert.Same(listener4, list[1]); 2213Assert.Same(listener4, list[0]); 2253Assert.Same(listener2, list[0]); 2302Assert.Same(list2, list1); 2305Assert.Same(listener2, list2[0]); 2306Assert.Same(listener3, list2[1]); 2311Assert.Same(list3, list1); 2314Assert.Same(listener3, list3[0]); 2340Assert.Same(list2, list1); 2343Assert.Same(listener2, list1[0]); 2344Assert.Same(listener3, list1[1]); 2355Assert.Same(listener2, list1[0]); 2356Assert.Same(listener3, list1[1]); 2359Assert.Same(listener3, list3[0]); 2367Assert.Same(listener2, list1[0]); 2368Assert.Same(listener3, list1[1]); 2392Assert.Same(list2, list1); 2395Assert.Same(listener2, list1[0]); 2396Assert.Same(listener3, list1[1]); 2407Assert.Same(list3, list1); 2410Assert.Same(listener3, list3[0]); 2415Assert.Same(list3, list1); 2446Assert.Same(listener, list[0]); 2453Assert.Same(listener, list[0]); 2470Assert.Same(listener, list[0]); 2477Assert.Same(listener, list[0]); 2584Assert.Same(expectedSource, source); 2595Assert.Same(value, manager[source]); 2601Assert.Same(value, manager[source]); 2623Assert.Same(listener, list[0]); 2624Assert.Same(target, list[1]); 2625Assert.Same(value, manager[source]); 2636Assert.Same(expectedSource, source); 2672Assert.Same(value, manager[source]); 2685Assert.Same(value, manager[source]); 2699Assert.Same(value, manager[source]); 2703Assert.Same(value, manager[source]); 2717Assert.Same(value, manager[source]); 2721Assert.Same(value, manager[source]); 2733Assert.Same(expectedSource, source); 2768Assert.Same(listener, list[0]); 2769Assert.Same(target, list[1]); 2781Assert.Same(expectedSource, source); 2867Assert.Same(listener, manager[source]); 2905Assert.Same(newManager, SubWeakEventManager.GetCurrentManager(typeof(SentinelType2))); 2909Assert.Same(newManager, SubWeakEventManager.GetCurrentManager(typeof(SentinelType2))); 2944Assert.Same(listener1, list[0]); 2945Assert.Same(listener2, list[1]); 2949Assert.Same(listener3, list[0]); 2956Assert.Same(listener1, list[0]); 2957Assert.Same(listener2, list[1]); 2961Assert.Same(listener3, list[0]); 2985Assert.Same(target1, list[0]); 2997Assert.Same(target1, list[0]); 3032Assert.Same(listener1, list[0]); 3033Assert.Same(target1, list[1]); 3034Assert.Same(listener2, list[2]); 3039Assert.Same(listener3, list[0]); 3047Assert.Same(listener1, list[0]); 3048Assert.Same(target1, list[1]); 3049Assert.Same(listener2, list[2]); 3054Assert.Same(listener3, list[0]); 3104Assert.Same(list, ListenerList.Empty); 3137Assert.Same(originalList, list); 3144Assert.Same(originalList, list); 3145Assert.Same(newList, list); 3164Assert.Same(originalList, list); 3170Assert.Same(originalList, list); 3188Assert.Same(originalList, list); 3191Assert.Same(listener1, list[0]); 3192Assert.Same(listener2, list[1]); 3197Assert.Same(originalList, list); 3198Assert.Same(newList, list); 3201Assert.Same(listener1, list[0]); 3202Assert.Same(listener2, list[1]); 3224Assert.Same(listener1, list[0]); 3225Assert.Same(listener2, list[1]); 3230Assert.Same(newList, list); 3233Assert.Same(listener1, list[0]); 3234Assert.Same(listener2, list[1]); 3256Assert.Same(originalList, list); 3259Assert.Same(listener1, list[0]); 3260Assert.Same(listener2, list[1]); 3264Assert.Same(originalList, list); 3267Assert.Same(listener1, list[0]); 3268Assert.Same(listener2, list[1]); 3295Assert.Same(result, list); 3314Assert.Same(listener1, list[0]); 3327Assert.Same(target, list[0]); 3369Assert.Same(listener1, list[0]); 3445Assert.Same(listener1, list[0]); 3451Assert.Same(listener1, list[0]); 3452Assert.Same(listener1, list[1]); 3458Assert.Same(listener1, list[0]); 3459Assert.Same(listener1, list[1]); 3466Assert.Same(listener1, list[0]); 3467Assert.Same(listener1, list[1]); 3469Assert.Same(listener2, list[3]); 3475Assert.Same(listener1, list[0]); 3476Assert.Same(listener1, list[1]); 3478Assert.Same(listener2, list[3]); 3479Assert.Same(listener3, list[4]); 3485Assert.Same(listener1, list[0]); 3486Assert.Same(listener1, list[1]); 3488Assert.Same(listener2, list[3]); 3489Assert.Same(listener3, list[4]); 3490Assert.Same(listener4, list[5]); 3496Assert.Same(listener1, list[0]); 3497Assert.Same(listener1, list[1]); 3499Assert.Same(listener2, list[3]); 3500Assert.Same(listener3, list[4]); 3501Assert.Same(listener4, list[5]); 3502Assert.Same(listener5, list[6]); 3508Assert.Same(listener1, list[0]); 3509Assert.Same(listener1, list[1]); 3511Assert.Same(listener2, list[3]); 3512Assert.Same(listener3, list[4]); 3513Assert.Same(listener4, list[5]); 3514Assert.Same(listener5, list[6]); 3515Assert.Same(listener6, list[7]); 3553Assert.Same(listener, list[0]); 3580Assert.Same(listeners[j], list[j]); 3602Assert.Same(target1, list[0]); 3608Assert.Same(target1, list[0]); 3609Assert.Same(target1, list[1]); 3615Assert.Same(target1, list[0]); 3616Assert.Same(target1, list[1]); 3623Assert.Same(target1, list[0]); 3624Assert.Same(target1, list[1]); 3632Assert.Same(target1, list[0]); 3633Assert.Same(target1, list[1]); 3642Assert.Same(target1, list[0]); 3643Assert.Same(target1, list[1]); 3653Assert.Same(target1, list[0]); 3654Assert.Same(target1, list[1]); 3659Assert.Same(target2, list[6]); 3665Assert.Same(target1, list[0]); 3666Assert.Same(target1, list[1]); 3671Assert.Same(target2, list[6]); 3672Assert.Same(target3, list[7]); 3694Assert.Same(target1, list[0]); 3700Assert.Same(target1, list[0]); 3701Assert.Same(target2, list[1]); 3707Assert.Same(target1, list[0]); 3708Assert.Same(target2, list[1]); 3709Assert.Same(target1, list[2]); 3715Assert.Same(target1, list[0]); 3716Assert.Same(target2, list[1]); 3717Assert.Same(target1, list[2]); 3718Assert.Same(target1, list[3]); 3724Assert.Same(target1, list[0]); 3725Assert.Same(target2, list[1]); 3726Assert.Same(target1, list[2]); 3727Assert.Same(target1, list[3]); 3728Assert.Same(target1, list[4]); 3734Assert.Same(target1, list[0]); 3735Assert.Same(target2, list[1]); 3736Assert.Same(target1, list[2]); 3737Assert.Same(target1, list[3]); 3738Assert.Same(target1, list[4]); 3739Assert.Same(target2, list[5]); 3745Assert.Same(target1, list[0]); 3746Assert.Same(target2, list[1]); 3747Assert.Same(target1, list[2]); 3748Assert.Same(target1, list[3]); 3749Assert.Same(target1, list[4]); 3750Assert.Same(target2, list[5]); 3751Assert.Same(target2, list[6]); 3765Assert.Same(target, list[0]); 3771Assert.Same(target, list[0]); 3772Assert.Same(target, list[1]); 3778Assert.Same(target, list[0]); 3779Assert.Same(target, list[1]); 3780Assert.Same(target, list[2]); 3901Assert.Same(handlers[j].Target, list[j]); 3953Assert.Same(listener1, list[0]); 3954Assert.Same(listener2, list[1]); 3957Assert.Same(listener1, newList[0]); 3958Assert.Same(listener2, newList[1]); 3981Assert.Same(target1, list[0]); 3982Assert.Same(target2, list[1]); 3987Assert.Same(target1, newList[0]); 3988Assert.Same(target2, newList[1]); 4017Assert.Same(listener1, list[0]); 4018Assert.Same(target1, list[1]); 4019Assert.Same(listener2, list[2]); 4020Assert.Same(target2, list[3]); 4025Assert.Same(listener1, newList[0]); 4026Assert.Same(target1, newList[1]); 4027Assert.Same(listener2, newList[2]); 4028Assert.Same(target2, newList[3]); 4120Assert.Same(listener1, newList[0]); 4122Assert.Same(listener2, newList[2]); 4141Assert.Same(listener1, list[0]); 4142Assert.Same(listener2, list[1]); 4145Assert.Same(listener1, newList[0]); 4146Assert.Same(listener2, newList[1]); 4169Assert.Same(target1, list[0]); 4170Assert.Same(target2, list[1]); 4175Assert.Same(target1, newList[0]); 4176Assert.Same(target2, newList[1]); 4205Assert.Same(listener1, list[0]); 4206Assert.Same(target1, list[1]); 4207Assert.Same(listener2, list[2]); 4208Assert.Same(target2, list[3]); 4213Assert.Same(listener1, newList[0]); 4214Assert.Same(target1, newList[1]); 4215Assert.Same(listener2, newList[2]); 4216Assert.Same(target2, newList[3]); 4241Assert.Same(listener1, list[0]); 4242Assert.Same(target1, list[1]); 4245Assert.Same(listener2, newList[0]); 4246Assert.Same(target2, newList[1]); 4247Assert.Same(listener1, newList[2]); 4248Assert.Same(target1, newList[3]); 4270Assert.Same(listener1, list[0]); 4271Assert.Same(listener1, list[1]); 4316Assert.Same(managerType, t); 4317Assert.Same(sender, s); 4318Assert.Same(args, e); 4327Assert.Same(managerType, t); 4328Assert.Same(sender, s); 4329Assert.Same(args, e); 4351Assert.Same(sender, s); 4352Assert.Same(args, e); 4360Assert.Same(sender, s); 4361Assert.Same(args, e); 4384Assert.Same(sender, s); 4385Assert.Same(args, e); 4393Assert.Same(managerType, t); 4394Assert.Same(sender, s); 4395Assert.Same(args, e); 4404Assert.Same(sender, s); 4405Assert.Same(args, e); 4413Assert.Same(managerType, t); 4414Assert.Same(sender, s); 4415Assert.Same(args, e); 4585Assert.Same(listener1, list[0]); 4586Assert.Same(listener2, list[1]); 4605Assert.Same(target1, list[0]); 4629Assert.Same(listener1, list[0]); 4630Assert.Same(target1, list[1]); 4631Assert.Same(listener2, list[2]); 4678Assert.Same(listener1, list[0]); 4735Assert.Same(listener1, list[0]); 4736Assert.Same(listener2, list[1]); 4737Assert.Same(listener3, list[2]); 4743Assert.Same(listener1, list[0]); 4744Assert.Same(listener2, list[1]); 4750Assert.Same(listener2, list[0]); 4779Assert.Same(listener1, list[0]); 4781Assert.Same(listener2, list[2]); 4787Assert.Same(listener1, list[0]); 4828Assert.Same(listener1, list[0]); 4829Assert.Same(listener2, list[1]); 4830Assert.Same(listener3, list[2]); 4831Assert.Same(listener4, list[3]); 4837Assert.Same(listener1, list[0]); 4838Assert.Same(listener2, list[1]); 4839Assert.Same(listener3, list[2]); 4845Assert.Same(listener1, list[0]); 4846Assert.Same(listener3, list[1]); 4852Assert.Same(listener3, list[0]); 4883Assert.Same(listener1, list[0]); 4885Assert.Same(listener2, list[2]); 4891Assert.Same(listener1, list[0]); 4893Assert.Same(listener2, list[2]); 4900Assert.Same(listener2, list[1]); 4907Assert.Same(listener2, list[1]); 4945Assert.Same(listener1, list[0]); 4946Assert.Same(listener2, list[1]); 4947Assert.Same(listener3, list[2]); 4948Assert.Same(listener4, list[3]); 4949Assert.Same(listener5, list[4]); 4950Assert.Same(listener6, list[5]); 4956Assert.Same(listener1, list[0]); 4957Assert.Same(listener2, list[1]); 4958Assert.Same(listener3, list[2]); 4959Assert.Same(listener4, list[3]); 4960Assert.Same(listener5, list[4]); 4966Assert.Same(listener1, list[0]); 4967Assert.Same(listener3, list[1]); 4968Assert.Same(listener4, list[2]); 4969Assert.Same(listener5, list[3]); 4975Assert.Same(listener3, list[0]); 4976Assert.Same(listener4, list[1]); 4977Assert.Same(listener5, list[2]); 5014Assert.Same(listener1, list[0]); 5016Assert.Same(listener2, list[2]); 5017Assert.Same(listener3, list[3]); 5018Assert.Same(listener4, list[4]); 5019Assert.Same(listener5, list[5]); 5025Assert.Same(listener1, list[0]); 5027Assert.Same(listener2, list[2]); 5028Assert.Same(listener3, list[3]); 5029Assert.Same(listener4, list[4]); 5035Assert.Same(listener1, list[0]); 5037Assert.Same(listener3, list[2]); 5038Assert.Same(listener4, list[3]); 5045Assert.Same(listener3, list[1]); 5046Assert.Same(listener4, list[2]); 5053Assert.Same(listener3, list[1]); 5054Assert.Same(listener4, list[2]); 5095Assert.Same(listener1, list[0]); 5096Assert.Same(listener2, list[1]); 5097Assert.Same(listener3, list[2]); 5098Assert.Same(listener4, list[3]); 5099Assert.Same(listener5, list[4]); 5100Assert.Same(listener6, list[5]); 5101Assert.Same(listener7, list[6]); 5107Assert.Same(listener1, list[0]); 5108Assert.Same(listener2, list[1]); 5109Assert.Same(listener3, list[2]); 5110Assert.Same(listener4, list[3]); 5111Assert.Same(listener5, list[4]); 5112Assert.Same(listener6, list[5]); 5118Assert.Same(listener1, list[0]); 5119Assert.Same(listener3, list[1]); 5120Assert.Same(listener4, list[2]); 5121Assert.Same(listener5, list[3]); 5122Assert.Same(listener6, list[4]); 5128Assert.Same(listener3, list[0]); 5129Assert.Same(listener4, list[1]); 5130Assert.Same(listener5, list[2]); 5131Assert.Same(listener6, list[3]); 5171Assert.Same(listener1, list[0]); 5173Assert.Same(listener2, list[2]); 5174Assert.Same(listener3, list[3]); 5175Assert.Same(listener4, list[4]); 5176Assert.Same(listener5, list[5]); 5177Assert.Same(listener6, list[6]); 5183Assert.Same(listener1, list[0]); 5185Assert.Same(listener2, list[2]); 5186Assert.Same(listener3, list[3]); 5187Assert.Same(listener4, list[4]); 5188Assert.Same(listener5, list[5]); 5194Assert.Same(listener1, list[0]); 5196Assert.Same(listener3, list[2]); 5197Assert.Same(listener4, list[3]); 5198Assert.Same(listener5, list[4]); 5205Assert.Same(listener3, list[1]); 5206Assert.Same(listener4, list[2]); 5207Assert.Same(listener5, list[3]); 5214Assert.Same(listener3, list[1]); 5215Assert.Same(listener4, list[2]); 5216Assert.Same(listener5, list[3]); 5303Assert.Same(listener, list[0]); 5309Assert.Same(listener, list[0]); 5315Assert.Same(listener, list[0]); 5622Assert.Same(expectedHandlers[i].Target, list[i]); 5715Assert.Same(listener1, list[0]); 5716Assert.Same(listener2, list[1]); 5719Assert.Same(listener1, newList[0]); 5720Assert.Same(listener2, newList[1]); 5743Assert.Same(target1, list[0]); 5744Assert.Same(target2, list[1]); 5749Assert.Same(target1, newList[0]); 5750Assert.Same(target2, newList[1]); 5779Assert.Same(listener1, list[0]); 5780Assert.Same(target1, list[1]); 5781Assert.Same(listener2, list[2]); 5782Assert.Same(target2, list[3]); 5787Assert.Same(listener1, newList[0]); 5788Assert.Same(target1, newList[1]); 5789Assert.Same(listener2, newList[2]); 5790Assert.Same(target2, newList[3]); 5812Assert.Same(managerType, t); 5813Assert.Same(sender, s); 5814Assert.Same(args, e); 5823Assert.Same(managerType, t); 5824Assert.Same(sender, s); 5825Assert.Same(args, e); 5847Assert.Same(sender, s); 5848Assert.Same(args, e); 5856Assert.Same(sender, s); 5857Assert.Same(args, e); 5865Assert.Same(sender, s); 5866Assert.Same(args, e); 5891Assert.Same(sender, s); 5892Assert.Same(args, e); 5900Assert.Same(managerType, t); 5901Assert.Same(sender, s); 5902Assert.Same(args, e); 5911Assert.Same(sender, s); 5912Assert.Same(args, e); 5920Assert.Same(managerType, t); 5921Assert.Same(sender, s); 5922Assert.Same(args, e); 5931Assert.Same(sender, s); 5932Assert.Same(args, e);
System\Windows\WeakEventManagerTTests.cs (4)
26Assert.Same(source1, sender); 27Assert.Same(e, actualE); 32Assert.Same(source1, sender); 33Assert.Same(e, actualE);