167Assert.IsType<TestTypes.SingleThreadSynchronizationContext>(SynchronizationContext.Current); 232Assert.IsType<TestTypes.SingleThreadSynchronizationContext>(SynchronizationContext.Current);

124var qex = Assert.IsType<QuicException>(ex.InnerException); 140var qex = Assert.IsType<QuicException>(ex.InnerException?.InnerException?.InnerException); 157var qex = Assert.IsType<QuicException>(ex.InnerException?.InnerException?.InnerException); 171var qex = Assert.IsType<QuicException>(ex.InnerException);

95Assert.IsType<OperationCanceledException>(exception); 134Assert.IsType<ConnectionResetException>(exception); 177Assert.IsType<OperationCanceledException>(exception); 218Assert.IsType<OperationCanceledException>(exception); 275Assert.IsType<ConnectionResetException>(exception);

52Assert.IsType<InvalidOperationException>(readException); 53Assert.IsType<InvalidOperationException>(writeException);

93Assert.IsType<ConnectionAbortedException>(exception);

1166Assert.IsType<Http2StreamErrorException>(thrownEx.InnerException); 1201Assert.IsType<Http2StreamErrorException>(thrownEx.InnerException); 1237Assert.IsType<Http2StreamErrorException>(thrownEx.InnerException); 1273Assert.IsType<Http2StreamErrorException>(thrownEx.InnerException); 3442Assert.IsType<ConnectionAbortedException>(thrownEx); 3469Assert.IsType<TaskCanceledException>(thrownEx); 3471Assert.IsType<ConnectionAbortedException>(thrownEx.InnerException);

104Assert.IsType<NotSupportedException>(errorException);

1082Assert.IsType<WindowsPrincipal>(context.User);

577var innerEx = Assert.IsType<HttpProtocolException>(ex.InnerException); 686var innerEx = Assert.IsType<HttpProtocolException>(ex.InnerException); 2083Assert.IsType<ConnectionAbortedException>(rootException);

79Assert.IsType<KeyValuePair<string, JsonValue>>(value);

43Assert.IsType<JsonObject>(new JsonValue(new JsonObject()).AsJsonObject); 50Assert.IsType<JsonArray>(new JsonValue(new JsonArray()).AsJsonArray); 142Assert.IsType<JsonObject>(new JsonValue(new JsonObject()).AsJsonObject); 150Assert.IsType<JsonArray>(new JsonValue(new JsonArray()).AsJsonArray); 171Assert.IsType<JsonObject>(new JsonValue(new JsonObject()).AsObject); 172Assert.IsType<JsonArray>(new JsonValue(new JsonArray()).AsObject);

120var prop = Assert.IsType<JProperty>(item); 121var lib = Assert.IsType<JObject>(prop.Value); 135var obj = Assert.IsType<JProperty>(item); 148var obj = Assert.IsType<JProperty>(item);

80Assert.IsType<InvalidOperationException>(context.Exception); 128Assert.IsType<Exception>(context.Exception); 179Assert.IsType<Exception>(context.Exception); 229Assert.IsType<Exception>(context.Exception);

996var symmetricKey = Assert.IsType<SymmetricSecurityKey>(securityKey);

103Assert.IsType<AssertionRequirement>(policy.Requirements.First());

218Assert.IsType<ClaimsAuthorizationRequirement>(allowed.Failure.FailedRequirements.First());

292component => Assert.IsType<CascadingAuthenticationState>(component), 293component => Assert.IsType<CascadingValue<Task<AuthenticationState>>>(component), 295component => Assert.IsType<LayoutView>(component), 296component => Assert.IsType<TestPageWithNoAuthorization>(component)); 320component => Assert.IsType<CascadingValue<Task<AuthenticationState>>>(component), 321component => Assert.IsType<AuthorizeRouteView>(component), 326component => Assert.IsType<LayoutView>(component), 327component => Assert.IsType<TestPageWithNoAuthorization>(component));

46req => Assert.IsType<DenyAnonymousAuthorizationRequirement>(req)); 81req => Assert.IsType<DenyAnonymousAuthorizationRequirement>(req)); 109req => Assert.IsType<DenyAnonymousAuthorizationRequirement>(req)); 145req => Assert.IsType<DenyAnonymousAuthorizationRequirement>(req)); 181req => Assert.IsType<DenyAnonymousAuthorizationRequirement>(req)); 228req => Assert.IsType<DenyAnonymousAuthorizationRequirement>(req)); 345req => Assert.IsType<DenyAnonymousAuthorizationRequirement>(req)); 403req => Assert.IsType<DenyAnonymousAuthorizationRequirement>(req)); 474Assert.IsType<DenyAnonymousAuthorizationRequirement>(req));

98Assert.IsType<T>(frame.Component);

635var list = Assert.IsType<List<int>>(result); 951var dictionary = Assert.IsType<ImmutableDictionary<int, int>>(result); 1005var dictionary = Assert.IsType<ReadOnlyDictionary<int, int>>(result); 1035var dictionary = Assert.IsType<ReadOnlyDictionary<int, int>>(result); 1144var dictionary = Assert.IsType<Dictionary<int, int>>(result); 1203var dictionary = Assert.IsType<Dictionary<int, int>>(result); 1246var dictionary = Assert.IsType<TImplementation>(result); 1274var list = Assert.IsType<TImplementation>(result);

198var invoked = Assert.IsType<InvokedRenderModes>(mode); 236var rawValue = Assert.IsType<JsonElement>(value); 310var rawValue = Assert.IsType<JsonElement>(value); 576var rawValue = Assert.IsType<JsonElement>(value); 656var rawValue = Assert.IsType<JsonElement>(value); 1237var rawValue = Assert.IsType<JsonElement>(value); 1266var rawValue = Assert.IsType<JsonElement>(value); 1360var stateContent = Assert.IsType<EndpointHtmlRenderer.ComponentStateHtmlContent>(content); 1390var stateContent = Assert.IsType<EndpointHtmlRenderer.ComponentStateHtmlContent>(content); 1426var stateContent = Assert.IsType<EndpointHtmlRenderer.ComponentStateHtmlContent>(content); 1480var stateContent = Assert.IsType<EndpointHtmlRenderer.ComponentStateHtmlContent>(content); 1546var stateContent = Assert.IsType<EndpointHtmlRenderer.ComponentStateHtmlContent>(content); 1615var stateContent = Assert.IsType<EndpointHtmlRenderer.ComponentStateHtmlContent>(content);

49var endpoint = Assert.IsType<RouteEndpoint>( 84var endpoint = Assert.IsType<RouteEndpoint>(Assert.Single(endpointDataSource.Endpoints, 108var endpoint = Assert.IsType<RouteEndpoint>(Assert.Single(endpointDataSource.Endpoints, e => e.Metadata.GetMetadata<RootComponentMetadata>() != null)); 118var updatedEndpoint = Assert.IsType<RouteEndpoint>(Assert.Single(endpointDataSource.Endpoints, e => e.Metadata.GetMetadata<RootComponentMetadata>() != null)); 134var endpoint = Assert.IsType<RouteEndpoint>(Assert.Single(endpointDataSource.Endpoints, e => e.Metadata.GetMetadata<RootComponentMetadata>() != null)); 136var compositeEndpoint = Assert.IsType<RouteEndpoint>(Assert.Single(compositeEndpointDataSource.Endpoints, e => e.Metadata.GetMetadata<RootComponentMetadata>() != null)); 183var endpoint = Assert.IsType<RouteEndpoint>(Assert.Single(endpointDataSource.Endpoints, e => e.Metadata.GetMetadata<RootComponentMetadata>() != null));

36var routeEndpoint = Assert.IsType<RouteEndpoint>(endpoint); 133var routeEndpoint = Assert.IsType<RouteEndpoint>(endpoint);

154result[i] = Assert.IsType<TestModel>(value);

98Assert.IsType<T>(frame.Component);

150var componentException = Assert.IsType<JSDisconnectedException>(component.ExceptionDuringDisposeAsync); 285var aex = Assert.IsType<AggregateException>(reportedErrors.Single().ExceptionObject); 541var component = Assert.IsType<DynamicallyAddedComponent>(componentState.Component); 567var component = Assert.IsType<DynamicallyAddedComponent>(componentState.Component); 594var component = Assert.IsType<DynamicallyAddedComponent>(componentState.Component); 628var component = Assert.IsType<DynamicallyAddedComponent>(componentState.Component); 632var exception = Assert.IsType<InvalidOperationException>(evt.Arguments.ExceptionObject); 665var component = Assert.IsType<DynamicallyAddedComponent>(componentState.Component); 669var exception = Assert.IsType<InvalidOperationException>(evt.Arguments.ExceptionObject);

233Assert.IsType<ArgumentException>(innerException);

398var bindingFailure = Assert.IsType<InvocationBindingFailureMessage>(message);

26Assert.IsType<EmptyComponent>(instance); 54var component = Assert.IsType<ComponentWithInjectProperties>(instance); // Custom activator returns a different type 87var component = Assert.IsType<DerivedComponent>(instance); 112var component = Assert.IsType<ComponentWithNonInjectableProperties>(instance); 132Assert.IsType<ComponentWithInjectProperties>(instance); 157Assert.IsType<TestRenderMode>(renderer.SuppliedRenderMode); 247var component = Assert.IsType<ComponentWithConstructorInjection>(instance);

124Assert.IsType<TestComponent>(instance.Instance);

83Assert.IsType<MessageComponent>(componentFrame.Component); 2248Assert.IsType<FakeComponent>(childComponent3); 2301var aex = Assert.IsType<AggregateException>(Assert.Single(renderer.HandledExceptions)); 2460var aex = Assert.IsType<InvalidOperationException>(Assert.Single(renderer.HandledExceptions)); 2495Assert.IsType<TaskCanceledException>(Assert.Single(renderer.HandledExceptions)); 2539var aex = Assert.IsType<TaskCanceledException>(Assert.Single(renderer.HandledExceptions)); 2603var ex = Assert.IsType<Exception>(Assert.Single(renderer.HandledExceptions)); 4221var nestedComponent = Assert.IsType<DisposableComponent>(componentFrame.Component); 4257var aex = Assert.IsType<AggregateException>(Assert.Single(renderer.HandledExceptions)); 4502Assert.IsType<MessageComponent>(suppliedComponent); 4520Assert.IsType<MessageComponent>(suppliedComponent);

828Assert.IsType<FakeComponent2>(batchBuilder.ReferenceFramesBuffer.Buffer[entry.ReferenceFrameIndex].Component); 1922Assert.IsType<FakeComponent>(capturedInstance1); 1923Assert.IsType<FakeComponent>(capturedInstance2); 1962Assert.IsType<FakeComponent>(capturedInstance);

33frame => AssertFrame.Attribute(frame, "eventname", v => Assert.IsType<Action>(v), 1), 61frame => AssertFrame.Attribute(frame, "eventname", v => Assert.IsType<Action>(v), 1), 94frame => AssertFrame.Attribute(frame, "eventname", v => Assert.IsType<Action>(v), 1), 97frame => AssertFrame.Attribute(frame, "eventname", v => Assert.IsType<Action>(v), 4), 125frame => AssertFrame.Attribute(frame, "eventname", v => Assert.IsType<Action>(v), 1)); 149frame => AssertFrame.Attribute(frame, "eventname", v => Assert.IsType<Action>(v), 1)); 183frame => AssertFrame.Attribute(frame, "eventname", v => Assert.IsType<Action>(v), 4));

98Assert.IsType<T>(frame.Component);

28Assert.IsType<SupplyParameterFromFormValueProvider>(supplier.ValueSupplier);

98Assert.IsType<T>(frame.Component);

48Assert.IsType<CbcAuthenticatedEncryptor>(encryptor);

48Assert.IsType<CngGcmAuthenticatedEncryptor>(encryptor);

45Assert.IsType<ManagedAuthenticatedEncryptor>(encryptor);

33Assert.IsType<AuthenticatedEncryptorConfiguration>(options.AuthenticatedEncryptorConfiguration); 36f => Assert.IsType<CngGcmAuthenticatedEncryptorFactory>(f), 37f => Assert.IsType<CngCbcAuthenticatedEncryptorFactory>(f), 38f => Assert.IsType<ManagedAuthenticatedEncryptorFactory>(f), 39f => Assert.IsType<AuthenticatedEncryptorFactory>(f)); 64k => Assert.IsType<MyKeyEscrowSink1>(k), 65k => Assert.IsType<MyKeyEscrowSink2>(k)); 68Assert.IsType<ManagedAuthenticatedEncryptorConfiguration>(options.AuthenticatedEncryptorConfiguration); 71f => Assert.IsType<CngGcmAuthenticatedEncryptorFactory>(f), 72f => Assert.IsType<CngCbcAuthenticatedEncryptorFactory>(f), 73f => Assert.IsType<ManagedAuthenticatedEncryptorFactory>(f), 74f => Assert.IsType<AuthenticatedEncryptorFactory>(f));

48Assert.IsType<MyKeyEscrowSink1>(actualKeyEscrowSinks[0]); 49Assert.IsType<MyKeyEscrowSink2>(actualKeyEscrowSinks[1]);

24Assert.IsType<ClassWithParameterlessCtor>(instance); 117Assert.IsType<ClassWithParameterlessCtor>(activator.CreateInstance(typeof(object), newName, out var forwarded));

990Assert.IsType<InvalidOperationException>(logCollector.GetSnapshot()[0].Exception);

88Assert.IsType<Exception>(suppressContext.Exception);

569Assert.IsType<ApplicationException>(exception.InnerException);

98Assert.IsType<DateTimeOffsetParser>(key.Parser);

68Assert.IsType<InvalidOperationException>(captured);

558Assert.IsType<MyContainer>(app.ApplicationServices); 574Assert.IsType<MyContainer>(app.ApplicationServices); 590Assert.IsType<MyContainer>(app.ApplicationServices);

40entry => Assert.Equal("Hi", Assert.IsType<UnencodedString>(entry).Value), 73entry => Assert.Equal("Hi", Assert.IsType<EncodedString>(entry).Value), 90entry => Assert.Equal("Hi", Assert.IsType<UnencodedString>(entry).Value)); 124entry => Assert.Equal("Hi", Assert.IsType<EncodedString>(entry).Value));

24Assert.IsType<string>(result); 72var testHtmlContent = Assert.IsType<TestHtmlContent>(result); 130entry => Assert.Equal("some-content", Assert.IsType<string>(entry)), 131entry => Assert.Equal(new TestHtmlContent("hello"), Assert.IsType<TestHtmlContent>(entry)), 132entry => Assert.Equal("Test", Assert.IsType<string>(entry))); 158entry => Assert.Equal("some-content", Assert.IsType<string>(entry)), 159entry => Assert.Equal(new TestHtmlContent("hello"), Assert.IsType<TestHtmlContent>(entry)), 160entry => Assert.Equal("Test", Assert.IsType<string>(entry))); 182entry => Assert.Equal("some-content", Assert.IsType<string>(entry)), 183entry => Assert.Equal(new TestHtmlContent("hello"), Assert.IsType<TestHtmlContent>(entry)), 184entry => Assert.Equal("Test", Assert.IsType<string>(entry))); 210entry => Assert.Equal("some-content", Assert.IsType<string>(entry)), 211entry => Assert.Equal(new TestHtmlContent("hello"), Assert.IsType<TestHtmlContent>(entry)), 212entry => Assert.Equal("Test", Assert.IsType<string>(entry)));

28Assert.IsType<Todo>(todo);

53var storage = Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 54var otherStorage = Assert.IsType<KeyValuePair<string, object?>[]>(other._arrayStorage); 122Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 128var address = Assert.IsType<Address>(kvp.Value); 144Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 224var value = Assert.IsType<bool>(kvp.Value); 245var value = Assert.IsType<bool>(kvp.Value); 297var value = Assert.IsType<bool>(kvp.Value); 303var value = Assert.IsType<bool>(kvp.Value); 520Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 537Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 554Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 581Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 598Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 612Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 626Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 646Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 663Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 680Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 724Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 738Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 752Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 769Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 783Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 797Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 814Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 828Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 858Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 886Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 907Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 928Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 948Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1008Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1028Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1047Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1066Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1086Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1255Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1272Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1289Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1314Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1334Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1354Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1374Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1395Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1451Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1466Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1481Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1499Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1517Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1535Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1595Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1612Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1629Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1648Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1668Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1688Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1713Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1738Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1763Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1997Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 2015Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 2033Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 2046var storage = Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 2056storage = Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 2070var storage = Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 2077storage = Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage);

273Assert.True(Assert.IsType<bool>(context.Items["before"])); 274Assert.True(Assert.IsType<bool>(context.Items["after"])); 277Assert.IsType<Middleware>(middlewareFactory.Created); 278Assert.IsType<Middleware>(middlewareFactory.Released);

1868Assert.IsType<WindowsPrincipal>(currentUser); 3560var feature = Assert.IsType<HttpRequestTimeoutFeature>(context.Features.Get<IHttpContextFeature>()?.HttpContext.Features.Get<IHttpRequestTimeoutFeature>());

137Assert.IsType<WebSocketError>(ex);

45Assert.IsType<DefaultJsonTypeInfoResolver>(options.TypeInfoResolver);

395Assert.IsType<BindAsyncFromImplicitStaticAbstractInterface>(result); 413Assert.IsType<BindAsyncFromExplicitStaticAbstractInterface>(result); 463Assert.IsType<BindAsyncFromStaticAbstractInterfaceAndBindAsync>(result);

534var value = Assert.IsType<JsonElement>(extension.Value);

235Assert.IsType<CustomProblemDetailsTypeInfoResolver>(jsonOptions.Value.SerializerOptions.TypeInfoResolverChain[0]); 237Assert.IsType<DefaultJsonTypeInfoResolver>(jsonOptions.Value.SerializerOptions.TypeInfoResolverChain[2]);

159Assert.IsType<int>(parameterInfo.DefaultValue); 161Assert.IsType<int>(parameterInfo.RawDefaultValue);

113Assert.IsType<EmptyHttpResult>(response); 2225var invokedInContext = Assert.IsType<bool>(httpContext.Items["invoked"]); 3099Assert.IsType<EmptyHttpResult>(response);

31var result = Assert.IsType<GeneratorRunResult>(generatorRunResult); 88var result = Assert.IsType<GeneratorRunResult>(generatorRunResult); 107var result = Assert.IsType<GeneratorRunResult>(generatorRunResult);

27var results = Assert.IsType<GeneratorRunResult>(generatorRunResult); 199var result = Assert.IsType<GeneratorRunResult>(generatorRunResult); 247var result = Assert.IsType<GeneratorRunResult>(Assert.Single(generatorRunResult.Results)); 301var result = Assert.IsType<GeneratorRunResult>(Assert.Single(generatorRunResult.Results)); 348var result = Assert.IsType<GeneratorRunResult>(Assert.Single(generatorRunResult.Results)); 684var result = Assert.IsType<GeneratorRunResult>(Assert.Single(generatorRunResult.Results)); 754var result = Assert.IsType<GeneratorRunResult>(generatorRunResult); 774var results = Assert.IsType<GeneratorRunResult>(generatorRunResult);

91.Select(output => Assert.IsType<RequestDelegateGenerator.StaticRouteHandlerModel.Endpoint>(output.Value)) 184var generatedCode = Assert.IsType<GeneratedCodeAttribute>(generatedCodeAttribute);

287var input = Assert.IsType<ParameterListWithReadOnlyProperties>(httpContext.Items["input"]); 344var value = Assert.IsType<InheritBindAsync>(httpContext.Items["value"]); 345var anotherValue = Assert.IsType<MyBindAsyncRecord>(httpContext.Items["anotherValue"]);

307var traceIdArgument = Assert.IsType<TraceIdentifier>(httpContext.Items["traceId"]); 409var formFilesArgument = Assert.IsType<FormFileCollection>(httpContext.Items["formFiles"]); 775var traceIdArgument = Assert.IsType<TraceIdentifier>(httpContext.Items["traceId"]); 904var content = Assert.IsType<MyTryParseRecord>(httpContext.Items["tryParsable"]); 978Assert.IsType<InvalidDataException>(logMessage.Exception); 1018Assert.IsType<InvalidDataException>(badHttpRequestException.InnerException);

436var resultStruct = Assert.IsType<BodyStruct>(httpContext.Items["targetStruct"]);

172Assert.IsType<TestService>(httpContext.Items["arg2"]); 201Assert.IsType<TestService>(httpContext.Items["arg2"]);

613Assert.IsType<JsonException>(logMessage.Exception); 655Assert.IsType<JsonException>(badHttpRequestException.InnerException);

61var errors = Assert.IsType<JsonElement>(errorsObj); 111var errors = Assert.IsType<JsonElement>(errorsObj); 169var errors = Assert.IsType<JsonElement>(errorsObj);

91.Select(output => Assert.IsType<RequestDelegateGenerator.StaticRouteHandlerModel.Endpoint>(output.Value)) 184var generatedCode = Assert.IsType<GeneratedCodeAttribute>(generatedCodeAttribute);

186Assert.IsType<string>(result.Value); 203Assert.IsType<string>(result.Value);

115Assert.IsType<string>(result.Value); 127Assert.IsType<string>(result.Value);

158Assert.IsType<string>(result.Value); 170Assert.IsType<string>(result.Value);

136Assert.IsType<string>(result.Value); 148Assert.IsType<string>(result.Value);

154Assert.IsType<string>(result.Value); 170Assert.IsType<string>(result.Value);

154Assert.IsType<string>(result.Value); 167Assert.IsType<string>(result.Value);

204var one = Assert.IsType<JsonTodo>(body[0]); 209var two = Assert.IsType<JsonTodo>(body[1]); 214var three = Assert.IsType<TodoJsonChild>(body[2]);

158Assert.IsType<string>(result.Value); 170Assert.IsType<string>(result.Value);

296Assert.IsType<string>(result.Value); 309Assert.IsType<string>(result.Value);

118Assert.IsType<string>(result.Value); 130Assert.IsType<string>(result.Value);

135Assert.IsType<string>(result.Value); 147Assert.IsType<string>(result.Value);

226Assert.IsType<ProblemDetails>(result.Value); 238Assert.IsType<ProblemDetails>(result.Value);

1414Assert.IsType<HttpValidationProblemDetails>(result.ProblemDetails); 1445Assert.IsType<HttpValidationProblemDetails>(result.ProblemDetails);

31RouteValuesAddress = Assert.IsType<RouteValuesAddress>(address);

135Assert.IsType<string>(result.Value); 147Assert.IsType<string>(result.Value);

146Assert.IsType<HttpValidationProblemDetails>(result.Value); 158Assert.IsType<HttpValidationProblemDetails>(result.Value);

23Assert.IsType<NoopRoleStore>(sp.GetRequiredService<IRoleStore<PocoRole>>()); 24Assert.IsType<RoleManager<PocoRole>>(sp.GetRequiredService<RoleManager<PocoRole>>()); 26Assert.IsType<UserClaimsPrincipalFactory<PocoUser, PocoRole>>(sp.GetRequiredService<IUserClaimsPrincipalFactory<PocoUser>>()); 195Assert.IsType<RoleManager<PocoRole>>(provider.GetRequiredService<RoleManager<PocoRole>>()); 196Assert.IsType<UserManager<PocoUser>>(provider.GetRequiredService<UserManager<PocoUser>>()); 212Assert.IsType<MySignInManager>(provider.GetRequiredService<SignInManager<PocoUser>>()); 213Assert.IsType<SecurityStampValidator<PocoUser>>(provider.GetRequiredService<ISecurityStampValidator>()); 214Assert.IsType<TwoFactorSecurityStampValidator<PocoUser>>(provider.GetRequiredService<ITwoFactorSecurityStampValidator>()); 232Assert.IsType<MySignInManager>(provider.GetRequiredService<SignInManager<PocoUser>>()); 233Assert.IsType<SecurityStampValidator<PocoUser>>(provider.GetRequiredService<ISecurityStampValidator>()); 234Assert.IsType<TwoFactorSecurityStampValidator<PocoUser>>(provider.GetRequiredService<ITwoFactorSecurityStampValidator>());

25var fixture = Assert.IsType<TestAssemblyFixtureWithAll>(fixtureObject); 40var fixture = Assert.IsType<TestAssemblyFixtureWithMessageSink>(fixtureObject); 59var fixture = Assert.IsType<TextAssemblyFixtureWithDispose>(fixtureObject); 80var fixture = Assert.IsType<TextAssemblyFixtureWithDispose>(fixtureObject); 99var fixture = Assert.IsType<TestAssemblyFixtureWithAsyncDispose>(fixtureObject); 121var fixture = Assert.IsType<TestAssemblyFixtureWithAsyncDispose>(fixtureObject);

57Assert.IsType<ListAdapter>(adapter); 135Assert.IsType<PocoAdapter>(adapter); 188Assert.IsType<PocoAdapter>(adapter);

164Assert.IsType<JsonPatchDocument<SimpleObject>>(deserialized);

57Assert.IsType<ListAdapter>(adapter); 152Assert.IsType<PocoAdapter>(adapter); 205Assert.IsType<PocoAdapter>(adapter);

125Assert.IsType<JsonPatchDocument<SimpleObject>>(deserialized);

770Assert.IsType<TooManyModelErrorsException>(error.Exception); 799Assert.IsType<TooManyModelErrorsException>(error.Exception); 840Assert.IsType<TooManyModelErrorsException>(error.Exception); 871Assert.IsType<TooManyModelErrorsException>(error.Exception); 904Assert.IsType<TooManyModelErrorsException>(error.Exception); 930Assert.IsType<TooManyModelErrorsException>(error.Exception);

47Assert.IsType<TestOutputFormatter>(format.Formatter); 112Assert.IsType<TestOutputFormatter>(format.Formatter); 125Assert.IsType<TestOutputFormatter>(format.Formatter); 170Assert.IsType<TestOutputFormatter>(format.Formatter); 228Assert.IsType<TestOutputFormatter>(format.Formatter);

473Assert.IsType<IntRouteConstraint>(Assert.Single(id2.RouteInfo.Constraints));

1534constraint => Assert.IsType<MinLengthRouteConstraint>(constraint), 1535constraint => Assert.IsType<GuidRouteConstraint>(constraint), 1536constraint => Assert.IsType<MaxLengthRouteConstraint>(constraint));

71var objectResult = Assert.IsType<ObjectResult>(result); 89var objectResult = Assert.IsType<ObjectResult>(result); 107var objectResult = Assert.IsType<ObjectResult>(result);

135c => Assert.IsType<ApiVisibilityConvention>(c), 136c => Assert.IsType<ClientErrorResultFilterConvention>(c), 137c => Assert.IsType<InvalidModelStateFilterConvention>(c), 138c => Assert.IsType<ConsumesConstraintForFormFileParameterConvention>(c), 141var convention = Assert.IsType<ApiConventionApplicationModelConvention>(c); 144c => Assert.IsType<InferParameterBindingInfoConvention>(c));

158return Assert.IsType<TValue>(action.Properties[typeof(TValue)]);

141var authorizationFilter = Assert.IsType<AuthorizeFilter>(Assert.Single(action.Filters)); 168var actionFilter = Assert.IsType<AuthorizeFilter>(Assert.Single(action.Filters));

26var consumesAttribute = Assert.IsType<ConsumesAttribute>(attribute); 47var consumesAttribute = Assert.IsType<ConsumesAttribute>(attribute);

52var property = Assert.IsType<ControllerBoundPropertyDescriptor>(parameter);

73Assert.Equal(2, Assert.IsType<MyFilterAttribute>(filter2.Filter).Value); 77Assert.Equal(3, Assert.IsType<MyFilterAttribute>(filter3.Filter).Value); 94var constraint = Assert.IsType<HttpMethodActionConstraint>(Assert.Single(descriptor.ActionConstraints)); 111var constraint = Assert.IsType<HttpMethodActionConstraint>(Assert.Single(descriptor.ActionConstraints)); 266metadata => Assert.IsType<AuthorizeAttribute>(metadata), 267metadata => Assert.IsType<AllowAnonymousAttribute>(metadata)); 274metadata => Assert.Equal("ControllerPolicy", Assert.IsType<AuthorizeAttribute>(metadata).Policy), 275metadata => Assert.Equal("ActionPolicy", Assert.IsType<AuthorizeAttribute>(metadata).Policy)); 291metadata => Assert.IsType<RouteAttribute>(metadata), 292metadata => Assert.IsType<HttpGetAttribute>(metadata), 295var httpMethodMetadata = Assert.IsType<HttpMethodMetadata>(metadata); 486var methodConstraint = Assert.IsType<HttpMethodActionConstraint>(Assert.Single(action.ActionConstraints)); 511var methodConstraint = Assert.IsType<HttpMethodActionConstraint>(Assert.Single(action.ActionConstraints));

85Assert.IsType<FromQueryAttribute>(attribute); 102Assert.IsType<FromServicesAttribute>(attribute); 137Assert.IsType<FromQueryAttribute>(attribute); 154Assert.IsType<FromServicesAttribute>(attribute); 190Assert.IsType<FromQueryAttribute>(attribute); 382Assert.IsType<ControllerActionFilter>(filter); 399Assert.IsType<MyFilterAttribute>(filter); 785Assert.IsType<CustomHttpMethodsAttribute>(Assert.Single(action.Attributes)); 884Assert.IsType<HttpHeadAttribute>(Assert.Single(action.Attributes)); 908Assert.IsType<RouteAttribute>(Assert.Single(action.Attributes)); 937Assert.IsType<AcceptVerbsAttribute>(Assert.Single(action.Attributes)); 1281Assert.IsType<ProducesResponseTypeMetadata>(selector.EndpointMetadata.Single());

49Assert.IsType<ChallengeResult>(authorizationContext.Result); 168Assert.IsType<ChallengeResult>(authorizationContext.Result); 272Assert.IsType<ForbidResult>(authorizationContext.Result); 298Assert.IsType<ForbidResult>(authorizationContext.Result); 306Assert.IsType<ForbidResult>(authorizationContext.Result); 326Assert.IsType<ForbidResult>(authorizationContext.Result); 364Assert.IsType<ForbidResult>(authorizationContext.Result); 399Assert.IsType<ForbidResult>(authorizationContext.Result); 416Assert.IsType<ForbidResult>(authorizationContext.Result); 485var actual = Assert.IsType<AuthorizeFilter>(result); 506var actual = Assert.IsType<AuthorizeFilter>(result);

31var errors = Assert.IsType<SerializableError>(badRequestObjectResult.Value);

24var route = Assert.IsType<Route>((Assert.Single(builder.Routes))); 33Assert.IsType<StringRouteConstraint>(kvp.Value); 59var route = Assert.IsType<Route>((Assert.Single(builder.Routes))); 68Assert.IsType<StringRouteConstraint>(kvp.Value); 100var route = Assert.IsType<Route>((Assert.Single(builder.Routes))); 109Assert.IsType<StringRouteConstraint>(kvp.Value); 114Assert.IsType<IntRouteConstraint>(kvp.Value); 147var route = Assert.IsType<Route>((Assert.Single(builder.Routes))); 156Assert.IsType<StringRouteConstraint>(kvp.Value); 161Assert.IsType<IntRouteConstraint>(kvp.Value); 200var route = Assert.IsType<Route>((Assert.Single(builder.Routes))); 209Assert.IsType<IntRouteConstraint>(kvp.Value); 238var route = Assert.IsType<Route>((Assert.Single(builder.Routes))); 247Assert.IsType<StringRouteConstraint>(kvp.Value);

31var errors = Assert.IsType<SerializableError>(conflictObjectResult.Value);

321Assert.IsType<UnsupportedMediaTypeResult>(resourceExecutingContext.Result);

51Assert.IsType<RedirectResult>(result); 68Assert.IsType<RedirectResult>(result); 85Assert.IsType<RedirectResult>(result); 102Assert.IsType<RedirectResult>(result); 149Assert.IsType<LocalRedirectResult>(result); 166Assert.IsType<LocalRedirectResult>(result); 183Assert.IsType<LocalRedirectResult>(result); 200Assert.IsType<LocalRedirectResult>(result); 291Assert.IsType<RedirectToActionResult>(resultTemporary); 307Assert.IsType<RedirectToActionResult>(resultTemporary); 323Assert.IsType<RedirectToActionResult>(resultPermanent); 339Assert.IsType<RedirectToActionResult>(resultPermanent); 358Assert.IsType<RedirectToActionResult>(resultTemporary); 378Assert.IsType<RedirectToActionResult>(resultTemporary); 398Assert.IsType<RedirectToActionResult>(resultPermanent); 418Assert.IsType<RedirectToActionResult>(resultPermanent); 438Assert.IsType<RedirectToActionResult>(resultTemporary); 462Assert.IsType<RedirectToActionResult>(resultTemporary); 486Assert.IsType<RedirectToActionResult>(resultPermanent); 510Assert.IsType<RedirectToActionResult>(resultPermanent); 531Assert.IsType<RedirectToActionResult>(resultTemporary); 551Assert.IsType<RedirectToActionResult>(resultTemporary); 574Assert.IsType<RedirectToActionResult>(result); 599Assert.IsType<RedirectToActionResult>(result); 621Assert.IsType<RedirectToActionResult>(resultPermanent); 641Assert.IsType<RedirectToActionResult>(resultPermanent); 664Assert.IsType<RedirectToActionResult>(result); 693Assert.IsType<RedirectToActionResult>(result); 715Assert.IsType<RedirectToRouteResult>(resultTemporary); 734Assert.IsType<RedirectToRouteResult>(resultTemporary); 755Assert.IsType<RedirectToRouteResult>(result); 778Assert.IsType<RedirectToRouteResult>(result); 799Assert.IsType<RedirectToRouteResult>(resultPermanent); 818Assert.IsType<RedirectToRouteResult>(resultPermanent); 839Assert.IsType<RedirectToRouteResult>(result); 862Assert.IsType<RedirectToRouteResult>(result); 881Assert.IsType<RedirectToRouteResult>(resultTemporary); 898Assert.IsType<RedirectToRouteResult>(resultTemporary); 915Assert.IsType<RedirectToRouteResult>(resultPermanent); 932Assert.IsType<RedirectToRouteResult>(resultPermanent); 952Assert.IsType<RedirectToRouteResult>(resultTemporary); 973Assert.IsType<RedirectToRouteResult>(resultTemporary); 994Assert.IsType<RedirectToRouteResult>(resultPermanent); 1012Assert.IsType<RedirectToPageResult>(result); 1028Assert.IsType<RedirectToPageResult>(result); 1045Assert.IsType<RedirectToPageResult>(result); 1069Assert.IsType<RedirectToPageResult>(result); 1089Assert.IsType<RedirectToPageResult>(result); 1113Assert.IsType<RedirectToPageResult>(result); 1130Assert.IsType<RedirectToPageResult>(result); 1148Assert.IsType<RedirectToPageResult>(result); 1173Assert.IsType<RedirectToPageResult>(result); 1194Assert.IsType<RedirectToPageResult>(result); 1219Assert.IsType<RedirectToPageResult>(result); 1239Assert.IsType<RedirectToPageResult>(resultPermanent); 1260Assert.IsType<RedirectToPageResult>(resultPermanent); 1281Assert.IsType<RedirectToRouteResult>(resultPermanent); 1299Assert.IsType<CreatedResult>(result); 1314Assert.IsType<CreatedResult>(result); 1330Assert.IsType<CreatedResult>(result); 1345Assert.IsType<CreatedResult>(result); 1361Assert.IsType<CreatedResult>(result); 1376Assert.IsType<CreatedAtActionResult>(result); 1395Assert.IsType<CreatedAtActionResult>(result); 1419Assert.IsType<CreatedAtActionResult>(result); 1437Assert.IsType<CreatedAtRouteResult>(result); 1456Assert.IsType<CreatedAtRouteResult>(result); 1477Assert.IsType<CreatedAtRouteResult>(result); 1493Assert.IsType<AcceptedResult>(result); 1508Assert.IsType<AcceptedResult>(result); 1524Assert.IsType<AcceptedResult>(result); 1540Assert.IsType<AcceptedResult>(result); 1556Assert.IsType<AcceptedResult>(result); 1571Assert.IsType<AcceptedAtActionResult>(result); 1589Assert.IsType<AcceptedAtActionResult>(result); 1613Assert.IsType<AcceptedAtActionResult>(result); 1635Assert.IsType<AcceptedAtRouteResult>(result); 1656Assert.IsType<AcceptedAtRouteResult>(result); 1972Assert.IsType<UnauthorizedResult>(result); 1986Assert.IsType<NotFoundResult>(result); 2000Assert.IsType<NotFoundObjectResult>(result); 2015Assert.IsType<OkResult>(result); 2029Assert.IsType<BadRequestResult>(result); 2044Assert.IsType<BadRequestObjectResult>(result); 2059Assert.IsType<BadRequestObjectResult>(result); 2061var errors = Assert.IsType<SerializableError>(result.Value); 2075Assert.IsType<UnprocessableEntityResult>(result); 2090Assert.IsType<UnprocessableEntityObjectResult>(result); 2105Assert.IsType<UnprocessableEntityObjectResult>(result); 2107var errors = Assert.IsType<SerializableError>(result.Value); 2122Assert.IsType<ConflictResult>(result); 2137Assert.IsType<ConflictObjectResult>(result); 2152Assert.IsType<ConflictObjectResult>(result); 2154var errors = Assert.IsType<SerializableError>(result.Value); 2189Assert.IsType<ContentResult>(actualContentResult); 2204Assert.IsType<ContentResult>(actualContentResult); 2220Assert.IsType<ContentResult>(actualContentResult); 2355var badRequestResult = Assert.IsType<BadRequestObjectResult>(actionResult); 2356var problemDetails = Assert.IsType<ValidationProblemDetails>(badRequestResult.Value); 2383var badRequestResult = Assert.IsType<BadRequestObjectResult>(actionResult); 2384var problemDetails = Assert.IsType<ValidationProblemDetails>(badRequestResult.Value); 2405var objectResult = Assert.IsType<ObjectResult>(actionResult); 2406var problemDetails = Assert.IsType<ValidationProblemDetails>(objectResult.Value); 2426var badRequestResult = Assert.IsType<BadRequestObjectResult>(actionResult); 2427var problemDetails = Assert.IsType<ValidationProblemDetails>(badRequestResult.Value); 2447var objectResult = Assert.IsType<BadRequestObjectResult>(actionResult); 2448var problemDetails = Assert.IsType<ValidationProblemDetails>(objectResult.Value); 2474var badRequestResult = Assert.IsType<ObjectResult>(actionResult); 2475var problemDetails = Assert.IsType<ProblemDetails>(badRequestResult.Value); 2500var badRequestResult = Assert.IsType<ObjectResult>(actionResult); 2501var problemDetails = Assert.IsType<ProblemDetails>(badRequestResult.Value); 2524var badRequestResult = Assert.IsType<ObjectResult>(actionResult); 2525var problemDetails = Assert.IsType<ProblemDetails>(badRequestResult.Value); 2545var badRequestResult = Assert.IsType<ObjectResult>(actionResult); 2546var problemDetails = Assert.IsType<ProblemDetails>(badRequestResult.Value); 2617Assert.Same(valueProvider, Assert.IsType<CompositeValueProvider>(context.ValueProvider)[0]); 2645Assert.Same(valueProvider, Assert.IsType<CompositeValueProvider>(context.ValueProvider)[0]); 2728Assert.Same(valueProvider, Assert.IsType<CompositeValueProvider>(context.ValueProvider)[0]); 2795Assert.IsType<CompositeValueProvider>(context.ValueProvider)[0]); 2859Assert.IsType<CompositeValueProvider>(context.ValueProvider)[0]); 2941Assert.Same(valueProvider, Assert.IsType<CompositeValueProvider>(context.ValueProvider)[0]); 2969Assert.Same(valueProvider, Assert.IsType<CompositeValueProvider>(context.ValueProvider)[0]);

65var actual = Assert.IsType<TestController>(result);

1192var accountId = Assert.IsType<int>(value); 1195var transferInfo = Assert.IsType<TransferInfo>(value);

138var actual = Assert.IsType<TestController>(controller);

143var controller = Assert.IsType<TypeDerivingFromControllerWithServices>(instance);

45var controller = Assert.IsType<MyController>(result); 73var controller = Assert.IsType<ControllerWithAttributes>(result); 100var controller = Assert.IsType<ControllerWithAttributes>(result); 127var controller = Assert.IsType<ControllerWithoutAttributes>(result); 154var controller = Assert.IsType<ControllerWithNonVisibleProperties>(result);

41var badRequest = Assert.IsType<BadRequestObjectResult>(result); 44var problemDetails = Assert.IsType<ValidationProblemDetails>(badRequest.Value); 63var badRequest = Assert.IsType<BadRequestObjectResult>(result); 66var problemDetails = Assert.IsType<ValidationProblemDetails>(badRequest.Value); 86var objectResult = Assert.IsType<ObjectResult>(result); 90var problemDetails = Assert.IsType<ValidationProblemDetails>(objectResult.Value); 108var badRequest = Assert.IsType<BadRequestObjectResult>(result); 109var problemDetails = Assert.IsType<ValidationProblemDetails>(badRequest.Value); 125var badRequest = Assert.IsType<BadRequestObjectResult>(result); 126var problemDetails = Assert.IsType<ValidationProblemDetails>(badRequest.Value);

185Assert.IsType<BarApplicationModelConvention>(convention); 378Assert.IsType<BarApplicationModelConvention>(convention);

32var assemblyPart = Assert.IsType<AssemblyPart>(part);

29var assemblyPart = Assert.IsType<AssemblyPart>(part);

20var typeFilter = Assert.IsType<TypeFilterAttribute>(added); 35var typeFilter = Assert.IsType<TypeFilterAttribute>(added); 91var serviceFilter = Assert.IsType<ServiceFilterAttribute>(added); 106var serviceFilter = Assert.IsType<ServiceFilterAttribute>(added);

162var cachedFactoryCreatedFilter = Assert.IsType<TestFilter>(filters[0]); // Created by factory 237var request1Filter1 = Assert.IsType<TestFilter>(filters[0]); // Created by factory 239var request1Filter3 = Assert.IsType<TestFilter>(filters[2]); // Created by custom filter provider 248var request2Filter1 = Assert.IsType<TestFilter>(filters[0]); 251var request2Filter3 = Assert.IsType<TestFilter>(filters[2]);

35var middlewareFilter = Assert.IsType<MiddlewareFilter>(filter);

32Assert.IsType<FormFeature>(formFeature);

52var objectResult = Assert.IsType<ObjectResult>(resultExecutingContext.Result); 96var objectResult = Assert.IsType<ObjectResult>(resultExecutingContext.Result); 128var objectResult = Assert.IsType<ObjectResult>(resultExecutingContext.Result); 151Assert.IsType<NotFoundResult>(actionResult); 232Assert.IsType<NotFoundResult>(actionResult); 257var result = Assert.IsType<NotFoundResult>(resourceExecutingContext.Result); 351var result = Assert.IsType<ObjectResult>(resultExecutingContext.Result); 386var result = Assert.IsType<ObjectResult>(resultExecutingContext.Result);

26Assert.IsType<AnotherTestOutputFormatter>(formatter); 45Assert.IsType<AnotherTestOutputFormatter>(formatter);

80var intValue = Assert.IsType<int>(result.Model); 101var stringValue = Assert.IsType<string>(result.Model); 122var stringValue = Assert.IsType<string>(result.Model); 228var dateValue = Assert.IsType<DateTime>(result.Model); 249var userModel = Assert.IsType<ComplexModel>(result.Model); 271var integers = Assert.IsType<int[]>(result.Model); 436Assert.IsType<TooManyModelErrorsException>(error.Exception); 555var userModel = Assert.IsType<ComplexModel>(result.Model); 577var userModel = Assert.IsType<ComplexModel>(result.Model); 603var userModel = Assert.IsType<ComplexModel>(result.Model);

289Assert.IsType<DefaultJsonTypeInfoResolver>(stjOutputFormatter.SerializerOptions.TypeInfoResolver);

38Assert.IsType<UnsupportedContentTypeException>(error.Exception);

35Assert.IsType<EmptyResult>(await valueTask); 61Assert.IsType<ContentResult>(await valueTask); 86Assert.IsType<ContentResult>(await valueTask); 110var result = Assert.IsType<ObjectResult>(await valueTask); 114Assert.IsType<TestModel>(result.Value); 139var result = Assert.IsType<ObjectResult>(await valueTask); 143Assert.IsType<TestModel>(result.Value); 168var result = Assert.IsType<ObjectResult>(await valueTask); 172Assert.IsType<TestModel>(result.Value); 198Assert.IsType<ContentResult>(await valueTask); 224Assert.IsType<EmptyResult>(await valueTask); 250Assert.IsType<EmptyResult>(await valueTask); 275Assert.IsType<StatusCodeResult>(await valueTask); 301Assert.IsType<ViewResult>(await valueTask); 325var result = Assert.IsType<ObjectResult>(await valueTask); 329Assert.IsType<TestModel>(result.Value); 354var result = Assert.IsType<ObjectResult>(await valueTask); 358Assert.IsType<TestModel>(result.Value); 384Assert.IsType<OkResult>(await valueTask); 408var result = Assert.IsType<ObjectResult>(await valueTask); 412Assert.IsType<TestModel>(result.Value);

39var httpResult = Assert.IsType<HttpActionResult>(result); 55Assert.IsType<EmptyResult>(result); 70var objectResult = Assert.IsType<ObjectResult>(result);

38var invoker = Assert.IsType<ControllerActionInvoker>(context.Result);

221var controllerContext = Assert.IsType<ControllerActionInvoker>(invoker).ControllerContext; 253var controllerContext = Assert.IsType<ControllerActionInvoker>(invoker).ControllerContext; 874Assert.IsType<EmptyResult>(result); 899var contentResult = Assert.IsType<ObjectResult>(result); 994var contentResult = Assert.IsType<ObjectResult>(result); 1044var contentResult = Assert.IsType<ObjectResult>(result); 1071var contentResult = Assert.IsType<ObjectResult>(result); 1097var contentResult = Assert.IsType<ObjectResult>(result); 1124var contentResult = Assert.IsType<ObjectResult>(result); 1153Assert.IsType<EmptyResult>(result); 1181Assert.IsType<ObjectResult>(result); 1182Assert.IsType<int>(((ObjectResult)result).Value); 1208Assert.IsType<EmptyResult>(result); 1233var testResult = Assert.IsType<TestActionResult>(result); 1259var testResult = Assert.IsType<TestActionResult>(result); 1290var contentResult = Assert.IsType<ObjectResult>(result); 1320var contentResult = Assert.IsType<TestActionResult>(result); 1469var testActionResult = Assert.IsType<TestActionResult>(result); 1494var testActionResult = Assert.IsType<TestActionResult>(result); 1518Assert.IsType<TestActionResult>(result);

223var expectedException = Assert.IsType<NotImplementedException>(serializerException.InnerException); 499return Assert.IsType<MemoryStream>(context.Response.Body).ToArray();

30var objectResult = Assert.IsType<ObjectResult>(result); 32var problemDetails = Assert.IsType<ProblemDetails>(objectResult.Value); 57var objectResult = Assert.IsType<ObjectResult>(result); 59var problemDetails = Assert.IsType<ProblemDetails>(objectResult.Value); 87var objectResult = Assert.IsType<ObjectResult>(result); 89var problemDetails = Assert.IsType<ProblemDetails>(objectResult.Value); 113var objectResult = Assert.IsType<ObjectResult>(result); 115var problemDetails = Assert.IsType<ProblemDetails>(objectResult.Value);

44Assert.IsType<DefaultJsonTypeInfoResolver>(options.TypeInfoResolver);

68var binder = Assert.IsType<ArrayModelBinder<int>>(result); 98Assert.IsType<ArrayModelBinder<int>>(result);

38var array = Assert.IsType<int[]>(bindingContext.Result.Model); 81Assert.Empty(Assert.IsType<string[]>(bindingContext.Result.Model)); 115Assert.Empty(Assert.IsType<string[]>(bindingContext.Result.Model));

36Assert.IsType<BinderTypeModelBinder>(result);

68Assert.IsType<BodyModelBinder>(result);

504Assert.IsType<IOException>(entry.Value.Errors[0].Exception);

37Assert.IsType<ByteArrayModelBinder>(result);

53var bytes = Assert.IsType<byte[]>(bindingContext.Result.Model);

37Assert.IsType<CancellationTokenModelBinder>(result);

63Assert.IsType<CollectionModelBinder<int>>(result); 83var binder = Assert.IsType<CollectionModelBinder<int>>(result);

36var strategy = Assert.IsType<ExplicitIndexCollectionValidationStrategy>(collectionResult.ValidationStrategy); 190var model = Assert.IsType<List<int>>(bindingContext.Result.Model); 267Assert.Empty(Assert.IsType<List<string>>(bindingContext.Result.Model)); 301Assert.Empty(Assert.IsType<List<string>>(bindingContext.Result.Model));

52Assert.IsType<ComplexObjectModelBinder>(result); 79Assert.IsType<ComplexObjectModelBinder>(result);

314Assert.IsType<Person>(bindingContext.Result.Model); 358Assert.IsType<PersonWithNoProperties>(bindingContext.Result.Model); 402Assert.IsType<PersonWithAllPropertiesExcluded>(bindingContext.Result.Model); 729Assert.IsType<NullReferenceException>(modelError.Exception); 878var person = Assert.IsType<Person>(bindingContext.Model); 902var person = Assert.IsType<Person>(bindingContext.Model); 926var person = Assert.IsType<Person>(bindingContext.Model);

52Assert.IsType<ComplexTypeModelBinder>(result); 79Assert.IsType<ComplexTypeModelBinder>(result);

329var returnedPerson = Assert.IsType<Person>(bindingContext.Result.Model); 374Assert.IsType<Person>(bindingContext.Result.Model); 418Assert.IsType<PersonWithNoProperties>(bindingContext.Result.Model); 462Assert.IsType<PersonWithAllPropertiesExcluded>(bindingContext.Result.Model); 524Assert.IsType<Person>(model); 634Assert.IsType<Person>(bindingContext.Model); 873Assert.IsType<NullReferenceException>(modelError.Exception); 1040var person = Assert.IsType<Person>(bindingContext.Model); 1064var person = Assert.IsType<Person>(bindingContext.Model); 1088var person = Assert.IsType<Person>(bindingContext.Model);

37Assert.IsType<DateTimeModelBinder>(result); 50Assert.IsType<DateTimeModelBinder>(result);

173var model = Assert.IsType<DateTime>(bindingContext.Result.Model); 196var model = Assert.IsType<DateTime>(bindingContext.Result.Model);

57var binder = Assert.IsType<DictionaryModelBinder<string, int>>(result);

367var strategy = Assert.IsType<ShortFormDictionaryValidationStrategy<int, ModelWithProperties>>(entry.Strategy); 452Assert.Empty(Assert.IsType<Dictionary<string, string>>(bindingContext.Result.Model)); 487Assert.Empty(Assert.IsType<Dictionary<string, string>>(bindingContext.Result.Model));

23Assert.IsType<EnumTypeModelBinder>(result); 39Assert.IsType<EnumTypeModelBinder>(result);

63var boundModel = Assert.IsType<IntEnum>(bindingContext.Result.Model); 87var boundModel = Assert.IsType<FlagsEnum>(bindingContext.Result.Model); 111var boundModel = Assert.IsType<FlagsEnum>(bindingContext.Result.Model); 173var boundModel = Assert.IsType<FlagsEnum>(bindingContext.Result.Model); 198var boundModel = Assert.IsType<FlagsEnum>(bindingContext.Result.Model);

61Assert.IsType<DecimalModelBinder>(result); 77Assert.IsType<DoubleModelBinder>(result); 93Assert.IsType<FloatModelBinder>(result);

55Assert.IsType<FormCollectionModelBinder>(result);

45Assert.IsType<FormFileModelBinder>(result);

65var headerModelBinder = Assert.IsType<HeaderModelBinder>(result); 88var headerModelBinder = Assert.IsType<HeaderModelBinder>(result); 114var headerModelBinder = Assert.IsType<HeaderModelBinder>(result); 158var headerModelBinder = Assert.IsType<HeaderModelBinder>(result);

53Assert.IsType<KeyValuePairModelBinder<string, int>>(result);

166var model = Assert.IsType<KeyValuePair<string, string>>(bindingContext.Result.Model);

53Assert.IsType<ServicesModelBinder>(result); 69var binder = Assert.IsType<ServicesModelBinder>(result);

43Assert.IsType<SimpleTypeModelBinder>(result);

397var boundModel = Assert.IsType<IntEnum>(bindingContext.Result.Model); 418var boundModel = Assert.IsType<IntEnum>(bindingContext.Result.Model); 459var boundModel = Assert.IsType<IntEnum>(bindingContext.Result.Model); 482var boundModel = Assert.IsType<FlagsEnum>(bindingContext.Result.Model);

36Assert.IsType<TryParseModelBinder>(result);

323var boundModel = Assert.IsType<IntEnum>(bindingContext.Result.Model); 344var boundModel = Assert.IsType<IntEnum>(bindingContext.Result.Model); 381var boundModel = Assert.IsType<IntEnum>(bindingContext.Result.Model); 431var boundModel = Assert.IsType<TestTryParseClass>(bindingContext.Result.Model); 480var boundModel = Assert.IsType<FlagsEnum>(bindingContext.Result.Model);

31var newProvider = Assert.IsType<CompositeValueProvider>(result); 130var valueProvider = Assert.IsType<CompositeValueProvider>(result); 172var newProvider = Assert.IsType<CompositeValueProvider>(result); 224var newProvider = Assert.IsType<CompositeValueProvider>(result);

81Assert.IsType<CompositeValueProvider>(context.ValueProvider), 109Assert.IsType<CompositeValueProvider>(context.ValueProvider), 138Assert.IsType<CompositeValueProvider>(context.ValueProvider),

57v => Assert.IsType<FormFileValueProvider>(v));

44var valueProvider = Assert.IsType<FormValueProvider>(Assert.Single(context.ValueProviders));

68var valueProvider = Assert.IsType<JQueryFormValueProvider>(Assert.Single(context.ValueProviders)); 129var jqueryFormValueProvider = Assert.IsType<JQueryFormValueProvider>(valueProvider);

109var jqueryQueryStringValueProvider = Assert.IsType<JQueryQueryStringValueProvider>(valueProvider);

21var defaultMetadata = Assert.IsType<DefaultModelMetadata>(metadata); 23var attribute = Assert.IsType<ModelAttribute>(Assert.Single(defaultMetadata.Attributes.Attributes)); 34var metadata1 = Assert.IsType<DefaultModelMetadata>(provider.GetMetadataForType(typeof(ModelType))); 35var metadata2 = Assert.IsType<DefaultModelMetadata>(provider.GetMetadataForType(typeof(ModelType))); 144var metadata1 = Assert.IsType<DefaultModelMetadata>(provider.GetMetadataForType(typeof(ModelType))); 145var metadata2 = Assert.IsType<DefaultModelMetadata>(provider.GetMetadataForType(typeof(ModelType))); 161var defaultMetadata = Assert.IsType<DefaultModelMetadata>(metadata); 164Assert.Equal("OnProperty", Assert.IsType<ModelAttribute>(attributes[0]).Value); 165Assert.Equal("OnPropertyType", Assert.IsType<ModelAttribute>(attributes[1]).Value); 212var defaultMetadata = Assert.IsType<DefaultModelMetadata>(metadata); 215Assert.IsType<SerializableAttribute>(Assert.Single(defaultMetadata.Attributes.Attributes)); 231var defaultMetadata = Assert.IsType<DefaultModelMetadata>(metadata); 237var modelAttribute = Assert.IsType<ModelAttribute>(attribute); 242var modelAttribute = Assert.IsType<ModelAttribute>(attribute); 280var defaultModelMetadata = Assert.IsType<DefaultModelMetadata>(metadata); 284a => Assert.Equal("OnParameter", Assert.IsType<ModelAttribute>(a).Value), 285a => Assert.Equal("OnDerivedType", Assert.IsType<ModelAttribute>(a).Value), 286a => Assert.Equal("OnType", Assert.IsType<ModelAttribute>(a).Value)); 294var defaultPropertyMetadata = Assert.IsType<DefaultModelMetadata>(p); 297a => Assert.Equal("OnDerivedProperty", Assert.IsType<ModelAttribute>(a).Value)); 303var defaultPropertyMetadata = Assert.IsType<DefaultModelMetadata>(p); 306a => Assert.Equal("OnProperty", Assert.IsType<ModelAttribute>(a).Value), 307a => Assert.Equal("OnPropertyType", Assert.IsType<ModelAttribute>(a).Value)); 364var defaultModelMetadata = Assert.IsType<DefaultModelMetadata>(metadata); 368a => Assert.Equal("OnProperty", Assert.IsType<ModelAttribute>(a).Value), 369a => Assert.Equal("OnDerivedType", Assert.IsType<ModelAttribute>(a).Value), 370a => Assert.Equal("OnType", Assert.IsType<ModelAttribute>(a).Value)); 378var defaultPropertyMetadata = Assert.IsType<DefaultModelMetadata>(p); 381a => Assert.Equal("OnDerivedProperty", Assert.IsType<ModelAttribute>(a).Value)); 387var defaultPropertyMetadata = Assert.IsType<DefaultModelMetadata>(p); 390a => Assert.Equal("OnProperty", Assert.IsType<ModelAttribute>(a).Value), 391a => Assert.Equal("OnPropertyType", Assert.IsType<ModelAttribute>(a).Value));

24Assert.IsType<BarMetadataDetailsProvider>(provider); 43Assert.IsType<BarMetadataDetailsProvider>(provider);

166Assert.IsType<RequiredAttribute>(attributes.Attributes[0]); 167Assert.IsType<RangeAttribute>(attributes.Attributes[1]); 168Assert.IsType<ClassValidator>(attributes.Attributes[2]); 171Assert.IsType<RequiredAttribute>(attributes.PropertyAttributes[0]); 172Assert.IsType<RangeAttribute>(attributes.PropertyAttributes[1]); 175Assert.IsType<ClassValidator>(attribute); 189Assert.IsType<SerializableAttribute>(Assert.Single(attributes.Attributes)); 208attribute => Assert.IsType<RequiredAttribute>(attribute), 209attribute => Assert.IsType<RangeAttribute>(attribute)); 212attribute => Assert.IsType<RequiredAttribute>(attribute), 213attribute => Assert.IsType<RangeAttribute>(attribute)); 218attribute => Assert.IsType<SerializableAttribute>(attribute)); 234attribute => Assert.IsType<BindRequiredAttribute>(attribute), 235attribute => Assert.IsType<ClassValidator>(attribute)); 236Assert.IsType<BindRequiredAttribute>(Assert.Single(attributes.ParameterAttributes)); 238Assert.IsType<ClassValidator>(Assert.Single(attributes.TypeAttributes)); 255attribute => Assert.IsType<BindRequiredAttribute>(attribute), 256attribute => Assert.IsType<ModelBinderAttribute>(attribute), 257attribute => Assert.IsType<ClassValidator>(attribute)); 258Assert.IsType<BindRequiredAttribute>(Assert.Single(attributes.ParameterAttributes)); 262attribute => Assert.IsType<ModelBinderAttribute>(attribute), 263attribute => Assert.IsType<ClassValidator>(attribute)); 279attribute => Assert.IsType<BindRequiredAttribute>(attribute), 280attribute => Assert.IsType<ModelBinderAttribute>(attribute), 281attribute => Assert.IsType<ClassValidator>(attribute)); 282Assert.IsType<BindRequiredAttribute>(Assert.Single(attributes.PropertyAttributes)); 286attribute => Assert.IsType<ModelBinderAttribute>(attribute), 287attribute => Assert.IsType<ClassValidator>(attribute));

135Assert.IsType<NoOpBinder>(result); 194Assert.IsType<PlaceholderBinder>(binder); 465Assert.IsType<NoOpBinder>(binder); 632var placeholder = Assert.IsType<PlaceholderBinder>(innerInner); 633Assert.IsType<NoOpBinder>(placeholder.Inner);

24Assert.IsType<BarModelBinderProvider>(provider); 43Assert.IsType<BarModelBinderProvider>(provider);

1136var result = Assert.IsType<IntEnum[]>(outValue); 1154var result = Assert.IsType<FlagsEnum[]>(outValue); 1373Assert.IsType<List<int>>(result); 1402var list = Assert.IsType<List<int>>(result); 1455var list = Assert.IsType<List<int>>(result); 1471var list = Assert.IsType<List<int>>(result);

45var valueProvider = Assert.IsType<QueryStringValueProvider>(Assert.Single(factoryContext.ValueProviders));

43var status = Assert.IsType<UnsupportedMediaTypeResult>(context.Result);

29Assert.IsType<ValidatableObjectAdapter>(validatorItem.Validator); 48var validator = Assert.IsType<CustomModelValidatorAttribute>(Assert.Single(validatorItems).Validator); 70var validator = Assert.IsType<CustomModelValidatorAttribute>(Assert.Single(validatorItems).Validator); 93Assert.Single(validatorItems, v => Assert.IsType<CustomModelValidatorAttribute>(v.Validator).Tag == "Class"); 94Assert.Single(validatorItems, v => Assert.IsType<CustomModelValidatorAttribute>(v.Validator).Tag == "Property"); 115var adapter = Assert.IsType<DataAnnotationsModelValidator>(Assert.Single(validatorItems).Validator); 116Assert.IsType<RangeAttribute>(adapter.Attribute);

745Assert.IsType<TooManyModelErrorsException>(error.Exception); 1250Assert.IsType<TooManyModelErrorsException>(error.Exception);

24Assert.IsType<BarModelValidatorProvider>(provider); 43Assert.IsType<BarModelValidatorProvider>(provider);

23var attribute1 = Assert.IsType<DataAnnotationsModelValidator>(validators1[0]).Attribute; 24var attribute2 = Assert.IsType<DataAnnotationsModelValidator>(validators1[1]).Attribute; 50var validator1 = Assert.IsType<DataAnnotationsModelValidator>(validators1[0]); 51var validator2 = Assert.IsType<DataAnnotationsModelValidator>(validators1[1]);

24Assert.IsType<BarValueProviderFactory>(factory); 43Assert.IsType<BarValueProviderFactory>(factory);

58var objectResult = Assert.IsType<ObjectResult>(resultExecutingContext.Result); 83var objectResult = Assert.IsType<ObjectResult>(resultExecutingContext.Result);

112Assert.Collection(Assert.IsType<RouteValueDictionary>(context.Values), 166Assert.Collection(Assert.IsType<RouteValueDictionary>(context.Values), 228Assert.Collection(Assert.IsType<RouteValueDictionary>(context.Values), 279Assert.Collection(Assert.IsType<RouteValueDictionary>(context.Values),

98var result = Assert.IsType<RedirectResult>(authContext.Result); 124var result = Assert.IsType<StatusCodeResult>(authContext.Result); 143var result = Assert.IsType<StatusCodeResult>(authContext.Result); 187var result = Assert.IsType<RedirectResult>(authContext.Result); 215var result = Assert.IsType<RedirectResult>(authContext.Result);

37var responseCacheFilter = Assert.IsType<ResponseCacheFilter>(createdFilter); 166var responseCacheFilter = Assert.IsType<ResponseCacheFilter>(createdFilter);

35var endpoint = Assert.IsType<RouteEndpoint>(Assert.Single(endpoints)); 61(e) => Assert.Equal("/test", Assert.IsType<RouteEndpoint>(e).RoutePattern.RawText)); 98var routePattern = Assert.IsType<RouteEndpoint>(e).RoutePattern; 120var routePattern = Assert.IsType<RouteEndpoint>(e).RoutePattern;

284var endpoint = Assert.IsType<RouteEndpoint>(Assert.Single(endpoints)); 346var matcherEndpoint = Assert.IsType<RouteEndpoint>(ep); 354var matcherEndpoint = Assert.IsType<RouteEndpoint>(ep); 373Assert.IsType<Endpoint>(Assert.Single(endpoints)); 389return Assert.IsType<RouteEndpoint>(Assert.Single(endpoints)); 412var endpoint = Assert.IsType<RouteEndpoint>(Assert.Single(endpoints));

537Assert.IsType<RouteCreationException>(exception.InnerException);

145Assert.IsType<EndpointRoutingUrlHelper>(urlHelper);

50var knownRouteValueConstraint = Assert.IsType<KnownRouteValueConstraint>(constraint);

41Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 89Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 121Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 153Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 185Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 235Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 284Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 327Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 375Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 418Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 453Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 480Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 524Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 587Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values).OrderBy(v => v.Key), 743Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 791Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values), 839Assert.Collection(Assert.IsType<RouteValueDictionary>(actual.Values),

23var arr = Assert.IsType<string[]>(serializableError["key1"]); 40var arr = Assert.IsType<string[]>(serializableError["KEY1"]); 55var arr = Assert.IsType<string[]>(serializableError["key1"]);

43Assert.IsType<TestFilter>(filter);

28var testFilter = Assert.IsType<TestFilter>(filter); 53var testFilter = Assert.IsType<TestFilter>(filter); 78var testFilter = Assert.IsType<TestFilter>(filter);

31var errors = Assert.IsType<SerializableError>(result.Value);

77Assert.IsType<NoOpResult>(context.Result);

38Assert.IsType<CorsHttpMethodActionConstraint>(constraint); 57Assert.IsType<CorsHttpMethodActionConstraint>(constraint); 75Assert.IsType<CorsHttpMethodActionConstraint>(constraint); 94Assert.IsType<CorsHttpMethodActionConstraint>(constraint); 113Assert.IsType<CorsHttpMethodActionConstraint>(constraint); 131Assert.IsType<CorsHttpMethodActionConstraint>(constraint); 152Assert.IsType<CorsHttpMethodActionConstraint>(constraint); 171Assert.IsType<CorsHttpMethodActionConstraint>(constraint); 190Assert.IsType<CorsHttpMethodActionConstraint>(constraint);

72var statusCodeResult = Assert.IsType<StatusCodeResult>(authorizationFilterContext.Result);

35Assert.IsType<RequiredAttributeAdapter>(validatorItem.Validator); 111var adapter = Assert.IsType<RequiredAttributeAdapter>(validatorItem.Validator);

34Assert.IsType<ValidatableObjectAdapter>(validatorItem.Validator); 76Assert.IsType<DataAnnotationsModelValidator>(validatorItem.Validator);

33Assert.IsType<NumericClientModelValidator>(validatorItem.Validator);

30Assert.IsType<ValidatableObjectAdapter>(validatorItem.Validator); 50var customModelValidator = Assert.IsType<CustomModelValidatorAttribute>(validatorItem.Validator); 72var validatorItem = Assert.IsType<CustomModelValidatorAttribute>(Assert.Single(validatorItems).Validator); 95Assert.Single(validatorItems, v => Assert.IsType<CustomModelValidatorAttribute>(v.Validator).Tag == "Class"); 96Assert.Single(validatorItems, v => Assert.IsType<CustomModelValidatorAttribute>(v.Validator).Tag == "Property"); 141Assert.IsType<CustomValidationAttribute>(Assert.Single(validatorItems).Validator);

87var dataTypeAdapter = Assert.IsType<DataTypeAttributeAdapter>(adapter);

50Assert.IsType<SerializableErrorWrapper>(errorWrapper);

54Assert.IsType<XmlDataContractSerializerInputFormatter>(Assert.Single(options.InputFormatters)); 68Assert.IsType<XmlDataContractSerializerOutputFormatter>(Assert.Single(options.OutputFormatters));

54Assert.IsType<XmlSerializerInputFormatter>(Assert.Single(options.InputFormatters)); 68Assert.IsType<XmlSerializerOutputFormatter>(Assert.Single(options.OutputFormatters));

35var wrapper = Assert.IsType<ProblemDetailsWrapper>(result); 52var wrapper = Assert.IsType<ValidationProblemDetailsWrapper>(result);

32var problemDetails = Assert.IsType<ProblemDetailsWrapper>(value).ProblemDetails;

36var problemDetails = Assert.IsType<ValidationProblemDetailsWrapper>(value).ProblemDetails; 92var problemDetails = Assert.IsType<ValidationProblemDetailsWrapper>(value).ProblemDetails; 130var problemDetails = Assert.IsType<ValidationProblemDetailsWrapper>(value).ProblemDetails;

159var model = Assert.IsType<TestLevelOne>(result.Model); 190var model = Assert.IsType<TestLevelOne>(result.Model); 223var model = Assert.IsType<TestLevelOne>(result.Model); 258var model = Assert.IsType<TestLevelOne>(result.Model); 290var model = Assert.IsType<TestLevelOne>(result.Model); 317var model = Assert.IsType<TestLevelOne>(result.Model); 351var model = Assert.IsType<TestLevelOne>(result.Model); 383var model = Assert.IsType<TestLevelTwo>(result.Model); 409var model = Assert.IsType<DummyClass>(result.Model); 554var model = Assert.IsType<TestLevelTwo>(result.Model); 592var model = Assert.IsType<TestLevelOne>(result.Model); 652var model = Assert.IsType<DummyClass>(result.Model); 711var model = Assert.IsType<SomeDummyClass>(result.Model);

64var model = Assert.IsType<TestLevelOne>(result.Model); 101var model = Assert.IsType<TestLevelOne>(result.Model); 137var model = Assert.IsType<TestLevelOne>(result.Model); 173var model = Assert.IsType<TestLevelOne>(result.Model); 217var model = Assert.IsType<TestLevelOne>(result.Model); 353var model = Assert.IsType<TestLevelOne>(result.Model); 387var model = Assert.IsType<TestLevelTwo>(result.Model); 416var model = Assert.IsType<DummyClass>(result.Model); 574var model = Assert.IsType<TestLevelTwo>(result.Model); 613var model = Assert.IsType<TestLevelOne>(result.Model); 645var model = Assert.IsType<TestLevelOne>(result.Model);

113var value = Assert.IsType<JArray>(p.Value); 145var value = Assert.IsType<JArray>(p.Value); 177var value = Assert.IsType<JArray>(p.Value);

832var value = Assert.IsType<JArray>(p.Value);

60var boundModel = Assert.IsType<Person3>(modelBindingResult.Model); 104var boundModel = Assert.IsType<Person6>(modelBindingResult.Model); 153var boundModel = Assert.IsType<Person4>(modelBindingResult.Model); 199var boundModel = Assert.IsType<Person5>(modelBindingResult.Model); 240var boundModel = Assert.IsType<Person3>(modelBindingResult.Model); 283var boundModel = Assert.IsType<Person6>(modelBindingResult.Model); 331var boundModel = Assert.IsType<Person4>(modelBindingResult.Model); 376var boundModel = Assert.IsType<Person5>(modelBindingResult.Model); 442var model = Assert.IsType<ActionParameter_DefaultValueConstructor>(result.Model); 624var boundModel = Assert.IsType<ClassWithNoDefaultConstructor>(modelBindingResult.Model); 694var model = Assert.IsType<ModelWithIValidatableObject>(modelBindingResult.Model); 742Assert.Equal(input.Value, Assert.IsType<int>(modelBindingResult.Model));

37var model = Assert.IsType<int[]>(modelBindingResult.Model); 81var model = Assert.IsType<int[]>(modelBindingResult.Model); 121var model = Assert.IsType<int[]>(modelBindingResult.Model); 160Assert.Empty(Assert.IsType<int[]>(modelBindingResult.Model)); 196var model = Assert.IsType<Person[]>(modelBindingResult.Model); 241var model = Assert.IsType<Person[]>(modelBindingResult.Model); 282var model = Assert.IsType<Person[]>(modelBindingResult.Model); 322Assert.Empty(Assert.IsType<Person[]>(modelBindingResult.Model)); 362var model = Assert.IsType<PersonWithReadOnlyAndInitializedProperty>(modelBindingResult.Model);

176var address = Assert.IsType<Address>(modelBindingResult.Model); 227var person = Assert.IsType<Person3>(modelBindingResult.Model); 265var boundPerson = Assert.IsType<Person>(modelBindingResult.Model); 304var boundPerson = Assert.IsType<Person>(modelBindingResult.Model);

53var boundPerson = Assert.IsType<CancellationTokenBundle>(modelBindingResult.Model); 106var boundPerson = Assert.IsType<FormFileBundle>(modelBindingResult.Model);

47Assert.Equal("Joey", Assert.IsType<Person>(result.Model).Name); 74Assert.Equal("Joey", Assert.IsType<Person>(result.Model).Name); 176Assert.Equal(input.Value, Assert.IsType<int>(result.Model));

47var boundPerson = Assert.IsType<ProductViewModel>(modelBindingResult.Model); 128var boundPerson = Assert.IsType<ProductViewModel>(modelBindingResult.Model); 174var boundPerson = Assert.IsType<ProductViewModel>(modelBindingResult.Model); 213var boundPerson = Assert.IsType<ProductViewModel>(modelBindingResult.Model); 253var boundPerson = Assert.IsType<SoftwareViewModel>(modelBindingResult.Model); 292var boundPerson = Assert.IsType<SoftwareViewModel>(modelBindingResult.Model); 334var boundPerson = Assert.IsType<SoftwareViewModel>(modelBindingResult.Model); 386var boundPerson = Assert.IsType<Person>(modelBindingResult.Model); 474var boundPerson = Assert.IsType<Person4>(modelBindingResult.Model); 538var boundPerson = Assert.IsType<Person5>(modelBindingResult.Model); 580var boundPerson = Assert.IsType<Person5>(modelBindingResult.Model); 594Assert.IsType<JsonReaderException>(error.Exception); 679Assert.IsType<Person5>(modelBindingResult.Model); 730var boundPerson = Assert.IsType<Person2>(modelBindingResult.Model); 786Assert.IsType<Person3>(modelBindingResult.Model); 840var person = Assert.IsType<Person6>(modelBindingResult.Model); 886var address = Assert.IsType<Address6>(modelBindingResult.Model);

53var boundPerson = Assert.IsType<Person>(modelBindingResult.Model); 135var model = Assert.IsType<byte[]>(modelBindingResult.Model);

44var boundPerson = Assert.IsType<Person>(modelBindingResult.Model); 80var boundPerson = Assert.IsType<Person>(modelBindingResult.Model); 119var token = Assert.IsType<CancellationToken>(modelBindingResult.Model);

43var model = Assert.IsType<List<int>>(modelBindingResult.Model); 91var model = Assert.IsType<List<int>>(modelBindingResult.Model); 127var model = Assert.IsType<List<int>>(modelBindingResult.Model); 158Assert.Empty(Assert.IsType<List<int>>(modelBindingResult.Model)); 199var model = Assert.IsType<List<Person>>(modelBindingResult.Model); 239var model = Assert.IsType<List<Person>>(modelBindingResult.Model); 271Assert.Empty(Assert.IsType<List<Person>>(modelBindingResult.Model)); 310var model = Assert.IsType<List<Person2>>(modelBindingResult.Model); 369var model = Assert.IsType<List<Person2>>(modelBindingResult.Model); 420var model = Assert.IsType<List<Person2>>(modelBindingResult.Model); 472var model = Assert.IsType<List<int>>(modelBindingResult.Model); 515var model = Assert.IsType<List<Person2>>(modelBindingResult.Model); 565Assert.Empty(Assert.IsType<List<Person2>>(modelBindingResult.Model)); 615Assert.IsType<Person4>(modelBindingResult.Model); 672Assert.IsType<Person5>(modelBindingResult.Model); 712var model = Assert.IsType<List<Address5>>(modelBindingResult.Model); 1032var locations = Assert.IsType<List<SuccessfulModel>>(result.Model); 1155var model = Assert.IsType<Collection<string>>(result.Model); 1204var model = Assert.IsType<Collection<string>>(result.Model);

66var model = Assert.IsType<Order1>(modelBindingResult.Model); 116var model = Assert.IsType<Order1>(modelBindingResult.Model); 168var model = Assert.IsType<Order1>(modelBindingResult.Model); 222var model = Assert.IsType<Order1>(modelBindingResult.Model); 271var model = Assert.IsType<Order1>(modelBindingResult.Model); 320var model = Assert.IsType<Order1>(modelBindingResult.Model); 368var model = Assert.IsType<Order3>(modelBindingResult.Model); 420var model = Assert.IsType<Order3>(modelBindingResult.Model); 472var model = Assert.IsType<Order3>(modelBindingResult.Model); 525var model = Assert.IsType<Order4>(modelBindingResult.Model); 578var model = Assert.IsType<Order4>(modelBindingResult.Model); 632var model = Assert.IsType<Order4>(modelBindingResult.Model); 682var model = Assert.IsType<Order4>(modelBindingResult.Model); 739var model = Assert.IsType<Order4>(modelBindingResult.Model); 793var model = Assert.IsType<Order5>(modelBindingResult.Model); 848var model = Assert.IsType<Order5>(modelBindingResult.Model); 903var model = Assert.IsType<Order5>(modelBindingResult.Model); 950var model = Assert.IsType<Order5>(modelBindingResult.Model); 996var model = Assert.IsType<Order6>(modelBindingResult.Model); 1051var model = Assert.IsType<Order6>(modelBindingResult.Model); 1106var model = Assert.IsType<Order6>(modelBindingResult.Model); 1153var model = Assert.IsType<Order6>(modelBindingResult.Model); 1199var model = Assert.IsType<Order7>(modelBindingResult.Model); 1254var model = Assert.IsType<Order7>(modelBindingResult.Model); 1309var model = Assert.IsType<Order7>(modelBindingResult.Model); 1356var model = Assert.IsType<Order7>(modelBindingResult.Model); 1415var model = Assert.IsType<Car1>(modelBindingResult.Model); 1522var model = Assert.IsType<Car2>(modelBindingResult.Model); 1629var model = Assert.IsType<Car3>(modelBindingResult.Model); 1733var model = Assert.IsType<Order8>(modelBindingResult.Model); 1788var model = Assert.IsType<Order8>(modelBindingResult.Model); 1852var model = Assert.IsType<Car4>(modelBindingResult.Model); 1938var model = Assert.IsType<Order9>(modelBindingResult.Model); 1984var model = Assert.IsType<Order10>(modelBindingResult.Model); 2040var model = Assert.IsType<Order10>(modelBindingResult.Model); 2092var model = Assert.IsType<Order11>(modelBindingResult.Model); 2146var model = Assert.IsType<Order11>(modelBindingResult.Model); 2204var model = Assert.IsType<Order11>(modelBindingResult.Model); 2260var model = Assert.IsType<Order12>(modelBindingResult.Model); 2312var model = Assert.IsType<Order12>(modelBindingResult.Model); 2360var model = Assert.IsType<Order12>(modelBindingResult.Model); 2408var model = Assert.IsType<Order13>(modelBindingResult.Model); 2460var model = Assert.IsType<Order13>(modelBindingResult.Model); 2507var model = Assert.IsType<Order13>(modelBindingResult.Model); 2557var model = Assert.IsType<Order14>(modelBindingResult.Model); 2611var model = Assert.IsType<Order14>(modelBindingResult.Model); 2669var person = Assert.IsType<Person12>(modelBindingResult.Model); 2718var address = Assert.IsType<Address12>(modelBindingResult.Model); 2774var person = Assert.IsType<Person13>(modelBindingResult.Model); 2828var address = Assert.IsType<Address13>(modelBindingResult.Model); 2887var model = Assert.IsType<Product>(modelBindingResult.Model); 2934var model = Assert.IsType<Photo>(modelBindingResult.Model); 3002var model = Assert.IsType<List<Person5>>(modelBindingResult.Model); 3074var model = Assert.IsType<TestModel>(modelBindingResult.Model); 3138var model = Assert.IsType<Person6>(modelBindingResult.Model); 3190var model = Assert.IsType<Person6>(modelBindingResult.Model); 3265var model = Assert.IsType<Person7>(modelBindingResult.Model); 3360var model = Assert.IsType<ThreeDeepModel>(result.Model); 3472var model = Assert.IsType<RecordTypeWithSettableProperty1>(modelBindingResult.Model); 3514var model = Assert.IsType<RecordTypeWithSettableProperty1>(modelBindingResult.Model); 3557var model = Assert.IsType<RecordTypeWithSettableProperty1>(modelBindingResult.Model); 3600var model = Assert.IsType<RecordTypeWithSettableProperty1>(modelBindingResult.Model); 3651var model = Assert.IsType<RecordTypeWithFilteredProperty1>(modelBindingResult.Model); 3697var model = Assert.IsType<RecordTypeWithFilteredProperty2>(modelBindingResult.Model); 3750var model = Assert.IsType<RecordTypesWithDifferentMetadataOnParameterAndProperty>(modelBindingResult.Model); 3792var model = Assert.IsType<RecordTypesWithDifferentMetadataOnParameterAndProperty>(modelBindingResult.Model); 3838var model = Assert.IsType<RecordTypeWithCollectionParameter>(modelBindingResult.Model); 3880var model = Assert.IsType<RecordTypeWithCollectionParameter>(modelBindingResult.Model); 3925var model = Assert.IsType<RecordTypesWithReadOnlyCollectionParameter>(modelBindingResult.Model); 3971var model = Assert.IsType<RecordTypesWithDefaultParameterValue>(modelBindingResult.Model); 4014var model = Assert.IsType<RecordTypesWithDefaultParameterValue>(modelBindingResult.Model); 4055var model = Assert.IsType<RecordTypesWithDefaultParameterValue>(modelBindingResult.Model); 4098var model = Assert.IsType<RecordTypesWithDefaultParameterValue>(modelBindingResult.Model); 4143var model = Assert.IsType<RecordTypeWithBindRequiredParameters>(modelBindingResult.Model); 4187var model = Assert.IsType<RecordTypeWithBindRequiredParameters>(modelBindingResult.Model);

103var model = Assert.IsType<Order1>(modelBindingResult.Model); 153var model = Assert.IsType<Order1>(modelBindingResult.Model); 205var model = Assert.IsType<Order1>(modelBindingResult.Model); 254var model = Assert.IsType<Order1>(modelBindingResult.Model); 303var model = Assert.IsType<Order1>(modelBindingResult.Model); 361var model = Assert.IsType<Order3>(modelBindingResult.Model); 413var model = Assert.IsType<Order3>(modelBindingResult.Model); 465var model = Assert.IsType<Order3>(modelBindingResult.Model); 528var model = Assert.IsType<Order4>(modelBindingResult.Model); 581var model = Assert.IsType<Order4>(modelBindingResult.Model); 635var model = Assert.IsType<Order4>(modelBindingResult.Model); 685var model = Assert.IsType<Order4>(modelBindingResult.Model); 742var model = Assert.IsType<Order4>(modelBindingResult.Model); 801var model = Assert.IsType<Order5>(modelBindingResult.Model); 856var model = Assert.IsType<Order5>(modelBindingResult.Model); 911var model = Assert.IsType<Order5>(modelBindingResult.Model); 958var model = Assert.IsType<Order5>(modelBindingResult.Model); 1009var model = Assert.IsType<Order6>(modelBindingResult.Model); 1064var model = Assert.IsType<Order6>(modelBindingResult.Model); 1119var model = Assert.IsType<Order6>(modelBindingResult.Model); 1166var model = Assert.IsType<Order6>(modelBindingResult.Model); 1217var model = Assert.IsType<Order7>(modelBindingResult.Model); 1272var model = Assert.IsType<Order7>(modelBindingResult.Model); 1327var model = Assert.IsType<Order7>(modelBindingResult.Model); 1374var model = Assert.IsType<Order7>(modelBindingResult.Model); 1451var model = Assert.IsType<Car1>(modelBindingResult.Model); 1558var model = Assert.IsType<Car2>(modelBindingResult.Model); 1665var model = Assert.IsType<Car3>(modelBindingResult.Model); 1774var model = Assert.IsType<Order8>(modelBindingResult.Model); 1829var model = Assert.IsType<Order8>(modelBindingResult.Model); 1884var model = Assert.IsType<Order8>(modelBindingResult.Model); 1933var model = Assert.IsType<Order8>(modelBindingResult.Model); 1992var model = Assert.IsType<Car4>(modelBindingResult.Model); 2085var model = Assert.IsType<Order9>(modelBindingResult.Model); 2138var model = Assert.IsType<Order10>(modelBindingResult.Model); 2193var model = Assert.IsType<Order10>(modelBindingResult.Model); 2254var model = Assert.IsType<Order11>(modelBindingResult.Model); 2308var model = Assert.IsType<Order11>(modelBindingResult.Model); 2366var model = Assert.IsType<Order11>(modelBindingResult.Model); 2426var model = Assert.IsType<Order12>(modelBindingResult.Model); 2478var model = Assert.IsType<Order12>(modelBindingResult.Model); 2526var model = Assert.IsType<Order12>(modelBindingResult.Model); 2578var model = Assert.IsType<Order13>(modelBindingResult.Model); 2630var model = Assert.IsType<Order13>(modelBindingResult.Model); 2677var model = Assert.IsType<Order13>(modelBindingResult.Model); 2730var model = Assert.IsType<Order14>(modelBindingResult.Model); 2784var model = Assert.IsType<Order14>(modelBindingResult.Model); 2848var person = Assert.IsType<Person12>(modelBindingResult.Model); 2897var address = Assert.IsType<Address12>(modelBindingResult.Model); 2965var person = Assert.IsType<Person13>(modelBindingResult.Model); 3019var address = Assert.IsType<Address13>(modelBindingResult.Model); 3080var model = Assert.IsType<Product>(modelBindingResult.Model); 3138var model = Assert.IsType<Photo>(modelBindingResult.Model); 3210var model = Assert.IsType<List<Person5>>(modelBindingResult.Model); 3289var model = Assert.IsType<TestModel>(modelBindingResult.Model); 3360var model = Assert.IsType<Person6>(modelBindingResult.Model); 3412var model = Assert.IsType<Person6>(modelBindingResult.Model); 3494var model = Assert.IsType<Person7>(modelBindingResult.Model); 3605var model = Assert.IsType<ThreeDeepModel>(result.Model);

41var model = Assert.IsType<Dictionary<string, int>>(modelBindingResult.Model); 81var model = Assert.IsType<Dictionary<string, int>>(modelBindingResult.Model); 119var model = Assert.IsType<Dictionary<string, int>>(modelBindingResult.Model); 172var model = Assert.IsType<Dictionary<string, int>>(modelBindingResult.Model); 209var model = Assert.IsType<Dictionary<string, int>>(modelBindingResult.Model); 353var model = Assert.IsType<Dictionary<string, int>>(result.Model); 390var model = Assert.IsType<Dictionary<string, int>>(result.Model); 421var model = Assert.IsType<Dictionary<string, int>>(modelBindingResult.Model); 526var model = Assert.IsType<Dictionary<string, Person>>(modelBindingResult.Model); 564var model = Assert.IsType<Dictionary<string, Person>>(modelBindingResult.Model); 602var model = Assert.IsType<Dictionary<string, Person>>(modelBindingResult.Model); 637var model = Assert.IsType<Dictionary<string, Person>>(modelBindingResult.Model); 672var model = Assert.IsType<Dictionary<string, Person>>(modelBindingResult.Model); 724var model = Assert.IsType<Dictionary<string, Person>>(modelBindingResult.Model); 763var model = Assert.IsType<Dictionary<string, Person>>(modelBindingResult.Model); 803var model = Assert.IsType<Dictionary<string, Person>>(modelBindingResult.Model); 843var model = Assert.IsType<Dictionary<string, Person>>(modelBindingResult.Model); 927var model = Assert.IsType<Dictionary<string, string[]>>(modelBindingResult.Model); 961var model = Assert.IsType<Dictionary<string, string[]>>(modelBindingResult.Model); 995var model = Assert.IsType<Dictionary<string, string[]>>(modelBindingResult.Model); 1034var model = Assert.IsType<Dictionary<string, string[]>>(modelBindingResult.Model); 1073var model = Assert.IsType<Dictionary<string, string[]>>(modelBindingResult.Model); 1255var model = Assert.IsType<Dictionary<string, string>>(modelBindingResult.Model); 1309var model = Assert.IsType<Dictionary<string, NonNullPerson>>(modelBindingResult.Model); 1416var model = Assert.IsType<Dictionary<string, DayOfWeek>>(modelBindingResult.Model); 1462var model = Assert.IsType<Dictionary<string, NonNullPersonWithRequiredProperties>>(modelBindingResult.Model);

52var boundPerson = Assert.IsType<TypesBundle>(modelBindingResult.Model); 111var boundPerson = Assert.IsType<TypesBundle>(modelBindingResult.Model);

57var boundPerson = Assert.IsType<Person>(modelBindingResult.Model);

57var boundPerson = Assert.IsType<Person>(modelBindingResult.Model); 104var boundPerson = Assert.IsType<Person>(modelBindingResult.Model); 155var boundPerson = Assert.IsType<Person>(modelBindingResult.Model); 214var group = Assert.IsType<Group>(modelBindingResult.Model); 301var fleet = Assert.IsType<Fleet>(modelBindingResult.Model); 366var fleet = Assert.IsType<Fleet>(modelBindingResult.Model); 432var group = Assert.IsType<Group>(modelBindingResult.Model); 495var boundContainer = Assert.IsType<ListContainer1>(result.Model); 540var boundContainer = Assert.IsType<ListContainer1>(result.Model); 584var boundContainer = Assert.IsType<ListContainer2>(result.Model); 639var file = Assert.IsType<FormFile>(modelBindingResult.Model); 726var car = Assert.IsType<Car1>(modelBindingResult.Model); 786var house = Assert.IsType<House>(modelBindingResult.Model); 851var house = Assert.IsType<House>(modelBindingResult.Model); 911var house = Assert.IsType<House>(modelBindingResult.Model); 951var house = Assert.IsType<House>(modelBindingResult.Model); 1013var car = Assert.IsType<Car1>(modelBindingResult.Model); 1068var container = Assert.IsType<MultiDimensionalFormFileContainer>(modelBindingResult.Model); 1117var container = Assert.IsType<MultiDimensionalFormFileContainer>(modelBindingResult.Model); 1164var level2 = Assert.IsType<MultiDimensionalFormFileContainerLevel2>(modelBindingResult.Model); 1228var container = Assert.IsType<DictionaryContainer>(modelBindingResult.Model);

45var model = Assert.IsType<List<IFormCollection>>(modelBindingResult.Model); 83var model = Assert.IsType<List<IFormCollection>>(modelBindingResult.Model); 122var model = Assert.IsType<List<IFormCollection>>(modelBindingResult.Model); 213var model = Assert.IsType<Address[]>(modelBindingResult.Model); 247var model = Assert.IsType<Address[]>(modelBindingResult.Model); 282var model = Assert.IsType<Dictionary<string, int>[]>(modelBindingResult.Model); 327var model = Assert.IsType<Dictionary<string, int>[]>(modelBindingResult.Model); 372var model = Assert.IsType<Dictionary<string, int>[]>(modelBindingResult.Model); 407var model = Assert.IsType<List<KeyValuePair<string, int>>>(modelBindingResult.Model); 451var model = Assert.IsType<List<KeyValuePair<string, int>>>(modelBindingResult.Model); 495var model = Assert.IsType<List<KeyValuePair<string, int>>>(modelBindingResult.Model); 531var model = Assert.IsType<Dictionary<string, List<int>>>(modelBindingResult.Model); 579var model = Assert.IsType<Dictionary<string, List<int>>>(modelBindingResult.Model); 627var model = Assert.IsType<Dictionary<string, List<int>>>(modelBindingResult.Model);

27Assert.IsType<HasValidatorsValidationMetadataProvider>(options.Value.ModelMetadataDetailsProviders.Last()); 45Assert.IsType<HasValidatorsValidationMetadataProvider>(options.Value.ModelMetadataDetailsProviders.Last());

55var boundPerson = Assert.IsType<Person>(modelBindingResult.Model); 94var boundPerson = Assert.IsType<Person>(modelBindingResult.Model); 136var boundPerson = Assert.IsType<Person>(modelBindingResult.Model); 180var boundContainer = Assert.IsType<ListContainer1>(result.Model); 227var boundContainer = Assert.IsType<ListContainer2>(result.Model); 343var product = Assert.IsType<Product>(modelBindingResult.Model);

43var model = Assert.IsType<Customer>(modelBindingResult.Model); 81var model = Assert.IsType<Customer>(modelBindingResult.Model);

37var model = Assert.IsType<KeyValuePair<string, int>>(modelBindingResult.Model); 255var model = Assert.IsType<KeyValuePair<string, int>>(modelBindingResult.Model); 295var model = Assert.IsType<KeyValuePair<string, int>>(modelBindingResult.Model); 373var model = Assert.IsType<KeyValuePair<string, Person>>(modelBindingResult.Model); 418var model = Assert.IsType<KeyValuePair<string, Person>>(modelBindingResult.Model); 459var model = Assert.IsType<KeyValuePair<string, Person>>(modelBindingResult.Model); 535var model = Assert.IsType<KeyValuePair<string, string[]>>(modelBindingResult.Model);

52var model = Assert.IsType<Person1>(modelBindingResult.Model); 101var model = Assert.IsType<Person2>(modelBindingResult.Model); 140var model = Assert.IsType<Person3>(modelBindingResult.Model); 189var model = Assert.IsType<Person4>(modelBindingResult.Model); 235var model = Assert.IsType<Person5>(modelBindingResult.Model);

44var boundPerson = Assert.IsType<Person1>(modelBindingResult.Model); 92var boundPerson = Assert.IsType<Person2>(modelBindingResult.Model); 131var boundPerson = Assert.IsType<Person3>(modelBindingResult.Model);

115var formatterArray = Assert.IsType<ITypeActivatorCache[]>(modelBindingResult.Model); 151var actionResultArray = Assert.IsType<IActionResult[]>(modelBindingResult.Model); 369var person = Assert.IsType<Person>(modelBindingResult.Model);

50var boundPerson = Assert.IsType<Person>(modelBindingResult.Model); 94var boundPerson = Assert.IsType<Person>(modelBindingResult.Model); 139var model = Assert.IsType<string>(modelBindingResult.Model); 216var model = Assert.IsType<decimal>(modelBindingResult.Model); 260var model = Assert.IsType<DateTime>(modelBindingResult.Model); 309var model = Assert.IsType<DateTime>(modelBindingResult.Model); 345var model = Assert.IsType<string>(modelBindingResult.Model); 686var boundPerson = Assert.IsType<Person>(modelBindingResult.Model); 733var model = Assert.IsType<SampleModel>(modelBindingResult.Model); 777var model = Assert.IsType<SampleTryParsableModel>(modelBindingResult.Model);

187var model = Assert.IsType<Order1>(modelBindingResult.Model); 224var model = Assert.IsType<Order1>(modelBindingResult.Model); 275var model = Assert.IsType<Order2>(modelBindingResult.Model); 313var model = Assert.IsType<Order2>(modelBindingResult.Model); 366var model = Assert.IsType<Order3>(modelBindingResult.Model); 405var model = Assert.IsType<Order3>(modelBindingResult.Model); 458var model = Assert.IsType<Order4>(modelBindingResult.Model); 497var model = Assert.IsType<Order4>(modelBindingResult.Model); 545var model = Assert.IsType<List<Order5>>(modelBindingResult.Model); 583var model = Assert.IsType<List<Order5>>(modelBindingResult.Model); 703var model = Assert.IsType<Order6>(modelBindingResult.Model); 740var model = Assert.IsType<Order6>(modelBindingResult.Model); 791var model = Assert.IsType<Order7>(modelBindingResult.Model); 828var model = Assert.IsType<Order7>(modelBindingResult.Model); 868var model = Assert.IsType<Order7>(modelBindingResult.Model); 926var model = Assert.IsType<Order8>(modelBindingResult.Model); 963var model = Assert.IsType<Order8>(modelBindingResult.Model); 1033var model = Assert.IsType<Order9>(modelBindingResult.Model); 1070var model = Assert.IsType<Order9>(modelBindingResult.Model); 1121var model = Assert.IsType<List<Order10>>(modelBindingResult.Model); 1158var model = Assert.IsType<List<Order10>>(modelBindingResult.Model); 1198var model = Assert.IsType<List<Order10>>(modelBindingResult.Model); 1238var model = Assert.IsType<User>(modelBindingResult.Model); 1278var model = Assert.IsType<User>(modelBindingResult.Model); 1368var model = Assert.IsType<ValidateSomeProperties>(result.Model); 1417var model = Assert.IsType<ValidateSomeProperties>(result.Model); 1456var model = Assert.IsType<ValidateSomeProperties>(result.Model); 1486var model = Assert.IsType<ValidateSomeProperties>(result.Model); 1519Assert.IsType<ValidateNoProperties>(result.Model); 1592var model = Assert.IsType<ValidateSomePropertiesSometimes>(result.Model); 1632var model = Assert.IsType<ValidateSomePropertiesSometimes>(result.Model); 1682var model = Assert.IsType<ValidateSomePropertiesSometimesWithoutValidation>(result.Model); 1809var message = Assert.IsType<JObject>(modelBindingResult.Model).GetValue("message").Value<string>(); 1852Assert.IsType<CancellationToken>(modelBindingResult.Model); 1897var message = Assert.IsType<Greeting>(modelBindingResult.Model).Message; 1944var message = Assert.IsType<Greeting>(modelBindingResult.Model).Message; 1998var model = Assert.IsType<Order12>(modelBindingResult.Model); 2047var model = Assert.IsType<List<int>>(modelBindingResult.Model); 2099var model = Assert.IsType<List<int>>(modelBindingResult.Model); 2169var model = Assert.IsType<Collection<InvalidEvenIds>>(modelBindingResult.Model); 2231var model = Assert.IsType<Dictionary<string, int>>(modelBindingResult.Model); 2278var model = Assert.IsType<Dictionary<string, NeverValid>>(modelBindingResult.Model); 2335var model = Assert.IsType<Validation_TopLevelPropertyModel>(modelBindingResult.Model); 2389var model = Assert.IsType<Validation_TopLevelPropertyModel>(modelBindingResult.Model); 2441var model = Assert.IsType<RecursiveModel>(modelBindingResult.Model); 2493var model = Assert.IsType<RecursiveModel>(modelBindingResult.Model); 2543var model = Assert.IsType<ModelWithNonNullableReferenceTypeProperties>(modelBindingResult.Model);

175var model = Assert.IsType<Order1>(modelBindingResult.Model); 212var model = Assert.IsType<Order1>(modelBindingResult.Model); 256var model = Assert.IsType<Order2>(modelBindingResult.Model); 294var model = Assert.IsType<Order2>(modelBindingResult.Model); 338var model = Assert.IsType<Order3>(modelBindingResult.Model); 377var model = Assert.IsType<Order3>(modelBindingResult.Model); 423var model = Assert.IsType<Order4>(modelBindingResult.Model); 462var model = Assert.IsType<Order4>(modelBindingResult.Model); 504var model = Assert.IsType<List<Order5>>(modelBindingResult.Model); 542var model = Assert.IsType<List<Order5>>(modelBindingResult.Model); 586var model = Assert.IsType<Order6>(modelBindingResult.Model); 623var model = Assert.IsType<Order6>(modelBindingResult.Model); 667var model = Assert.IsType<Order7>(modelBindingResult.Model); 704var model = Assert.IsType<Order7>(modelBindingResult.Model); 744var model = Assert.IsType<Order7>(modelBindingResult.Model); 795var model = Assert.IsType<Order8>(modelBindingResult.Model); 832var model = Assert.IsType<Order8>(modelBindingResult.Model); 895var model = Assert.IsType<Order9>(modelBindingResult.Model); 932var model = Assert.IsType<Order9>(modelBindingResult.Model); 979var model = Assert.IsType<List<Order10>>(modelBindingResult.Model); 1016var model = Assert.IsType<List<Order10>>(modelBindingResult.Model); 1056var model = Assert.IsType<List<Order10>>(modelBindingResult.Model); 1090var model = Assert.IsType<User>(modelBindingResult.Model); 1130var model = Assert.IsType<User>(modelBindingResult.Model); 1212var model = Assert.IsType<ValidateSomeProperties>(result.Model); 1261var model = Assert.IsType<ValidateSomeProperties>(result.Model); 1300var model = Assert.IsType<ValidateSomeProperties>(result.Model); 1330var model = Assert.IsType<ValidateSomeProperties>(result.Model); 1400var model = Assert.IsType<ValidateSomePropertiesSometimes>(result.Model); 1440var model = Assert.IsType<ValidateSomePropertiesSometimes>(result.Model); 1488var model = Assert.IsType<ValidateSomePropertiesSometimesWithoutValidation>(result.Model); 1612var message = Assert.IsType<JObject>(modelBindingResult.Model).GetValue("message").Value<string>(); 1655Assert.IsType<CancellationToken>(modelBindingResult.Model); 1700var message = Assert.IsType<Greeting>(modelBindingResult.Model).Message; 1747var message = Assert.IsType<Greeting>(modelBindingResult.Model).Message; 1793var model = Assert.IsType<Order12>(modelBindingResult.Model); 1838var model = Assert.IsType<List<int>>(modelBindingResult.Model); 1890var model = Assert.IsType<List<int>>(modelBindingResult.Model); 1960var model = Assert.IsType<Collection<InvalidEvenIds>>(modelBindingResult.Model); 2022var model = Assert.IsType<Dictionary<string, int>>(modelBindingResult.Model); 2069var model = Assert.IsType<Dictionary<string, NeverValid>>(modelBindingResult.Model); 2126var model = Assert.IsType<Validation_TopLevelPropertyModel>(modelBindingResult.Model); 2177var model = Assert.IsType<Validation_TopLevelPropertyModel>(modelBindingResult.Model); 2229var model = Assert.IsType<RecursiveModel>(modelBindingResult.Model); 2279var model = Assert.IsType<RecursiveModel>(modelBindingResult.Model);

107var roundTripValue = Assert.IsType<int[]>(values[key]); 128var roundTripValue = Assert.IsType<DateTime>(values[key]); 149var roundTripValue = Assert.IsType<Guid>(values[key]); 171var roundTripValue = Assert.IsType<long>(values[key]); 222var roundTripValue = Assert.IsType<string>(values[key]); 249var roundTripValue = Assert.IsType<DateTime[]>(values[key]);

66return Assert.IsType<MemoryStream>(context.Response.Body).ToArray();

37var htmlString = Assert.IsType<HtmlString>(result); 65var htmlString = Assert.IsType<HtmlString>(result); 84var htmlString = Assert.IsType<HtmlString>(result);

52var userModel = Assert.IsType<User>(result.Model); 88var userModel = Assert.IsType<User>(result.Model); 126var userModel = Assert.IsType<User>(result.Model); 468Assert.IsType<FileBufferingReadStream>(registerForDispose); 516var userModel = Assert.IsType<TypeWithPrimitives>(result.Model);

83Assert.IsType<FileBufferingWriteStream>(writeStream); 115Assert.IsType<FileBufferingWriteStream>(writeStream);

50var patchDocument = Assert.IsType<JsonPatchDocument<Customer>>(result.Model); 90var patchDocument = Assert.IsType<JsonPatchDocument<Customer>>(result.Model); 120var patchDocument = Assert.IsType<JsonPatchDocument<Customer>>(result.Model); 144var patchDocument = Assert.IsType<JsonPatchDocument<Customer>>(result.Model);

80var intValue = Assert.IsType<int>(result.Model); 101var stringValue = Assert.IsType<string>(result.Model); 122var stringValue = Assert.IsType<string>(result.Model); 228var dateValue = Assert.IsType<DateTime>(result.Model); 249var userModel = Assert.IsType<ComplexModel>(result.Model); 271var integers = Assert.IsType<int[]>(result.Model); 436Assert.IsType<TooManyModelErrorsException>(error.Exception); 555var userModel = Assert.IsType<ComplexModel>(result.Model); 577var userModel = Assert.IsType<ComplexModel>(result.Model); 603var userModel = Assert.IsType<ComplexModel>(result.Model);

223var expectedException = Assert.IsType<NotImplementedException>(serializerException.InnerException); 499return Assert.IsType<MemoryStream>(context.Response.Body).ToArray();

64var roundTripValue = Assert.IsType<int>(values[key]); 107var roundTripValue = Assert.IsType<string>(values[key]); 149var roundTripValue = Assert.IsType<DateTime>(values[key]); 170var roundTripValue = Assert.IsType<Guid>(values[key]); 192var roundTripValue = Assert.IsType<string>(values[key]); 214var roundTripValue = Assert.IsType<string>(values[key]); 236var roundTripValue = Assert.IsType<Guid>(values[key]); 257var roundTripValue = Assert.IsType<int[]>(values[key]); 278var roundTripValue = Assert.IsType<string[]>(values[key]); 299var roundTripValue = Assert.IsType<string[]>(values[key]); 324var roundTripValue = Assert.IsType<Dictionary<string, string>>(values[key]); 349var roundTripValue = Assert.IsType<Dictionary<string, int>>(values[key]);

27var htmlString = Assert.IsType<HtmlString>(result); 42var htmlString = Assert.IsType<HtmlString>(result); 61var htmlString = Assert.IsType<HtmlString>(result); 80var htmlString = Assert.IsType<HtmlString>(result); 99var htmlString = Assert.IsType<HtmlString>(result); 118var htmlString = Assert.IsType<HtmlString>(result);

28Assert.IsType<ViewDataDictionary<TestModel>>(viewDataDictionary); 47Assert.IsType<ViewDataDictionary<object>>(viewDataDictionary); 75Assert.IsType<ViewDataDictionary<TestModel>>(viewDataDictionary); 104Assert.IsType<ViewDataDictionary<TestModel>>(viewDataDictionary); 133Assert.IsType<ViewDataDictionary<TestModel>>(viewDataDictionary); 162Assert.IsType<ViewDataDictionary<object>>(viewDataDictionary);

22var compilerProvider = Assert.IsType<DefaultViewCompilerProvider>(serviceProvider.GetRequiredService<IViewCompilerProvider>()); 38var viewEngine = Assert.IsType<RazorViewEngine>(serviceProvider.GetRequiredService<IRazorViewEngine>()); 55var pageActivator = Assert.IsType<RazorPageActivator>(serviceProvider.GetRequiredService<IRazorPageActivator>());

189Assert.IsType<ViewDataDictionary<Guid>>(viewContext.ViewData);

200var content = Assert.IsType<DefaultTagHelperContent>(returnValue); 241var content = Assert.IsType<string>(returnValue); 1448var bufferedWriter = Assert.IsType<ViewBufferTextWriter>(Output);

157var view = Assert.IsType<RazorView>(result.View); 189var view1 = Assert.IsType<RazorView>(result1.View); 200var view2 = Assert.IsType<RazorView>(result2.View); 323var view = Assert.IsType<RazorView>(result.View); 355var view = Assert.IsType<RazorView>(result.View); 521var view = Assert.IsType<RazorView>(result.View); 557var view1 = Assert.IsType<RazorView>(result1.View); 571var view2 = Assert.IsType<RazorView>(result2.View); 583var view3 = Assert.IsType<RazorView>(result3.View); 585var view4 = Assert.IsType<RazorView>(result4.View); 621var view1 = Assert.IsType<RazorView>(result1.View); 636var view2 = Assert.IsType<RazorView>(result2.View); 648var view3 = Assert.IsType<RazorView>(result3.View); 650var view4 = Assert.IsType<RazorView>(result4.View); 843var view1 = Assert.IsType<RazorView>(result1.View); 856var view2 = Assert.IsType<RazorView>(result2.View); 880var view1 = Assert.IsType<RazorView>(result1.View); 893var view2 = Assert.IsType<RazorView>(result2.View); 931var view1 = Assert.IsType<RazorView>(result1.View); 940var view2 = Assert.IsType<RazorView>(result2.View); 1054var view = Assert.IsType<RazorView>(result.View); 2002var view = Assert.IsType<RazorView>(result.View); 2020var view = Assert.IsType<RazorView>(result.View);

53Assert.IsType<ViewBufferTextWriter>(actual); 302Assert.IsType<ViewBufferTextWriter>(actual);

89var attributeValue = Assert.IsType<string>(attribute.Value); 131var attributeValue = Assert.IsType<string>(attribute.Value); 249var attributeValue = Assert.IsType<string>(attribute.Value); 305var attributeValue = Assert.IsType<HtmlString>(attribute.Value); 336Assert.True(Assert.IsType<bool>(attribute.Value)); 431var attributeValue = Assert.IsType<string>(attribute.Value);

34f => Assert.IsType<PageHandlerPageFilter>(f), 35f => Assert.IsType<HandleOptionsRequestsPageFilter>(f)); 68f => Assert.IsType<PageHandlerPageFilter>(f), 69f => Assert.IsType<HandleOptionsRequestsPageFilter>(f)); 86f => Assert.IsType<PageHandlerPageFilter>(f), 87f => Assert.IsType<HandleOptionsRequestsPageFilter>(f), 88f => Assert.IsType<AuthorizeFilter>(f)); 126f => Assert.IsType<PageHandlerPageFilter>(f), 127f => Assert.IsType<HandleOptionsRequestsPageFilter>(f), 128f => authorizeFilter = Assert.IsType<AuthorizeFilter>(f)); 168f => Assert.IsType<PageHandlerPageFilter>(f), 169f => Assert.IsType<HandleOptionsRequestsPageFilter>(f), 170f => Assert.IsType<AllowAnonymousFilter>(f));

547filter => Assert.IsType<TypeFilterAttribute>(filter), 548filter => Assert.IsType<ServiceFilterAttribute>(filter), 549filter => Assert.IsType<PageHandlerPageFilter>(filter), 550filter => Assert.IsType<HandleOptionsRequestsPageFilter>(filter)); 1100filter => Assert.IsType<HandleOptionsRequestsPageFilter>(filter)); 1117filter => Assert.IsType<TypeFilterAttribute>(filter), 1118filter => Assert.IsType<HandleOptionsRequestsPageFilter>(filter)); 1142filter => Assert.IsType<PageHandlerPageFilter>(filter), 1143filter => Assert.IsType<HandleOptionsRequestsPageFilter>(filter)); 1173filter => Assert.IsType<PageHandlerPageFilter>(filter), 1174filter => Assert.IsType<HandleOptionsRequestsPageFilter>(filter)); 1209filter => Assert.IsType<ServiceFilterAttribute>(filter), 1210filter => Assert.IsType<PageHandlerPageFilter>(filter), 1211filter => Assert.IsType<HandleOptionsRequestsPageFilter>(filter));

92convention => Assert.IsType<BarPageConvention>(convention)); 112convention => Assert.IsType<BarPageConvention>(convention));

33f => Assert.IsType<PageHandlerPageFilter>(f), 34f => Assert.IsType<HandleOptionsRequestsPageFilter>(f)); 68f => Assert.IsType<PageHandlerPageFilter>(f), 69f => Assert.IsType<HandleOptionsRequestsPageFilter>(f), 72var filter = Assert.IsType<PageResponseCacheFilter>(f); 115f => Assert.IsType<PageHandlerPageFilter>(f), 116f => Assert.IsType<HandleOptionsRequestsPageFilter>(f), 119var filter = Assert.IsType<PageResponseCacheFilter>(f);

74Assert.IsType<PageSaveTempDataPropertyFilterFactory>(filter); 89var filter = Assert.IsType<PageSaveTempDataPropertyFilterFactory>(Assert.Single(context.PageApplicationModel.Filters)); 111var filter = Assert.IsType<PageSaveTempDataPropertyFilterFactory>(Assert.Single(context.PageApplicationModel.Filters));

40var viewDataFilter = Assert.IsType<PageViewDataAttributeFilterFactory>(filter);

66Assert.IsType<AuthorizeAttribute>(Assert.Single(model.EndpointMetadata)); 72Assert.IsType<AuthorizeAttribute>(model.EndpointMetadata[0]); 73Assert.IsType<AllowAnonymousAttribute>(model.EndpointMetadata[1]); 100Assert.IsType<AuthorizeFilter>(Assert.Single(model.Filters)); 105Assert.IsType<AuthorizeFilter>(model.Filters[0]); 106Assert.IsType<AllowAnonymousFilter>(model.Filters[1]); 132Assert.IsType<AllowAnonymousAttribute>(Assert.Single(model.EndpointMetadata)); 157Assert.IsType<AllowAnonymousFilter>(Assert.Single(model.Filters)); 187metadata => Assert.IsType<AuthorizeAttribute>(metadata)); 194metadata => Assert.IsType<AuthorizeAttribute>(metadata), 195metadata => Assert.IsType<AllowAnonymousAttribute>(metadata)); 201metadata => Assert.IsType<AuthorizeAttribute>(metadata), 202metadata => Assert.IsType<AllowAnonymousAttribute>(metadata)); 230Assert.IsType<AuthorizeFilter>(Assert.Single(model.Filters)); 235Assert.IsType<AuthorizeFilter>(model.Filters[0]); 236Assert.IsType<AllowAnonymousFilter>(model.Filters[1]); 241Assert.IsType<AuthorizeFilter>(model.Filters[0]); 242Assert.IsType<AllowAnonymousFilter>(model.Filters[1]); 272metadata => Assert.IsType<AuthorizeAttribute>(metadata)); 279metadata => Assert.IsType<AuthorizeAttribute>(metadata), 280metadata => Assert.IsType<AllowAnonymousAttribute>(metadata)); 287metadata => Assert.IsType<AuthorizeAttribute>(metadata), 288metadata => Assert.IsType<AllowAnonymousAttribute>(metadata)); 316Assert.IsType<AuthorizeFilter>(Assert.Single(model.Filters)); 321Assert.IsType<AuthorizeFilter>(model.Filters[0]); 322Assert.IsType<AllowAnonymousFilter>(model.Filters[1]); 327Assert.IsType<AuthorizeFilter>(model.Filters[0]); 328Assert.IsType<AllowAnonymousFilter>(model.Filters[1]); 358Assert.IsType<AllowAnonymousAttribute>(Assert.Single(model.EndpointMetadata)); 364Assert.IsType<AllowAnonymousAttribute>(Assert.Single(model.EndpointMetadata)); 394Assert.IsType<AllowAnonymousFilter>(Assert.Single(model.Filters)); 399Assert.IsType<AllowAnonymousFilter>(Assert.Single(model.Filters)); 427var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(model.EndpointMetadata)); 455var authorizeFilter = Assert.IsType<AuthorizeFilter>(Assert.Single(model.Filters)); 456var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(authorizeFilter.AuthorizeData)); 484var authorizeAttribute = Assert.IsType<AuthorizeAttribute>(Assert.Single(model.EndpointMetadata)); 510var authFilter = Assert.IsType<AuthorizeFilter>(Assert.Single(model.Filters)); 538var authorizeAttribute = Assert.IsType<AuthorizeAttribute>(Assert.Single(model.EndpointMetadata)); 564var authFilter = Assert.IsType<AuthorizeFilter>(Assert.Single(model.Filters)); 593var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(model.EndpointMetadata)); 621var authorizeFilter = Assert.IsType<AuthorizeFilter>(Assert.Single(model.Filters)); 622var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(authorizeFilter.AuthorizeData)); 653var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(model.EndpointMetadata)); 660var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(model.EndpointMetadata)); 689var authorizeFilter = Assert.IsType<AuthorizeFilter>(Assert.Single(model.Filters)); 690var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(authorizeFilter.AuthorizeData)); 696var authorizeFilter = Assert.IsType<AuthorizeFilter>(Assert.Single(model.Filters)); 697var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(authorizeFilter.AuthorizeData)); 728var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(model.EndpointMetadata)); 735var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(model.EndpointMetadata)); 766var authorizeFilter = Assert.IsType<AuthorizeFilter>(Assert.Single(model.Filters)); 767var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(authorizeFilter.AuthorizeData)); 773var authorizeFilter = Assert.IsType<AuthorizeFilter>(Assert.Single(model.Filters)); 774var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(authorizeFilter.AuthorizeData)); 806var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(model.EndpointMetadata)); 813var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(model.EndpointMetadata)); 844var authorizeFilter = Assert.IsType<AuthorizeFilter>(Assert.Single(model.Filters)); 845var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(authorizeFilter.AuthorizeData)); 851var authorizeFilter = Assert.IsType<AuthorizeFilter>(Assert.Single(model.Filters)); 852var authorizeData = Assert.IsType<AuthorizeAttribute>(Assert.Single(authorizeFilter.AuthorizeData));

180expander => Assert.IsType<PageViewLocationExpander>(expander));

35filter => Assert.IsType<AutoValidateAntiforgeryTokenAttribute>(filter));

27var pageFilter = Assert.IsType<PageSaveTempDataPropertyFilter>(filter);

26var filter = Assert.IsType<PageViewDataAttributeFilter>(result);

244var model = Assert.IsType<PageParameterModel>(m); 341var model = Assert.IsType<PagePropertyModel>(m);

61var testPage = Assert.IsType<TestPage>(instance); 97var testPage = Assert.IsType<TestPage>(instance); 127var testPage = Assert.IsType<ViewDataTestPage>(instance); 154var testPage = Assert.IsType<ViewDataTestPage>(instance); 181var testPage = Assert.IsType<ViewDataTestPage>(instance); 206var testPage = Assert.IsType<NonGenericViewDataTestPage>(instance); 240var testPage = Assert.IsType<TestPage>(instance); 278var testPage = Assert.IsType<PropertiesWithoutRazorInject>(instance);

56var simpleModel = Assert.IsType<SimpleModel>(model); 86var modelWithServices = Assert.IsType<ModelWithServices>(model);

57var model = Assert.IsType<SimpleModel>(instance); 77var testModel = Assert.IsType<ModelWithPageContext>(instance);

122Assert.IsType<OkResult>(context.Result);

29Assert.IsType<EmptyResult>(actionResult); 49Assert.IsType<ViewResult>(actionResult); 70var contentResult = Assert.IsType<ContentResult>(actionResult); 138Assert.IsType<EmptyResult>(actionResult); 159var contentResult = Assert.IsType<ContentResult>(actionResult);

61var descriptor = Assert.IsType<PageActionDescriptor>(result); 100var descriptor = Assert.IsType<PageActionDescriptor>(result); 150var descriptor = Assert.IsType<PageActionDescriptor>(result); 196var descriptor = Assert.IsType<PageActionDescriptor>(result); 230var descriptor = Assert.IsType<PageActionDescriptor>(result); 330var descriptor = Assert.IsType<PageActionDescriptor>(result); 337var descriptor = Assert.IsType<PageActionDescriptor>(result);

65var actionInvoker = Assert.IsType<PageActionInvoker>(context.Result); 128var actionInvoker = Assert.IsType<PageActionInvoker>(context.Result); 131var compiledPageActionDescriptor = Assert.IsType<CompiledPageActionDescriptor>(entry.ActionDescriptor); 145Assert.NotNull(Assert.IsType<ViewDataDictionary<TestPageModel>>(pageContext.ViewData)); 193var actionInvoker = Assert.IsType<PageActionInvoker>(context.Result); 225var actionInvoker = Assert.IsType<PageActionInvoker>(context.Result); 239actionInvoker = Assert.IsType<PageActionInvoker>(context.Result); 271Assert.IsType<PageActionInvoker>(context.Result); 305Assert.IsType<PageActionInvoker>(context.Result); 342var actionInvoker = Assert.IsType<PageActionInvoker>(context1.Result); 358actionInvoker = Assert.IsType<PageActionInvoker>(context2.Result);

109var pageContext = Assert.IsType<PageActionInvoker>(invoker).PageContext; 143var pageContext = Assert.IsType<PageActionInvoker>(invoker).PageContext; 199var page = Assert.IsType<TestPage>(instance); 200Assert.IsType<ViewDataDictionary<TestPage>>(page.ViewContext.ViewData); 203var pageResult = Assert.IsType<PageResult>(result); 255var page = Assert.IsType<TestPage>(instance); 256Assert.IsType<ViewDataDictionary<PocoModel>>(page.PageContext.ViewData); 259var pageResult = Assert.IsType<PageResult>(result); 315var pageModel = Assert.IsType<TestPageModel>(instance); 316Assert.IsType<ViewDataDictionary<TestPageModel>>(pageModel.PageContext.ViewData); 319var pageResult = Assert.IsType<PageResult>(result); 320Assert.IsType<TestPage>(pageResult.Page); 348var page = Assert.IsType<TestPage>(instance); 480var pageResult = Assert.IsType<PageResult>(result); 481Assert.IsType<ViewDataDictionary<TestPage>>(pageResult.ViewData); 482Assert.IsType<TestPage>(pageResult.Model); 578var pageResult = Assert.IsType<PageResult>(result); 612var pageResult = Assert.IsType<PageResult>(result); 647var pageResult = Assert.IsType<PageResult>(result); 681var pageResult = Assert.IsType<PageResult>(result); 716var pageResult = Assert.IsType<PageResult>(result); 750var pageResult = Assert.IsType<PageResult>(result); 786var pageResult = Assert.IsType<PageResult>(result); 821var pageResult = Assert.IsType<PageResult>(result);

87var simpleModel2 = Assert.IsType<DISimpleModel>(model);

42Assert.IsType<RedirectResult>(result); 59Assert.IsType<RedirectResult>(result); 76Assert.IsType<RedirectResult>(result); 93Assert.IsType<RedirectResult>(result); 140Assert.IsType<LocalRedirectResult>(result); 157Assert.IsType<LocalRedirectResult>(result); 174Assert.IsType<LocalRedirectResult>(result); 191Assert.IsType<LocalRedirectResult>(result); 282Assert.IsType<RedirectToActionResult>(resultTemporary); 298Assert.IsType<RedirectToActionResult>(resultTemporary); 314Assert.IsType<RedirectToActionResult>(resultPermanent); 330Assert.IsType<RedirectToActionResult>(resultPermanent); 349Assert.IsType<RedirectToActionResult>(resultTemporary); 369Assert.IsType<RedirectToActionResult>(resultTemporary); 389Assert.IsType<RedirectToActionResult>(resultPermanent); 409Assert.IsType<RedirectToActionResult>(resultPermanent); 429Assert.IsType<RedirectToActionResult>(resultTemporary); 453Assert.IsType<RedirectToActionResult>(resultTemporary); 477Assert.IsType<RedirectToActionResult>(resultPermanent); 501Assert.IsType<RedirectToActionResult>(resultPermanent); 522Assert.IsType<RedirectToActionResult>(resultTemporary); 542Assert.IsType<RedirectToActionResult>(resultTemporary); 565Assert.IsType<RedirectToActionResult>(result); 590Assert.IsType<RedirectToActionResult>(result); 612Assert.IsType<RedirectToActionResult>(resultPermanent); 632Assert.IsType<RedirectToActionResult>(resultPermanent); 655Assert.IsType<RedirectToActionResult>(result); 684Assert.IsType<RedirectToActionResult>(result); 706Assert.IsType<RedirectToRouteResult>(resultTemporary); 725Assert.IsType<RedirectToRouteResult>(resultTemporary); 746Assert.IsType<RedirectToRouteResult>(result); 769Assert.IsType<RedirectToRouteResult>(result); 790Assert.IsType<RedirectToRouteResult>(resultPermanent); 809Assert.IsType<RedirectToRouteResult>(resultPermanent); 830Assert.IsType<RedirectToRouteResult>(result); 853Assert.IsType<RedirectToRouteResult>(result); 872Assert.IsType<RedirectToRouteResult>(resultTemporary); 889Assert.IsType<RedirectToRouteResult>(resultTemporary); 906Assert.IsType<RedirectToRouteResult>(resultPermanent); 923Assert.IsType<RedirectToRouteResult>(resultPermanent); 969Assert.IsType<RedirectToPageResult>(result); 984Assert.IsType<RedirectToPageResult>(result); 999Assert.IsType<RedirectToPageResult>(result); 1022Assert.IsType<RedirectToPageResult>(result); 1039Assert.IsType<RedirectToPageResult>(result); 1063Assert.IsType<RedirectToPageResult>(result); 1083Assert.IsType<RedirectToPageResult>(result); 1107Assert.IsType<RedirectToPageResult>(result); 1124Assert.IsType<RedirectToPageResult>(result); 1142Assert.IsType<RedirectToPageResult>(result); 1167Assert.IsType<RedirectToPageResult>(result); 1193Assert.IsType<RedirectToPageResult>(result); 1214Assert.IsType<RedirectToPageResult>(result); 1239Assert.IsType<RedirectToPageResult>(result); 1259Assert.IsType<RedirectToPageResult>(resultPermanent); 1280Assert.IsType<RedirectToPageResult>(resultPermanent); 1301Assert.IsType<RedirectToRouteResult>(resultTemporary); 1322Assert.IsType<RedirectToRouteResult>(resultTemporary); 1343Assert.IsType<RedirectToRouteResult>(resultPermanent); 1364Assert.IsType<RedirectToRouteResult>(resultPermanent); 1502Assert.IsType<UnauthorizedResult>(result); 1516Assert.IsType<BadRequestResult>(result); 1530Assert.IsType<BadRequestObjectResult>(result); 1545Assert.IsType<NotFoundResult>(result); 1559Assert.IsType<NotFoundObjectResult>(result); 1574Assert.IsType<ContentResult>(actualContentResult); 1589Assert.IsType<ContentResult>(actualContentResult); 1605Assert.IsType<ContentResult>(actualContentResult); 1820var redirectResult = Assert.IsType<RedirectResult>(result); 1838var pageResult = Assert.IsType<PageResult>(result);

62Assert.IsType<RedirectResult>(result); 79Assert.IsType<RedirectResult>(result); 96Assert.IsType<RedirectResult>(result); 113Assert.IsType<RedirectResult>(result); 160Assert.IsType<LocalRedirectResult>(result); 177Assert.IsType<LocalRedirectResult>(result); 194Assert.IsType<LocalRedirectResult>(result); 211Assert.IsType<LocalRedirectResult>(result); 302Assert.IsType<RedirectToActionResult>(resultTemporary); 318Assert.IsType<RedirectToActionResult>(resultTemporary); 334Assert.IsType<RedirectToActionResult>(resultPermanent); 350Assert.IsType<RedirectToActionResult>(resultPermanent); 369Assert.IsType<RedirectToActionResult>(resultTemporary); 389Assert.IsType<RedirectToActionResult>(resultTemporary); 409Assert.IsType<RedirectToActionResult>(resultPermanent); 429Assert.IsType<RedirectToActionResult>(resultPermanent); 449Assert.IsType<RedirectToActionResult>(resultTemporary); 473Assert.IsType<RedirectToActionResult>(resultTemporary); 497Assert.IsType<RedirectToActionResult>(resultPermanent); 521Assert.IsType<RedirectToActionResult>(resultPermanent); 542Assert.IsType<RedirectToActionResult>(resultTemporary); 562Assert.IsType<RedirectToActionResult>(resultTemporary); 585Assert.IsType<RedirectToActionResult>(result); 610Assert.IsType<RedirectToActionResult>(result); 632Assert.IsType<RedirectToActionResult>(resultPermanent); 652Assert.IsType<RedirectToActionResult>(resultPermanent); 675Assert.IsType<RedirectToActionResult>(result); 704Assert.IsType<RedirectToActionResult>(result); 726Assert.IsType<RedirectToRouteResult>(resultTemporary); 745Assert.IsType<RedirectToRouteResult>(resultTemporary); 766Assert.IsType<RedirectToRouteResult>(result); 789Assert.IsType<RedirectToRouteResult>(result); 810Assert.IsType<RedirectToRouteResult>(resultPermanent); 829Assert.IsType<RedirectToRouteResult>(resultPermanent); 850Assert.IsType<RedirectToRouteResult>(result); 873Assert.IsType<RedirectToRouteResult>(result); 892Assert.IsType<RedirectToRouteResult>(resultTemporary); 909Assert.IsType<RedirectToRouteResult>(resultTemporary); 926Assert.IsType<RedirectToRouteResult>(resultPermanent); 943Assert.IsType<RedirectToRouteResult>(resultPermanent); 963Assert.IsType<RedirectToRouteResult>(resultTemporary); 984Assert.IsType<RedirectToRouteResult>(resultTemporary); 1005Assert.IsType<RedirectToRouteResult>(resultPermanent); 1026Assert.IsType<RedirectToRouteResult>(resultPermanent); 1043Assert.IsType<RedirectToPageResult>(result); 1058Assert.IsType<RedirectToPageResult>(result); 1073Assert.IsType<RedirectToPageResult>(result); 1096Assert.IsType<RedirectToPageResult>(result); 1113Assert.IsType<RedirectToPageResult>(result); 1137Assert.IsType<RedirectToPageResult>(result); 1157Assert.IsType<RedirectToPageResult>(result); 1181Assert.IsType<RedirectToPageResult>(result); 1198Assert.IsType<RedirectToPageResult>(result); 1216Assert.IsType<RedirectToPageResult>(result); 1241Assert.IsType<RedirectToPageResult>(result); 1267Assert.IsType<RedirectToPageResult>(result); 1288Assert.IsType<RedirectToPageResult>(result); 1313Assert.IsType<RedirectToPageResult>(result); 1333Assert.IsType<RedirectToPageResult>(resultPermanent); 1354Assert.IsType<RedirectToPageResult>(resultPermanent); 1492Assert.IsType<UnauthorizedResult>(result); 1506Assert.IsType<BadRequestResult>(result); 1520Assert.IsType<BadRequestObjectResult>(result); 1535Assert.IsType<NotFoundResult>(result); 1549Assert.IsType<NotFoundObjectResult>(result); 1564Assert.IsType<ContentResult>(actualContentResult); 1579Assert.IsType<ContentResult>(actualContentResult); 1595Assert.IsType<ContentResult>(actualContentResult);

35var endpoint = Assert.IsType<RouteEndpoint>(Assert.Single(endpoints)); 61(e) => Assert.Equal("/test", Assert.IsType<RouteEndpoint>(e).RoutePattern.RawText)); 98var routePattern = Assert.IsType<RouteEndpoint>(e).RoutePattern; 120var routePattern = Assert.IsType<RouteEndpoint>(e).RoutePattern;

450var rvd = Assert.IsType<RouteValueDictionary>(routeValues);

1009var cacheKey = Assert.IsType<CacheTagKey>(key); 1031var cacheKey = Assert.IsType<CacheTagKey>(key);

460var rvd = Assert.IsType<RouteValueDictionary>(routeContext.Values);

470var routeValueDictionary = Assert.IsType<RouteValueDictionary>(routeValues); 928var rvd = Assert.IsType<RouteValueDictionary>(routeValues);

332var actual = Assert.IsType<PropertyModel>(v.ViewData.Model);

622var actualCurrentValues = Assert.IsType<CurrentValues>(keyValuePair.Value); 698var actualCurrentValues = Assert.IsType<CurrentValues>(keyValuePair.Value);

36Assert.IsType<RazorViewEngine>(viewEngine); 48binder => Assert.IsType<BinderTypeModelBinderProvider>(binder), 49binder => Assert.IsType<ServicesModelBinderProvider>(binder), 50binder => Assert.IsType<BodyModelBinderProvider>(binder), 51binder => Assert.IsType<HeaderModelBinderProvider>(binder), 52binder => Assert.IsType<FloatingPointTypeModelBinderProvider>(binder), 53binder => Assert.IsType<EnumTypeModelBinderProvider>(binder), 54binder => Assert.IsType<DateTimeModelBinderProvider>(binder), 55binder => Assert.IsType<SimpleTypeModelBinderProvider>(binder), 56binder => Assert.IsType<TryParseModelBinderProvider>(binder), 57binder => Assert.IsType<CancellationTokenModelBinderProvider>(binder), 58binder => Assert.IsType<ByteArrayModelBinderProvider>(binder), 59binder => Assert.IsType<FormFileModelBinderProvider>(binder), 60binder => Assert.IsType<FormCollectionModelBinderProvider>(binder), 61binder => Assert.IsType<KeyValuePairModelBinderProvider>(binder), 62binder => Assert.IsType<DictionaryModelBinderProvider>(binder), 63binder => Assert.IsType<ArrayModelBinderProvider>(binder), 64binder => Assert.IsType<CollectionModelBinderProvider>(binder), 65binder => Assert.IsType<ComplexObjectModelBinderProvider>(binder)); 77provider => Assert.IsType<FormValueProviderFactory>(provider), 78provider => Assert.IsType<RouteValueProviderFactory>(provider), 79provider => Assert.IsType<QueryStringValueProviderFactory>(provider), 80provider => Assert.IsType<JQueryFormValueProviderFactory>(provider), 81provider => Assert.IsType<FormFileValueProviderFactory>(provider)); 92formatter => Assert.IsType<HttpNoContentOutputFormatter>(formatter), 93formatter => Assert.IsType<StringOutputFormatter>(formatter), 94formatter => Assert.IsType<StreamOutputFormatter>(formatter), 95formatter => Assert.IsType<SystemTextJsonOutputFormatter>(formatter)); 107formatter => Assert.IsType<SystemTextJsonInputFormatter>(formatter)); 129validator => Assert.IsType<DefaultModelValidatorProvider>(validator), 130validator => Assert.IsType<DataAnnotationsModelValidatorProvider>(validator)); 141validator => Assert.IsType<DefaultClientModelValidatorProvider>(validator), 142validator => Assert.IsType<DataAnnotationsClientModelValidatorProvider>(validator), 143validator => Assert.IsType<NumericClientModelValidatorProvider>(validator)); 169provider => Assert.IsType<ExcludeBindingMetadataProvider>(provider), 170provider => Assert.IsType<DefaultBindingMetadataProvider>(provider), 171provider => Assert.IsType<DefaultValidationMetadataProvider>(provider), 174var specialParameter = Assert.IsType<BindingSourceMetadataProvider>(provider); 180var formFileParameter = Assert.IsType<BindingSourceMetadataProvider>(provider); 186var formCollectionParameter = Assert.IsType<BindingSourceMetadataProvider>(provider); 192var formFileParameter = Assert.IsType<BindingSourceMetadataProvider>(provider); 198var formFileParameter = Assert.IsType<BindingSourceMetadataProvider>(provider); 204var excludeFilter = Assert.IsType<SuppressChildValidationMetadataProvider>(provider); 209var excludeFilter = Assert.IsType<SuppressChildValidationMetadataProvider>(provider); 214var excludeFilter = Assert.IsType<SuppressChildValidationMetadataProvider>(provider); 219var excludeFilter = Assert.IsType<SuppressChildValidationMetadataProvider>(provider); 224var excludeFilter = Assert.IsType<SuppressChildValidationMetadataProvider>(provider); 229var excludeFilter = Assert.IsType<SuppressChildValidationMetadataProvider>(provider); 234var excludeFilter = Assert.IsType<SuppressChildValidationMetadataProvider>(provider); 239var excludeFilter = Assert.IsType<SuppressChildValidationMetadataProvider>(provider); 244var excludeFilter = Assert.IsType<SuppressChildValidationMetadataProvider>(provider); 249var excludeFilter = Assert.IsType<SuppressChildValidationMetadataProvider>(provider); 254var excludeFilter = Assert.IsType<SuppressChildValidationMetadataProvider>(provider); 259var excludeFilter = Assert.IsType<SuppressChildValidationMetadataProvider>(provider); 262provider => Assert.IsType<DataAnnotationsMetadataProvider>(provider), 263provider => Assert.IsType<DataMemberRequiredBindingMetadataProvider>(provider), 266var excludeFilter = Assert.IsType<SuppressChildValidationMetadataProvider>(provider); 271var excludeFilter = Assert.IsType<SuppressChildValidationMetadataProvider>(provider); 274provider => Assert.IsType<HasValidatorsValidationMetadataProvider>(provider));

313var manager = Assert.IsType<ApplicationPartManager>(descriptor.ImplementationInstance); 341var manager = Assert.IsType<ApplicationPartManager>(descriptor.ImplementationInstance); 367var manager = Assert.IsType<ApplicationPartManager>(descriptor.ImplementationInstance); 370feature => Assert.IsType<ControllerFeatureProvider>(feature), 371feature => Assert.IsType<ViewComponentFeatureProvider>(feature), 372feature => Assert.IsType<TagHelperFeatureProvider>(feature), 373feature => Assert.IsType<RazorCompiledItemFeatureProvider>(feature));

59Assert.Equal("Hello world", Assert.IsType<string>(page.Buffer[0].Value)); 265Assert.Equal("Hello", Assert.IsType<HtmlString>(nestedItems[0]).Value); 266Assert.Equal("Hello", Assert.IsType<HtmlString>(destinationItems[0]).Value); 289Assert.Equal("Hello", Assert.IsType<HtmlString>(destinationItems[0]).Value);

77Assert.IsType<ViewResult>(actualViewResult); 101Assert.IsType<ViewResult>(actualViewResult); 122Assert.IsType<ViewResult>(actualViewResult); 144Assert.IsType<ViewResult>(actualViewResult); 166Assert.IsType<ViewResult>(actualViewResult); 188Assert.IsType<ViewResult>(actualViewResult); 212Assert.IsType<PartialViewResult>(actualViewResult); 235Assert.IsType<PartialViewResult>(actualViewResult); 257Assert.IsType<PartialViewResult>(actualViewResult); 279Assert.IsType<PartialViewResult>(actualViewResult); 301Assert.IsType<PartialViewResult>(actualViewResult); 319Assert.IsType<JsonResult>(actualJsonResult); 335Assert.IsType<JsonResult>(actualJsonResult);

29var viewResult = Assert.IsType<ViewResult>(result); 51var viewResult = Assert.IsType<PartialViewResult>(result); 75var contentResult = Assert.IsType<ContentResult>(result); 96var createdResult = Assert.IsType<CreatedResult>(result); 116var acceptedResult = Assert.IsType<AcceptedResult>(result); 137var fileContentResult = Assert.IsType<FileContentResult>(result); 170var fileStreamResult = Assert.IsType<FileStreamResult>(result); 200var jsonResult = Assert.IsType<JsonResult>(result); 203Assert.IsType<MyModel>(jsonResult.Value); 214jsonResult = Assert.IsType<JsonResult>(result); 232var jsonResult = Assert.IsType<JsonResult>(result); 235Assert.IsType<MyModel>(jsonResult.Value); 250var httpNotFoundResult = Assert.IsType<NotFoundResult>(result); 266var httpNotFoundObjectResult = Assert.IsType<NotFoundObjectResult>(result); 283var httpBadRequest = Assert.IsType<BadRequestResult>(result); 300var httpBadRequest = Assert.IsType<BadRequestObjectResult>(result); 313httpBadRequest = Assert.IsType<BadRequestObjectResult>(result); 333var createdAtRouteResult = Assert.IsType<CreatedAtRouteResult>(result); 348createdAtRouteResult = Assert.IsType<CreatedAtRouteResult>(result); 369var acceptedAtRouteResult = Assert.IsType<AcceptedAtRouteResult>(result); 384acceptedAtRouteResult = Assert.IsType<AcceptedAtRouteResult>(result); 406var createdAtActionResult = Assert.IsType<CreatedAtActionResult>(result); 422createdAtActionResult = Assert.IsType<CreatedAtActionResult>(result); 445var acceptedAtActionResult = Assert.IsType<AcceptedAtActionResult>(result); 461acceptedAtActionResult = Assert.IsType<AcceptedAtActionResult>(result); 482var redirectToRouteResult = Assert.IsType<RedirectToRouteResult>(result); 496redirectToRouteResult = Assert.IsType<RedirectToRouteResult>(result); 516var redirectToActionResult = Assert.IsType<RedirectToActionResult>(result); 531redirectToActionResult = Assert.IsType<RedirectToActionResult>(result); 550var redirectResult = Assert.IsType<RedirectResult>(result); 693var badRequest = Assert.IsType<ObjectResult>(result); 694var problemDetails = Assert.IsType<ProblemDetails>(badRequest.Value); 710var badRequest = Assert.IsType<ObjectResult>(result); 711var validationProblemDetails = Assert.IsType<ValidationProblemDetails>(badRequest.Value);

31Assert.IsType<AntiforgeryMiddlewareAuthorizationFilter>(Assert.Single(model.Filters)); 36Assert.IsType<ValidateAntiForgeryTokenAttribute>(Assert.Single(model.Filters));

29Assert.IsType<AntiforgeryValidationFailedResult>(context.Result);

23var tempDataFilter = Assert.IsType<ControllerSaveTempDataPropertyFilter>(filter);

25var filter = Assert.IsType<ControllerViewDataAttributeFilter>(result);

76var filter = Assert.IsType<ControllerSaveTempDataPropertyFilterFactory>(Assert.Single(controller.Filters)); 97var filter = Assert.IsType<ControllerSaveTempDataPropertyFilterFactory>(Assert.Single(controller.Filters));

96Assert.IsType<AntiforgeryValidationFailedResult>(context.Result);

42Assert.IsType<ControllerViewDataAttributeFilterFactory>(Assert.Single(controller.Filters)); 56var filter = Assert.IsType<ControllerViewDataAttributeFilterFactory>(Assert.Single(controller.Filters));

104Assert.IsType<HtmlAttributePropertyHelper>(helpers1[0]);

30var roundTripValue = Assert.IsType<string>(values[key]);

64var roundTripValue = Assert.IsType<int>(values[key]); 107var roundTripValue = Assert.IsType<string>(values[key]); 149var roundTripValue = Assert.IsType<DateTime>(values[key]); 170var roundTripValue = Assert.IsType<Guid>(values[key]); 192var roundTripValue = Assert.IsType<string>(values[key]); 214var roundTripValue = Assert.IsType<string>(values[key]); 236var roundTripValue = Assert.IsType<Guid>(values[key]); 257var roundTripValue = Assert.IsType<int[]>(values[key]); 278var roundTripValue = Assert.IsType<string[]>(values[key]); 299var roundTripValue = Assert.IsType<string[]>(values[key]); 324var roundTripValue = Assert.IsType<Dictionary<string, string>>(values[key]); 349var roundTripValue = Assert.IsType<Dictionary<string, int>>(values[key]);

54var routeDictionary = Assert.IsType<RouteValueDictionary>(urlHelper.RouteValues);

169var routeDictionary = Assert.IsType<RouteValueDictionary>(urlHelper.RouteValues); 188var routeDictionary = Assert.IsType<RouteValueDictionary>(urlHelper.RouteValues); 209var routeDictionary = Assert.IsType<RouteValueDictionary>(urlHelper.RouteValues);

591Assert.Equal("antiforgery", Assert.IsType<TagBuilder>(htmlHelper.AntiForgeryToken()).TagName);

302Assert.IsType<ViewDataDictionary<BaseModel>>(

27var htmlString = Assert.IsType<HtmlString>(result); 42var htmlString = Assert.IsType<HtmlString>(result); 61var htmlString = Assert.IsType<HtmlString>(result); 80var htmlString = Assert.IsType<HtmlString>(result); 99var htmlString = Assert.IsType<HtmlString>(result); 118var htmlString = Assert.IsType<HtmlString>(result);

34var htmlString = Assert.IsType<HtmlString>(result); 53var htmlString = Assert.IsType<HtmlString>(result); 85var htmlString = Assert.IsType<HtmlString>(result);

29var activablePropertiesComponent = Assert.IsType<ActivablePropertiesViewComponent>(result);

26Assert.IsType<Dictionary<string, object>>(argumentDictionary); 44Assert.IsType<int>(item.Value); 64Assert.IsType<int>(item.Value); 84Assert.IsType<int>(item1.Value); 90Assert.IsType<string>(item2.Value); 111Assert.IsType<object>(item.Value); 135Assert.IsType<int>(item.Value);

61Assert.IsType<ContentViewComponentResult>(actualResult); 75Assert.IsType<ViewViewComponentResult>(actualResult); 94Assert.IsType<ViewViewComponentResult>(actualResult); 111Assert.IsType<ViewViewComponentResult>(actualResult); 112Assert.IsType<ViewDataDictionary<object>>(actualResult.ViewData); 131Assert.IsType<ViewViewComponentResult>(actualResult); 132Assert.IsType<ViewDataDictionary<object>>(actualResult.ViewData); 151Assert.IsType<ViewViewComponentResult>(actualResult); 152Assert.IsType<ViewDataDictionary<object>>(actualResult.ViewData); 170Assert.IsType<ViewViewComponentResult>(actualResult); 171Assert.IsType<ViewDataDictionary<object>>(actualResult.ViewData); 189Assert.IsType<ViewViewComponentResult>(actualResult); 190Assert.IsType<ViewDataDictionary<string>>(actualResult.ViewData); 209Assert.IsType<ViewViewComponentResult>(actualResult); 210Assert.IsType<ViewDataDictionary<object>>(actualResult.ViewData);

57Assert.IsType<CopyOnWriteDictionary<string, object>>(viewData1.Data); 69Assert.IsType<CopyOnWriteDictionary<string, object>>(viewData2.Data); 96Assert.IsType<CopyOnWriteDictionary<string, object>>(viewData1.Data); 108Assert.IsType<CopyOnWriteDictionary<string, object>>(viewData2.Data); 176Assert.IsType<CopyOnWriteDictionary<string, object>>(viewData.Data);

211Assert.IsType<CopyOnWriteDictionary<string, object>>(viewData.Data); 365var model = Assert.IsType<bool>(viewData.Model); 391var model = Assert.IsType<bool>(viewData.Model);

46var generatedEndpoint = Assert.IsType<RouteEndpoint>(builder.DataSources.First().Endpoints.First());

248return Assert.IsType<RouteEndpointDataSource>(Assert.Single(endpointRouteBuilder.DataSources));

216Assert.IsType<OpenApiDocumentService>(documentProvider); 241Assert.IsType<OpenApiDocumentService>(documentProvider); 268Assert.IsType<OpenApiDocument>(document);

131Assert.IsType<OpenApiSchema>(schema); 197Assert.IsType<OpenApiSchemaReference>(responseSchema); 232Assert.IsType<OpenApiSchemaReference>(schema); 240Assert.IsType<OpenApiSchemaReference>(responseSchema);

365var schema = Assert.IsType<OpenApiSchema>(parameter.Schema); 395var schema = Assert.IsType<OpenApiSchema>(parameter.Schema); 424var schema = Assert.IsType<OpenApiSchema>(parameter.Schema); 746Assert.IsType<JsonArray>(param.Schema.Default); 773Assert.IsType<JsonObject>(param.Schema.Default);

49var targetSchema = Assert.IsType<OpenApiSchema>(schema.Value);

24Assert.IsType<DelegateOpenApiDocumentTransformer>(insertedTransformer); 25Assert.IsType<OpenApiOptions>(result); 43Assert.IsType<OpenApiOptions>(result); 59Assert.IsType<TypeBasedOpenApiDocumentTransformer>(insertedTransformer); 60Assert.IsType<OpenApiOptions>(result); 81Assert.IsType<DelegateOpenApiOperationTransformer>(insertedTransformer); 82Assert.IsType<OpenApiOptions>(result); 100Assert.IsType<OpenApiOptions>(result); 116Assert.IsType<TypeBasedOpenApiOperationTransformer>(insertedTransformer); 117Assert.IsType<OpenApiOptions>(result); 138Assert.IsType<DelegateOpenApiSchemaTransformer>(insertedTransformer); 139Assert.IsType<OpenApiOptions>(result); 157Assert.IsType<OpenApiOptions>(result); 173Assert.IsType<TypeBasedOpenApiSchemaTransformer>(insertedTransformer); 174Assert.IsType<OpenApiOptions>(result);

118Assert.Equal("some-content", Assert.IsType<string>(items[0])); 119Assert.Equal("hello", Assert.IsType<HtmlString>(items[1]).Value); 120Assert.Equal("Test", Assert.IsType<string>(items[2])); 144Assert.Equal("some-content", Assert.IsType<string>(items[0])); 145Assert.Equal("hello", Assert.IsType<HtmlString>(items[1]).Value); 146Assert.Equal("Test", Assert.IsType<string>(items[2])); 168Assert.Equal("some-content", Assert.IsType<string>(items[0])); 169Assert.Equal("hello", Assert.IsType<HtmlString>(items[1]).Value); 170Assert.Equal("Test", Assert.IsType<string>(items[2])); 196Assert.Equal("some-content", Assert.IsType<string>(items[0])); 197Assert.Equal("hello", Assert.IsType<HtmlString>(items[1]).Value); 198Assert.Equal("Test", Assert.IsType<string>(items[2]));

22Assert.IsType<BrotliDecompressionProvider>(brotliProvider); 25Assert.IsType<DeflateDecompressionProvider>(deflateProvider); 28Assert.IsType<GZipDecompressionProvider>(gzipProvider);

35var routeEndpoint = Assert.IsType<RouteEndpoint>(endpoint); 67var routeEndpoint = Assert.IsType<RouteEndpoint>(endpoint); 101var routeEndpoint = Assert.IsType<RouteEndpoint>(endpoint); 251var routeEndpoint = Assert.IsType<RouteEndpoint>(endpoint); 296var routeEndpoint = Assert.IsType<RouteEndpoint>(endpoint); 382var prefixedEndpoint = Assert.IsType<RouteEndpoint>(Assert.Single(groupDataSource.Endpoints));

20=> Assert.IsType<ExcludeFromDescriptionAttribute>(Assert.Single(builder.Metadata)); 33var tags = Assert.IsType<TagsAttribute>(Assert.Single(builder.Metadata)); 51var metadata = Assert.IsType<ProducesResponseTypeMetadata>(Assert.Single(testBuilder.Metadata)); 65var metadata = Assert.IsType<ProducesResponseTypeMetadata>(Assert.Single(testBuilder.Metadata)); 79var metadata = Assert.IsType<ProducesResponseTypeMetadata>(Assert.Single(builder.Metadata)); 97var metadata = Assert.IsType<ProducesResponseTypeMetadata>(Assert.Single(builder.Metadata)); 114var metadata = Assert.IsType<AcceptsMetadata>(Assert.Single(testBuilder.Metadata)); 127var metadata = Assert.IsType<EndpointDescriptionAttribute>(Assert.Single(builder.Metadata)); 137var metadata = Assert.IsType<EndpointSummaryAttribute>(Assert.Single(builder.Metadata));

256Assert.IsType<EmptyHttpResult>(response); 378Assert.IsType<Attribute1>(endpointBuilder1.Metadata[0]); 379Assert.IsType<Attribute2>(endpointBuilder1.Metadata[1]);

22return Assert.IsType<RouteEndpointDataSource>(Assert.Single(endpointRouteBuilder.DataSources)); 892var routeEndpoint = Assert.IsType<RouteEndpoint>(endpoint);

27var hostMetadata = Assert.IsType<HostAttribute>(Assert.Single(endpointModel.Metadata));

166var token = Assert.IsType<CancellationChangeToken>(changeToken1); 179token = Assert.IsType<CancellationChangeToken>(changeToken2); 193token = Assert.IsType<CancellationChangeToken>(changeToken3); 206var token = Assert.IsType<CancellationChangeToken>(changeToken1); 218token = Assert.IsType<CancellationChangeToken>(changeToken2); 229token = Assert.IsType<CancellationChangeToken>(changeToken3); 242var token = Assert.IsType<CancellationChangeToken>(changeToken1); 253token = Assert.IsType<CancellationChangeToken>(changeToken2); 265token = Assert.IsType<CancellationChangeToken>(changeToken3); 309var resolvedEndpoint = Assert.IsType<RouteEndpoint>(Assert.Single(groupedEndpoints)); 358var endpoint = Assert.IsType<RouteEndpoint>(endpoint1); 365var endpoint = Assert.IsType<RouteEndpoint>(endpoint2); 413var endpoint = Assert.IsType<RouteEndpoint>(endpoint1); 420var endpoint = Assert.IsType<RouteEndpoint>(endpoint2); 479var endpoint = Assert.IsType<RouteEndpoint>(endpoint1); 486var endpoint = Assert.IsType<RouteEndpoint>(endpoint2);

31Assert.IsType<RequiredRouteConstraint>(constraint); 41Assert.IsType<IntRouteConstraint>(constraint); 63Assert.IsType<AlphaRouteConstraint>(constraint); 73Assert.IsType<RegexInlineRouteConstraint>(constraint); 84Assert.IsType<RegexInlineRouteConstraint>(constraint); 94Assert.IsType<BoolRouteConstraint>(constraint); 111Assert.IsType<DateTimeRouteConstraint>(constraint); 121Assert.IsType<DecimalRouteConstraint>(constraint); 131Assert.IsType<DoubleRouteConstraint>(constraint); 141Assert.IsType<FloatRouteConstraint>(constraint); 151Assert.IsType<GuidRouteConstraint>(constraint); 161Assert.IsType<IntRouteConstraint>(constraint); 171Assert.IsType<LengthRouteConstraint>(constraint); 183var lengthConstraint = Assert.IsType<LengthRouteConstraint>(constraint); 195Assert.IsType<LongRouteConstraint>(constraint); 205Assert.IsType<MaxRouteConstraint>(constraint); 216Assert.IsType<MaxLengthRouteConstraint>(constraint); 227Assert.IsType<MinRouteConstraint>(constraint); 238Assert.IsType<MinLengthRouteConstraint>(constraint); 249Assert.IsType<RangeRouteConstraint>(constraint); 267Assert.IsType<CustomRouteConstraint>(constraint); 282Assert.IsType<CustomRouteConstraint>(constraint); 307Assert.IsType<CustomRouteConstraint>(constraint);

68Assert.IsType<IntRouteConstraint>(parameterPolicy); 87var optionalConstraint = Assert.IsType<OptionalRouteConstraint>(parameterPolicy); 88Assert.IsType<IntRouteConstraint>(optionalConstraint.InnerConstraint); 107Assert.IsType<IntRouteConstraint>(parameterPolicy); 126var optionalConstraint = Assert.IsType<OptionalRouteConstraint>(parameterPolicy); 127Assert.IsType<IntRouteConstraint>(optionalConstraint.InnerConstraint); 146Assert.IsType<CustomParameterPolicy>(parameterPolicy); 159Assert.IsType<IntRouteConstraint>(parameterPolicy); 172var constraint = Assert.IsType<RangeRouteConstraint>(parameterPolicy); 187var optionalConstraint = Assert.IsType<OptionalRouteConstraint>(parameterPolicy); 188Assert.IsType<IntRouteConstraint>(optionalConstraint.InnerConstraint); 207Assert.IsType<CustomParameterPolicy>(parameterPolicy); 226var constraint = Assert.IsType<CustomParameterPolicyWithArguments>(parameterPolicy); 247var constraint = Assert.IsType<CustomParameterPolicyWithMultipleArguments>(parameterPolicy); 270var constraint = Assert.IsType<CustomParameterPolicyWithOnlyServiceArguments>(parameterPolicy); 291var constraint = Assert.IsType<CustomParameterPolicyWithMultipleCtors>(parameterPolicy); 312var constraint = Assert.IsType<CustomParameterPolicyWithMultipleCtorsInAscendingOrder>(parameterPolicy); 355var constraint = Assert.IsType<RegexInlineRouteConstraintWithService>(parameterPolicy); 376var inner = Assert.IsType<InvalidOperationException>(exception.InnerException); 396Assert.IsType<CustomParameterPolicy>(parameterPolicy);

47var formOptions = Assert.IsType<FormFeature>(formFeature).FormOptions; 81var formOptions = Assert.IsType<FormFeature>(formFeature).FormOptions; 119var formOptions = Assert.IsType<FormFeature>(formFeature).FormOptions; 155var formOptions = Assert.IsType<FormFeature>(formFeature).FormOptions;

361e => Assert.Equal("gzip", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue), 362e => Assert.Equal("br", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue), 365Assert.Equal("identity", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue); 371Assert.Equal("", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue); 396Assert.Equal("gzip", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue); 403Assert.Equal("br", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue); 410Assert.Equal("identity", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue); 416Assert.Equal("", Assert.IsType<NegotiationMatcherPolicy<ContentEncodingMetadata>.NegotiationEdgeKey>(e.State).NegotiationValue);

23var inner = Assert.IsType<TestMatcher>(matcher.CurrentMatcher); 48var inner = Assert.IsType<TestMatcher>(matcher.CurrentMatcher); 75var inner = Assert.IsType<TestMatcher>(matcher.CurrentMatcher); 92var inner = Assert.IsType<TestMatcher>(matcher.CurrentMatcher); 114var inner = Assert.IsType<TestMatcher>(matcher.CurrentMatcher); 136var inner = Assert.IsType<TestMatcher>(matcher.CurrentMatcher);

2648Assert.IsType<TestMetadata1MatcherPolicy>(a.NodeBuilder); 2655Assert.IsType<TestMetadata2MatcherPolicy>(test1_0.NodeBuilder); 2693Assert.IsType<TestMetadata1MatcherPolicy>(a.NodeBuilder); 2701Assert.IsType<TestMetadata2MatcherPolicy>(test1_0.NodeBuilder); 2713Assert.IsType<TestMetadata2MatcherPolicy>(test1_1.NodeBuilder); 2757Assert.IsType<TestMetadata2MatcherPolicy>(a.NodeBuilder); 2801Assert.IsType<TestMetadata1MatcherPolicy>(a.NodeBuilder); 2845Assert.IsType<TestNonRoutePatternMatcherPolicy>(a.NodeBuilder);

58return Assert.IsType<DataSourceDependentMatcher>(factory.CreateMatcher(dataSource));

156c => Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy), 160c => Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy)); 169c => Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy), 177c => Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy)); 206c => Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy)); 213c => Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy)); 242c => Assert.Equal("foo", Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy).Constraint.ToString()), 243c => Assert.Equal("bar", Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy).Constraint.ToString()), 244c => Assert.Equal("^(baz)$", Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy).Constraint.ToString())); 280c => Assert.Equal("^(fizz)$", Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy).Constraint.ToString())); 287c => Assert.Equal("foo", Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy).Constraint.ToString()), 288c => Assert.Equal("bar", Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy).Constraint.ToString()), 289c => Assert.Equal("^(baz)$", Assert.IsType<RegexRouteConstraint>(c.ParameterPolicy).Constraint.ToString()), 374var regex = Assert.IsType<RegexRouteConstraint>(Assert.Single(kvp.Value).ParameterPolicy); 741var part = Assert.IsType<RoutePatternLiteralPart>(Assert.Single(segment.Parts));

29Assert.IsType<RegexRouteConstraint>(Assert.Single(result).Value); 69Assert.IsType<IntRouteConstraint>(kvp.Value); 112Assert.IsType<OptionalRouteConstraint>(Assert.Single(result).Value); 125Assert.IsType<OptionalRouteConstraint>(Assert.Single(result).Value); 140Assert.IsType<OptionalRouteConstraint>(Assert.Single(result).Value); 142var compositeConstraint = Assert.IsType<CompositeRouteConstraint>(optionalConstraint.InnerConstraint);

40var endpoint = Assert.IsType<RouteEndpoint>(builder.Build()); 62var endpoint = Assert.IsType<RouteEndpoint>(builder.Build()); 92var endpoint = Assert.IsType<RouteEndpoint>(builder.Build()); 112var endpoint = Assert.IsType<RouteEndpoint>(builder.Build()); 133var endpoint = Assert.IsType<RouteEndpoint>(builder.Build()); 167var endpoint = Assert.IsType<RouteEndpoint>(builder.Build());

193Assert.IsType<OptionalRouteConstraint>(route.Constraints["id"]); 235Assert.IsType<RegexInlineRouteConstraint>(route.Constraints["ssn"]); 277Assert.IsType<OptionalRouteConstraint>(route.Constraints["id"]); 320Assert.IsType<OptionalRouteConstraint>(route.Constraints["id"]); 322Assert.IsType<CompositeRouteConstraint>(innerConstraint); 369Assert.IsType<OptionalRouteConstraint>(route.Constraints["id"]); 480Assert.Equal("Home", Assert.IsType<string>(value.Value)); 1643Assert.IsType<RegexRouteConstraint>(constraints["controller"]); 1663Assert.IsType<CompositeRouteConstraint>(constraint); 1664Assert.IsType<RegexRouteConstraint>(constraint.Constraints.ElementAt(0)); 1665Assert.IsType<IntRouteConstraint>(constraint.Constraints.ElementAt(1)); 1683Assert.IsType<IntRouteConstraint>(constraints["id"]);

27var actual = Assert.IsType<RouteEndpoint>(namedMatch.Match.Entry.Data); 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)); 88var actual = Assert.IsType<RouteEndpoint>(match.Entry.Data); 131actual = Assert.IsType<RouteEndpoint>(m.Entry.Data); 136actual = Assert.IsType<RouteEndpoint>(m.Entry.Data); 141actual = Assert.IsType<RouteEndpoint>(m.Entry.Data); 146actual = Assert.IsType<RouteEndpoint>(m.Entry.Data);

24Assert.IsType<ArgumentNullException>(ex); 38Assert.IsType<ArgumentNullException>(ex); 50Assert.IsType<ArgumentNullException>(ex);

37Assert.IsType<RoutePatternParameterPart>(routePatternPathSegment.Parts[0]); 39Assert.IsType<RoutePatternLiteralPart>(routePatternPathSegment.Parts[1]); 41Assert.IsType<RoutePatternSeparatorPart>(routePatternPathSegment.Parts[2]); 43Assert.IsType<RoutePatternParameterPart>(routePatternPathSegment.Parts[3]);

177var qex = Assert.IsType<QuicException>(ex.InnerException); 210var qex = Assert.IsType<QuicException>(ex.InnerException?.InnerException?.InnerException); 236var qex = Assert.IsType<QuicException>(ex.InnerException?.InnerException?.InnerException); 257var qex = Assert.IsType<QuicException>(ex.InnerException);

83Assert.IsType<MemoryStream>(requestInfo.Body);

58Assert.IsType<AnyIPListenOptions>(listenOptions); 59Assert.IsType<IPEndPoint>(listenOptions.EndPoint); 69Assert.IsType<LocalhostListenOptions>(listenOptions); 70Assert.IsType<IPEndPoint>(listenOptions.EndPoint); 87Assert.IsType<LocalhostListenOptions>(listenOptions); 88Assert.IsType<IPEndPoint>(listenOptions.EndPoint); 105Assert.IsType<IPEndPoint>(listenOptions.EndPoint); 115Assert.IsType<NamedPipeEndPoint>(listenOptions.EndPoint); 126Assert.IsType<NamedPipeEndPoint>(listenOptions.EndPoint); 137Assert.IsType<NamedPipeEndPoint>(listenOptions.EndPoint); 148Assert.IsType<UnixDomainSocketEndPoint>(listenOptions.EndPoint); 159Assert.IsType<UnixDomainSocketEndPoint>(listenOptions.EndPoint); 173Assert.IsType<IPEndPoint>(listenOptions.EndPoint);

68Assert.IsType<InvalidOperationException>(critical.Exception);

72Assert.IsType<UriEndPoint>(listenOptions.EndPoint);

380Assert.IsType<OverflowException>(ex.InnerException);

21Assert.IsType<PinnedBlockMemoryPool>(pool); 59var pool = Assert.IsType<PinnedBlockMemoryPool>(factory.Create()); 60var pool2 = Assert.IsType<PinnedBlockMemoryPool>(factory.Create());

903Assert.IsType<HuffmanDecodingException>(exception.InnerException);

74t => Assert.IsType<SocketTransportFactory>(t), 75t => Assert.IsType<NamedPipeTransportFactory>(t)); 80t => Assert.IsType<SocketTransportFactory>(t)); 117var server = Assert.IsType<KestrelServerImpl>(hostBuilder.Build().Services.GetService<IServer>()); 120Assert.IsType<KestrelMetrics>(server.ServiceContext.Metrics); 150var memoryPoolFactory = Assert.IsType<PinnedBlockMemoryPoolFactory>(host.Services.GetRequiredService<IMemoryPoolFactory<byte>>()); 163memoryPoolFactory = Assert.IsType<PinnedBlockMemoryPoolFactory>(host.Services.GetRequiredService<IMemoryPoolFactory<byte>>()); 196var memoryPoolFactory = Assert.IsType<PinnedBlockMemoryPoolFactory>(host.Services.GetRequiredService<IMemoryPoolFactory<byte>>()); 209memoryPoolFactory = Assert.IsType<PinnedBlockMemoryPoolFactory>(host.Services.GetRequiredService<IMemoryPoolFactory<byte>>());

139var innerEx = Assert.IsType<QuicException>(ex.InnerException); 302var innerEx = Assert.IsType<QuicException>(ex.InnerException); 325var quicConnectionContext = Assert.IsType<QuicConnectionContext>(serverConnection); 342var quicStreamContext = Assert.IsType<QuicStreamContext>(serverStream); 368var quicConnectionContext = Assert.IsType<QuicConnectionContext>(serverConnection); 385var quicStreamContext = Assert.IsType<QuicStreamContext>(serverStream); 413var quicConnectionContext = Assert.IsType<QuicConnectionContext>(serverConnection); 434var quicStreamContext = Assert.IsType<QuicStreamContext>(serverStream); 462var quicConnectionContext = Assert.IsType<QuicConnectionContext>(serverConnection); 491var quicStreamContext = Assert.IsType<QuicStreamContext>(serverStream); 520var quicConnectionContext = Assert.IsType<QuicConnectionContext>(serverConnection); 574var quicConnectionContext = Assert.IsType<QuicConnectionContext>(serverConnection); 644var quicStreamContext = Assert.IsType<QuicStreamContext>(serverStream); 699var quicStreamContext1 = Assert.IsType<QuicStreamContext>(serverStream1); 727var quicStreamContext2 = Assert.IsType<QuicStreamContext>(serverStream2); 734var quicConnectionContext = Assert.IsType<QuicConnectionContext>(serverConnection); 763Assert.IsType<QuicConnectionContext>(protocolErrorCodeFeature);

47var quicConnectionContext = Assert.IsType<QuicConnectionContext>(serverConnection); 84var quicStreamContext = Assert.IsType<QuicStreamContext>(serverStream); 94var quicConnectionContext = Assert.IsType<QuicConnectionContext>(serverConnection); 138var quicStreamContext = Assert.IsType<QuicStreamContext>(serverStream); 153var quicConnectionContext = Assert.IsType<QuicConnectionContext>(serverConnection); 211var quicStreamContext = Assert.IsType<QuicStreamContext>(serverStream); 222var quicConnectionContext = Assert.IsType<QuicConnectionContext>(serverConnection); 246var quicConnectionContext = Assert.IsType<QuicConnectionContext>(serverConnection); 284var quicStreamContext = Assert.IsType<QuicStreamContext>(serverStream); 320var quicStreamContext = Assert.IsType<QuicStreamContext>(serverStream); 359var quicStreamContext = Assert.IsType<QuicStreamContext>(serverStream); 429var quicStreamContext = Assert.IsType<QuicStreamContext>(serverStream); 473var quicStreamContext = Assert.IsType<QuicStreamContext>(serverStream); 554Assert.IsType<QuicStreamContext>(protocolErrorCodeFeature); 581Assert.IsType<QuicStreamContext>(protocolErrorCodeFeature);

167var quicStreamContext = Assert.IsType<QuicStreamContext>(serverStream);

138Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 155Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 172Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 199Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 219Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 236Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 253Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 283Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 297Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 314Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 328Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 345Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 359Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 392Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 413Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 434Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 454Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 484Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 504Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 523Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 542Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 562Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 605Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 622Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 639Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 664Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 684Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 704Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 724Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 745Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 789Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 807Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 825Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 872Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 892Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 912Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 937Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 962Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 987Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1127Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1145Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1163Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1176var storage = Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1206var storage = Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1236var storage = Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1266var storage = Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage); 1273storage = Assert.IsType<KeyValuePair<string, object?>[]>(dict._arrayStorage);

50var resultObject = Assert.IsType<TestObject>(result); 63var resultObject = Assert.IsType<TestObject>(result); 98var resultObject = Assert.IsType<TestObject>(result); 111var resultObject = Assert.IsType<TestObject>(result); 206Assert.IsType<TestObject>(result); 223Assert.IsType<int>(result); 373Assert.IsType<InvalidOperationException>(exception.InnerException); 406Assert.IsType<InvalidOperationException>(exception.InnerException);

903Assert.IsType<HuffmanDecodingException>(exception.InnerException);

451Assert.IsType<OperationCanceledException>(innerInnerEx);

110Assert.IsType<NewtonsoftJsonHubProtocol>(resolvedHubProtocol); 123Assert.IsType<MessagePackHubProtocol>(resolvedHubProtocol);

41var actualProtocol = Assert.IsType<NewtonsoftJsonHubProtocol>(serviceProvider.GetService<IHubProtocol>()); 42Assert.IsType<CamelCasePropertyNamesContractResolver>(actualProtocol.PayloadSerializer.ContractResolver); 56var actualProtocol = Assert.IsType<NewtonsoftJsonHubProtocol>(serviceProvider.GetService<IHubProtocol>()); 78Assert.IsType<MessagePackHubProtocol>(serviceProvider.GetService<IHubProtocol>());

367var exception = Assert.IsType<TimeoutException>(await closeTcs.Task.DefaultTimeout());

265Assert.IsType<OperationCanceledException>(closeError); 356Assert.IsType<OperationCanceledException>(closeError); 930Assert.IsType<HubException>(retryContexts[1].RetryReason); 1036Assert.IsType<OperationCanceledException>(await closedErrorTcs.Task.DefaultTimeout()); 1111Assert.IsType<OperationCanceledException>(await closedErrorTcs.Task.DefaultTimeout());

133var invocationMessage = Assert.IsType<InvocationMessage>(message); 166var streamItemMessage = Assert.IsType<StreamItemMessage>(message); 199var completionMessage = Assert.IsType<CompletionMessage>(message);

208Assert.IsType<InvocationMessage>(message); 257var bindingFailure = Assert.IsType<InvocationBindingFailureMessage>(message); 281var invocationMessage = Assert.IsType<InvocationMessage>(message); 284var dt = Assert.IsType<DateTime>(invocationMessage.Arguments[0]); 296var invocationMessage = Assert.IsType<CompletionMessage>(message); 298var dt = Assert.IsType<DateTime>(invocationMessage.Result); 308var bindingFailure = Assert.IsType<InvocationBindingFailureMessage>(message); 322var streamItemMessage = Assert.IsType<StreamItemMessage>(message); 443var completion = Assert.IsType<CompletionMessage>(message); 457completion = Assert.IsType<CompletionMessage>(message); 476var completion = Assert.IsType<CompletionMessage>(hubMessage); 492var completion = Assert.IsType<CompletionMessage>(hubMessage);

398var bindingFailure = Assert.IsType<InvocationBindingFailureMessage>(message);

40var completionMessage = Assert.IsType<CompletionMessage>(hubMessage); 69var completionMessage = Assert.IsType<CompletionMessage>(hubMessage); 223var completion = Assert.IsType<CompletionMessage>(message); 237completion = Assert.IsType<CompletionMessage>(message); 254var completion = Assert.IsType<CompletionMessage>(hubMessage); 267var completion = Assert.IsType<CompletionMessage>(hubMessage);

48var message = Assert.IsType<InvocationMessage>(await client1.ReadAsync().DefaultTimeout()); 53message = Assert.IsType<InvocationMessage>(await client2.ReadAsync().DefaultTimeout()); 81var message = Assert.IsType<InvocationMessage>(await client1.ReadAsync().DefaultTimeout()); 111var message = Assert.IsType<InvocationMessage>(await client1.ReadAsync().DefaultTimeout()); 142var message = Assert.IsType<InvocationMessage>(await client1.ReadAsync().DefaultTimeout()); 167var message = Assert.IsType<InvocationMessage>(await client.ReadAsync().DefaultTimeout()); 190var invocation = Assert.IsType<InvocationMessage>(await client1.ReadAsync().DefaultTimeout()); 217var invocation = Assert.IsType<InvocationMessage>(await client1.ReadAsync().DefaultTimeout()); 247var invocation = Assert.IsType<InvocationMessage>(await client1.ReadAsync().DefaultTimeout()); 305var invocation1 = Assert.IsType<InvocationMessage>(await client1.ReadAsync().DefaultTimeout()); 306var invocation2 = Assert.IsType<InvocationMessage>(await client2.ReadAsync().DefaultTimeout()); 359var invocation1 = Assert.IsType<InvocationMessage>(await client1.ReadAsync().DefaultTimeout());

32var message = Assert.IsType<InvocationMessage>(await client.ReadAsync().DefaultTimeout()); 486var invocation = Assert.IsType<InvocationMessage>(await client1.ReadAsync().DefaultTimeout()); 517var invocation = Assert.IsType<InvocationMessage>(await client1.ReadAsync().DefaultTimeout()); 569var invocation = Assert.IsType<InvocationMessage>(await client1.ReadAsync().DefaultTimeout()); 598var invocation2 = Assert.IsType<InvocationMessage>(await client.ReadAsync().DefaultTimeout()); 601var invocation1 = Assert.IsType<InvocationMessage>(await client.ReadAsync().DefaultTimeout()); 649var invocation = Assert.IsType<InvocationMessage>(await client1.ReadAsync().DefaultTimeout());

34var dnsEndpoint = Assert.IsType<DnsEndPoint>(endpoint);

72var message = Assert.IsType<InvocationMessage>(await client2.ReadAsync().DefaultTimeout()); 78var dict = Assert.IsType<JObject>(arg0);

165var invocation = Assert.IsType<InvocationMessage>(actualMessage);

40Assert.IsType<CustomIdProvider>(serviceProvider.GetRequiredService<IUserIdProvider>()); 41Assert.IsType<CustomHubLifetimeManager<CustomHub>>(serviceProvider.GetRequiredService<HubLifetimeManager<CustomHub>>()); 42Assert.IsType<CustomHubProtocolResolver>(serviceProvider.GetRequiredService<IHubProtocolResolver>()); 43Assert.IsType<CustomHubActivator<CustomHub>>(serviceProvider.GetRequiredService<IHubActivator<CustomHub>>()); 44Assert.IsType<CustomHubContext<CustomHub>>(serviceProvider.GetRequiredService<IHubContext<CustomHub>>()); 45Assert.IsType<CustomHubContext<CustomTHub, string>>(serviceProvider.GetRequiredService<IHubContext<CustomTHub, string>>()); 46Assert.IsType<CustomHubContext<CustomDynamicHub>>(serviceProvider.GetRequiredService<IHubContext<CustomDynamicHub>>()); 65Assert.IsType<CustomIdProvider>(serviceProvider.GetRequiredService<IUserIdProvider>()); 66Assert.IsType<CustomHubLifetimeManager<CustomHub>>(serviceProvider.GetRequiredService<HubLifetimeManager<CustomHub>>()); 67Assert.IsType<CustomHubProtocolResolver>(serviceProvider.GetRequiredService<IHubProtocolResolver>()); 68Assert.IsType<CustomHubActivator<CustomHub>>(serviceProvider.GetRequiredService<IHubActivator<CustomHub>>()); 69Assert.IsType<CustomHubContext<CustomHub>>(serviceProvider.GetRequiredService<IHubContext<CustomHub>>()); 70Assert.IsType<CustomHubContext<CustomTHub, string>>(serviceProvider.GetRequiredService<IHubContext<CustomTHub, string>>()); 71Assert.IsType<CustomHubContext<CustomDynamicHub>>(serviceProvider.GetRequiredService<IHubContext<CustomDynamicHub>>());