308Assert.Throws<FormatException>(() =>

63Assert.Throws<PlatformNotSupportedException>(() =>

52Assert.Throws<InvalidOperationException>(() => scope.Dispose());

197Assert.Throws<EndpointNotFoundException>(() => ((IChannel)serviceProxy).Open());

33var exception = Assert.Throws<InvalidOperationException>(() => 43Assert.Throws<CommunicationObjectFaultedException>(() =>

107Assert.Throws<InvalidOperationException>(() => 131Assert.Throws<InvalidOperationException>(() => 155Assert.Throws<InvalidOperationException>(() => 441Assert.Throws<CommunicationException>(() =>

28ActionNotSupportedException exception = Assert.Throws<ActionNotSupportedException>(() => 68TimeoutException exception = Assert.Throws<TimeoutException>(() => 115TimeoutException exception = Assert.Throws<TimeoutException>(() => 158FaultException<FaultDetail> exception = Assert.Throws<FaultException<FaultDetail>>(() => 193FaultException<ExceptionDetail> exception = Assert.Throws<FaultException<ExceptionDetail>>(() =>

28EndpointNotFoundException exception = Assert.Throws<EndpointNotFoundException>(() => 130CommunicationException exception = Assert.Throws<CommunicationException>(() => 160EndpointNotFoundException exception = Assert.Throws<EndpointNotFoundException>(() => 199ProtocolException exception = Assert.Throws<ProtocolException>(() => 239FaultException<FaultDetail> exception = Assert.Throws<FaultException<FaultDetail>>(() => 291FaultException<FaultDetail> exception = Assert.Throws<FaultException<FaultDetail>>(() =>

27var exception = Assert.Throws<Exception>(() =>

24FaultException<FaultDetail> exception = Assert.Throws<FaultException<FaultDetail>>(() => 58FaultException<ExceptionDetail> exception = Assert.Throws<FaultException<ExceptionDetail>>(() => 101thrownException = Assert.Throws<FaultException<int>>(() => 130var exception = Assert.Throws<FaultException<FaultDetail>>(() => 167var exception = Assert.Throws<FaultException<FaultDetail2>>(() => 204var exception = Assert.Throws<FaultException<FaultDetail>>(() =>

57Assert.Throws<ProtocolException>(() =>

276Assert.Throws<TimeoutException>(() => 332Assert.Throws<TimeoutException>(() =>

31Assert.Throws<ProtocolException>(() => { serviceProxy.ReturnContentType(testContentType); });

1519ex = Assert.Throws<InvalidOperationException>(() => context.Response.OnStarting(_ => Task.CompletedTask, null)); 2144Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("Custom你好Name", "Custom Value")); 2146Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom 你好 Value")); 2147Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom \r Value")); 2185Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("Custom你好Name", "Custom Value")); 2186Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom \r Value")); 2469Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("Custom你好Name", "Custom Value")); 2470Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("CustomName", "Custom 你好 Value")); 2471Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("CustomName", "Custom \r Value")); 2512Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("Custom你好Name", "Custom Value")); 2513Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("CustomName", "Custom \r Value")); 5386var ex = Assert.Throws<InvalidOperationException>(() => context.Response.BodyWriter.Complete());

864Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("Custom你好Name", "Custom Value")); 866Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom 你好 Value")); 867Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom \r Value")); 898Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("Custom你好Name", "Custom Value")); 899Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom \r Value")); 1015Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("Custom你好Name", "Custom Value")); 1016Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("CustomName", "Custom 你好 Value")); 1017Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("CustomName", "Custom \r Value")); 1046Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("Custom你好Name", "Custom Value")); 1047Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("CustomName", "Custom \r Value")); 1664var ex = Assert.Throws<InvalidOperationException>(() => context.Response.BodyWriter.Complete());

1701var ioEx2 = Assert.Throws<InvalidOperationException>(() => context.Request.Body.CopyTo(Stream.Null)); 1794var ioEx2 = Assert.Throws<InvalidOperationException>(() => context.Request.Body.CopyTo(Stream.Null));

23Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("Custom你好Name", "Custom Value")); 26Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom 你好 Value")); 27Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom \r Value")); 54Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("Custom你好Name", "Custom Value")); 55Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom \r Value"));

83ex = Assert.Throws<InvalidOperationException>(() => context.Response.OnStarting(_ => Task.CompletedTask, null)); 117ex = Assert.Throws<InvalidOperationException>(() => context.Response.OnStarting(_ => Task.CompletedTask, null)); 1174completeEx = Assert.Throws<InvalidOperationException>(() => httpContext.Response.BodyWriter.Complete()); 3612var ioEx = Assert.Throws<InvalidOperationException>(() => context.Response.Body.Write(Encoding.ASCII.GetBytes("What!?"), 0, 6)); 3708var ioEx = Assert.Throws<InvalidOperationException>(() => context.Response.Body.Write(Encoding.ASCII.GetBytes("What!?"), 0, 6)); 3771Assert.Throws<ArgumentOutOfRangeException>(() => response.BodyWriter.Advance(-1)); 3802Assert.Throws<ArgumentOutOfRangeException>(() => response.BodyWriter.Advance(-1)); 3832Assert.Throws<InvalidOperationException>(() => response.BodyWriter.Advance(1)); 4261Assert.Throws<InvalidOperationException>(() => httpContext.Response.BodyWriter.Advance(1)); 4432Assert.Throws<InvalidOperationException>(() => httpContext.Response.BodyWriter.Advance(1));

393Assert.Throws<InvalidOperationException>(host.Run); 426Assert.Throws<InvalidOperationException>(host.Run);

89Assert.Throws<ArgumentNullException>(() => a.Initialize(null!));

121var exception = Assert.Throws<InvalidOperationException>(

71Assert.Throws<InvalidOperationException>(() => _context.Set(value));

16Assert.Throws<ArgumentNullException>(() => settings.Validate()); 28Assert.Throws<ArgumentNullException>(() => settings.Validate());

52var ex = Assert.Throws<InvalidOperationException>(() =>

244var ex = Assert.Throws<InvalidOperationException>(() => 492var ex = Assert.Throws<NotSupportedException>(rootComponent.TriggerRender);

28var ex = Assert.Throws<InvalidOperationException>(() => component.TriggerRender());

12Assert.Throws<NotSupportedException>(writer.Flush);

33var ex = Assert.Throws<ArgumentOutOfRangeException>(() => jsRuntime.TestReceiveByteArray(id: 0, data)); 73var ex = Assert.Throws<ArgumentOutOfRangeException>(() => jsRuntime.TestReceiveByteArray(5, new byte[] { 0 })); 85var ex = Assert.Throws<ArgumentOutOfRangeException>(() => jsRuntime.TestReceiveByteArray(1, new byte[5000]));

613var ex = Assert.Throws<InvalidOperationException>(() => renderer.GetOrCreateWebRootComponentManager().RemoveRootComponent(1));

84var ex = Assert.Throws<JsonException>(() => 103var ex = Assert.Throws<JsonException>(() =>

325var ex = Assert.Throws<InvalidOperationException>(() => component.TriggerRender()); 350var ex = Assert.Throws<InvalidOperationException>(() => component.TriggerRender()); 384var ex = Assert.Throws<InvalidOperationException>(nestedComponent.AttemptIllegalAccessToLastParameterView);

44var ex = Assert.Throws<InvalidOperationException>(() => 57var ex = Assert.Throws<InvalidOperationException>(() => 73var ex = Assert.Throws<InvalidOperationException>(() =>

14var ex = Assert.Throws<InvalidOperationException>(() => 35var ex = Assert.Throws<InvalidOperationException>(

59var ex = Assert.Throws<ArgumentException>(() => 77var ex = Assert.Throws<ArgumentException>(() =>

159var ex = Assert.Throws<InvalidOperationException>(() => parameters.SetParameterProperties(target)); 179var ex = Assert.Throws<InvalidOperationException>( 201var ex = Assert.Throws<InvalidOperationException>( 238var ex = Assert.Throws<InvalidOperationException>(() => parameters.SetParameterProperties(target)); 257var ex = Assert.Throws<InvalidOperationException>(() => parameters.SetParameterProperties(target)); 276var ex = Assert.Throws<InvalidOperationException>(() => parameters.SetParameterProperties(target)); 381var ex = Assert.Throws<InvalidOperationException>(() => parameters.SetParameterProperties(target)); 405var ex = Assert.Throws<InvalidOperationException>(() => parameters.SetParameterProperties(target)); 424var ex = Assert.Throws<InvalidOperationException>(() => parameters.SetParameterProperties(target)); 445var ex = Assert.Throws<InvalidOperationException>(() => parameters.SetParameterProperties(target)); 491var ex = Assert.Throws<InvalidOperationException>(() => parameters.SetParameterProperties(target)); 512var ex = Assert.Throws<InvalidOperationException>( 533var ex = Assert.Throws<InvalidOperationException>( 551var ex = Assert.Throws<InvalidOperationException>(() => 574var ex = Assert.Throws<InvalidOperationException>(() =>

232Assert.Throws<InvalidCastException>(() => 338Assert.Throws<InvalidOperationException>(() => parameterView.SetParameterProperties(new object()));

41Assert.Throws<InvalidOperationException>(() => applicationState.InitializeExistingState(existingState)); 110Assert.Throws<ArgumentException>(() => applicationState.PersistAsJson("MyState", myState));

2924var ex = Assert.Throws<InvalidOperationException>(component.TriggerRender); 4430var ex = Assert.Throws<InvalidOperationException>( 4460Assert.Throws<InvalidOperationException>(() => parameterView.SetParameterProperties(new object())); 4828var ex = Assert.Throws<ArgumentException>(() => 4854var ex = Assert.Throws<ArgumentException>(() => 4883var ex = Assert.Throws<InvalidOperationException>(() => 5043var ex = Assert.Throws<NotSupportedException>(() => component.TriggerRender()); 5061var ex = Assert.Throws<NotSupportedException>(component.TriggerRender);

318Assert.Throws<InvalidTimeZoneException>(() => context.Send((_) =>

435Assert.Throws<InvalidOperationException>(() => 448Assert.Throws<InvalidOperationException>(() => 461Assert.Throws<InvalidOperationException>(() => 474Assert.Throws<InvalidOperationException>(() => 489Assert.Throws<InvalidOperationException>(() => 504Assert.Throws<InvalidOperationException>(() => 519Assert.Throws<InvalidOperationException>(() => 533Assert.Throws<InvalidOperationException>(() => 547Assert.Throws<InvalidOperationException>(() => 562Assert.Throws<InvalidOperationException>(() => 577Assert.Throws<InvalidOperationException>(() => 592Assert.Throws<InvalidOperationException>(() => 738Assert.Throws<InvalidOperationException>(() => 751Assert.Throws<InvalidOperationException>(() => 765Assert.Throws<InvalidOperationException>(() => 827Assert.Throws<InvalidOperationException>(() => 840Assert.Throws<InvalidOperationException>(() => 854Assert.Throws<InvalidOperationException>(() => 1747var ex = Assert.Throws<InvalidOperationException>(() => 1763var ex = Assert.Throws<InvalidOperationException>(() => 2049var ex = Assert.Throws<InvalidOperationException>(() => builder.AssertTreeIsValid(component)); 2064var ex = Assert.Throws<InvalidOperationException>(() => builder.AssertTreeIsValid(component)); 2079var ex = Assert.Throws<InvalidOperationException>(() => builder.AssertTreeIsValid(component)); 2136var ex = Assert.Throws<InvalidOperationException>(() => 2175var ex = Assert.Throws<InvalidOperationException>(() => 2211var ex = Assert.Throws<InvalidOperationException>(() => 2226var ex = Assert.Throws<ArgumentNullException>(() => 2241var ex = Assert.Throws<ArgumentNullException>(() => 2256var ex = Assert.Throws<ArgumentException>(() => 2272var ex = Assert.Throws<InvalidOperationException>(() =>

35var ex = Assert.Throws<InvalidOperationException>(() =>

96var ex = Assert.Throws<InvalidOperationException>(() => 112var ex = Assert.Throws<ArgumentException>(() =>

21var ex = Assert.Throws<InvalidOperationException>(() => rootComponent.TriggerRender());

91var exception = Assert.Throws<InvalidOperationException>(() => _renderer.RenderRootComponent(id)); 106var exception = Assert.Throws<InvalidOperationException>(() => _renderer.RenderRootComponent(id)); 129var exception = Assert.Throws<InvalidOperationException>(testComponent.TriggerRender);

42var ex = Assert.Throws<InvalidOperationException>(() => htmlContent.WriteHtmlTo(new StringWriter())); 935var ex = Assert.Throws<InvalidTimeZoneException>(() =>

40var ex = Assert.Throws<InvalidOperationException>(() => cultureProvider.ThrowIfCultureChangeIsUnsupported());

143Assert.Throws<InvalidOperationException>(() => stack.OnExit()); 149Assert.Throws<InvalidOperationException>(() => stack.OnExit());

331Assert.Throws<InvalidOperationException>(() => context.Response.Cookies.Append("Test", "Value"));

338Assert.Throws<NotImplementedException>(() => context.Response.Cookies.Delete("A")); 339Assert.Throws<NotImplementedException>(() => context.Response.Cookies.Delete("A", new CookieOptions())); 340Assert.Throws<NotImplementedException>(() => context.Response.Cookies.Append("A", "A")); 341Assert.Throws<NotImplementedException>(() => context.Response.Cookies.Append("A", "A", new CookieOptions()));

48var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>

30var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>

20return Assert.Throws<CryptographicException>(testCode);

20return Assert.Throws<CryptographicException>(testCode);

250var ex = Assert.Throws<CryptographicException>(() => 278var ex = Assert.Throws<CryptographicException>(() => 292var ex = Assert.Throws<CryptographicException>(() =>

20return Assert.Throws<CryptographicException>(testCode);

52Assert.Throws<CryptographicException>(() => 61Assert.Throws<CryptographicException>(() => 69Assert.Throws<CryptographicException>(() => 76Assert.Throws<CryptographicException>(() =>

46Assert.Throws<CryptographicException>(() => 55Assert.Throws<CryptographicException>(() => 63Assert.Throws<CryptographicException>(() => 70Assert.Throws<CryptographicException>(() =>

168Assert.Throws<InvalidOperationException>(() => repository.StoreElement(xElement, friendlyName: null));

43Assert.Throws<EncoderFallbackException>(() =>

47Assert.Throws<CryptographicException>(() => 56Assert.Throws<CryptographicException>(() => 64Assert.Throws<CryptographicException>(() => 71Assert.Throws<CryptographicException>(() =>

218Assert.Throws<ObjectDisposedException>( 259Assert.Throws<ObjectDisposedException>(

102Assert.Throws<InvalidOperationException>(() => repository.StoreElement(xElement, friendlyName: null));

20return Assert.Throws<CryptographicException>(testCode);

38var ex = Assert.Throws<InvalidOperationException>(() => host.Start());

33var ex = Assert.Throws<InvalidOperationException>(() => host.Start());

526var exception = Assert.Throws<InvalidOperationException>(() => host.Start());

26var ex = Assert.Throws<InvalidOperationException>(() => action.Invoke(applicationBuilder));

514Assert.Throws<InvalidOperationException>(() => startup.ConfigureDelegate(app)); 543Assert.Throws<Exception>(() => startup.ConfigureDelegate(app));

233Assert.Throws<InvalidOperationException>(() => host.Start()); 261Assert.Throws<InvalidOperationException>(() => host.Start()); 714var ex = Assert.Throws<InvalidOperationException>(() => 1012var exception = Assert.Throws<NotSupportedException>(() => 1033var exception = Assert.Throws<NotSupportedException>(() => 1251Assert.Throws<InvalidOperationException>(() => host.Start());

13Assert.Throws<NotSupportedException>(() => context.Add("string")); 14Assert.Throws<NotSupportedException>(() => context.Insert(0, "string")); 15Assert.Throws<NotSupportedException>(() => context.RemoveAt(0)); 17Assert.Throws<NotSupportedException>(() => context.Clear());

352var exception = Assert.Throws<InvalidOperationException>(() =>

21Assert.Throws<ArgumentNullException>(nullPredicate); 22Assert.Throws<ArgumentNullException>(nullConfiguration);

31Assert.Throws<InvalidOperationException>(() => context.Response.Clear());

192Assert.Throws<ArgumentNullException>(() => UriHelper.FromAbsolute(null, out resScheme, out resHost, out resPath, out resQuery, out resFragment));

96Assert.Throws<InvalidOperationException>(() => headers.Add(new KeyValuePair<string, StringValues>("header1", "value1"))); 97Assert.Throws<InvalidOperationException>(() => headers.Add("header1", "value1")); 98Assert.Throws<InvalidOperationException>(() => headers.Clear());

35Assert.Throws<NotSupportedException>(() => stream.SetLength(0)); 42Assert.Throws<NotSupportedException>(() => stream.Write(new byte[1], 0, 1)); 49Assert.Throws<NotSupportedException>(() => stream.WriteByte(0));

270Assert.Throws<ArgumentException>(() => cookies.Append(key, "1"));

24Assert.Throws<ArgumentNullException>(() => 33Assert.Throws<ArgumentNullException>(() =>

29var ex = Assert.Throws<InvalidOperationException>(() => 42var ex = Assert.Throws<InvalidOperationException>(() =>

119var equalException = Assert.Throws<EqualException>( 207var equalException = Assert.Throws<EqualException>(

21var exception = Assert.Throws<JsonPatchException>(() => 44var exception = Assert.Throws<JsonPatchException>(() => 67var exception = Assert.Throws<JsonPatchException>(() => 91var exception = Assert.Throws<JsonPatchException>(() => 115var exception = Assert.Throws<JsonPatchException>(() => 156var exception = Assert.Throws<JsonPatchException>(() =>

168var exception = Assert.Throws<JsonPatchException>(() =>

48var exception = Assert.Throws<JsonPatchException>(() => { patchDocument.ApplyTo(targetObject); }); 160var exception = Assert.Throws<JsonPatchException>(() => 248var exception = Assert.Throws<JsonPatchException>(() => { patchDocument.ApplyTo(targetObject); });

164var ex = Assert.Throws<JsonPatchException>(() => document.ApplyTo(target));

36Assert.Throws<JsonPatchException>(() =>

97var exception = Assert.Throws<InvalidOperationException>(() =>

41Assert.Throws<JsonPatchException>(() => patch.ApplyTo(model));

23var exception = Assert.Throws<JsonPatchException>(() => 41var exception = Assert.Throws<JsonPatchException>(() => 174var exception = Assert.Throws<JsonException>(() => 191var exception = Assert.Throws<JsonException>(() => 231Assert.Throws<JsonPatchException>(() =>

21var exception = Assert.Throws<JsonPatchException>(() => 45var exception = Assert.Throws<JsonPatchException>(() => 68var exception = Assert.Throws<JsonPatchException>(() => 91var exception = Assert.Throws<JsonPatchException>(() => 115var exception = Assert.Throws<JsonPatchException>(() => 139var exception = Assert.Throws<JsonPatchException>(() => 180var exception = Assert.Throws<JsonPatchException>(() =>

168var exception = Assert.Throws<JsonPatchException>(() =>

60var exception = Assert.Throws<JsonPatchException>(() => 160var exception = Assert.Throws<JsonPatchException>(() => 225var exception = Assert.Throws<JsonPatchException>(() =>

147var exception = Assert.Throws<JsonPatchException>(() => 168var exception = Assert.Throws<JsonPatchException>(() => 272var exception = Assert.Throws<JsonPatchException>(() => 312var exception = Assert.Throws<JsonPatchException>(() => 354var exception = Assert.Throws<JsonPatchException>(() =>

48var exception = Assert.Throws<JsonPatchException>(() => { patchDocument.ApplyTo(targetObject); }); 160var exception = Assert.Throws<JsonPatchException>(() => 248var exception = Assert.Throws<JsonPatchException>(() => { patchDocument.ApplyTo(targetObject); });

164var ex = Assert.Throws<JsonPatchException>(() => document.ApplyTo(target));

36Assert.Throws<JsonPatchException>(() =>

97var exception = Assert.Throws<InvalidOperationException>(() =>

43Assert.Throws<JsonPatchException>(() => patch.ApplyTo(model));

19var exception = Assert.Throws<JsonPatchException>(() => 37var exception = Assert.Throws<JsonPatchException>(() => 135var exception = Assert.Throws<JsonSerializationException>(() => 152var exception = Assert.Throws<JsonSerializationException>(() =>

193var exception = Assert.Throws<InvalidOperationException>(() => source.MarkFieldSkipped("key")); 252var exception = Assert.Throws<InvalidOperationException>(() => source.MarkFieldValid("key")); 1687var invalidException = Assert.Throws<InvalidOperationException>(() => dictionary.SetModelValue(key, string.Empty, string.Empty)); 1705var exception = Assert.Throws<InvalidOperationException>(() => source.MarkFieldValid(key)); 1723var exception = Assert.Throws<InvalidOperationException>(() => source.MarkFieldSkipped(key));

36var ex = Assert.Throws<InvalidOperationException>(() => provider.OnProvidersExecuting(context));

170var ex = Assert.Throws<InvalidOperationException>( 197var ex = Assert.Throws<InvalidOperationException>(

437var ex = Assert.Throws<InvalidOperationException>(() => { provider.GetDescriptors(); }); 761var ex = Assert.Throws<InvalidOperationException>(() => { provider.GetDescriptors(); }); 882var ex = Assert.Throws<InvalidOperationException>(() => { provider.GetDescriptors(); });

67var ex = Assert.Throws<InvalidOperationException>(() => convention.InferParameterBindingSources(action)); 86var ex = Assert.Throws<InvalidOperationException>(() => convention.InferParameterBindingSources(action)); 105var ex = Assert.Throws<InvalidOperationException>(() => convention.InferParameterBindingSources(action));

71var ex = Assert.Throws<InvalidOperationException>(() =>

70var exception = Assert.Throws<InvalidOperationException>(() => 86var exception = Assert.Throws<InvalidOperationException>(() =>

59var ex = Assert.Throws<InvalidOperationException>(() => executor.Execute(context)); 428var exception = Assert.Throws<InvalidOperationException>(() => executor.Execute(context));

511Assert.Throws<AmbiguousActionException>(() => { selector.SelectBestCandidate(routeContext, actions); }); 838var ex = Assert.Throws<AmbiguousActionException>(() =>

1095Assert.Throws<InvalidTimeZoneException>( 1279var ex = Assert.Throws<InvalidOperationException>(() => validator.Validate(actionContext, validationState, prefix: string.Empty, model));

314var exception = Assert.Throws<InvalidOperationException>(() =>

532var exception = Assert.Throws<RouteCreationException>(() =>

20var equalException = Assert.Throws<EqualException>(() => XmlAssert.Equal(input1, input2)); 72Assert.Throws<EqualException>(() => XmlAssert.Equal(input1, input2)); 113var equalException = Assert.Throws<EqualException>(() => XmlAssert.Equal(expected, actual));

148var exception = Assert.Throws<FormatException>(

32var exception = Assert.Throws<InvalidOperationException>(() => 60var exception = Assert.Throws<InvalidOperationException>(() =>

107var ex = Assert.Throws<InvalidOperationException>(() => featureProvider.PopulateFeature(new[] { part1, part2.Object }, feature));

166Assert.Throws<InvalidCastException>(() => activator.Activate(instance, viewContext));

665var ex = Assert.Throws<InvalidOperationException>(() => page.EnsureRenderedBodyOrSections()); 704var ex = Assert.Throws<InvalidOperationException>(() => page.EnsureRenderedBodyOrSections());

380var exception = Assert.Throws<InvalidOperationException>(

27var ex = Assert.Throws<InvalidOperationException>(() => provider.OnProvidersExecuting(context)); 68var ex = Assert.Throws<InvalidOperationException>(() => provider.OnProvidersExecuting(context)); 91var ex = Assert.Throws<InvalidOperationException>(() => provider.OnProvidersExecuting(context)); 116var ex = Assert.Throws<InvalidOperationException>(() => provider.OnProvidersExecuting(context));

40var ex = Assert.Throws<InvalidOperationException>(() => provider.OnProvidersExecuting(context)); 57var ex = Assert.Throws<InvalidOperationException>(() => provider.OnProvidersExecuting(context));

149var ex = Assert.Throws<InvalidOperationException>(() => tagHelper.Process(context, output)); 196var ex = Assert.Throws<InvalidOperationException>(() => tagHelper.Process(context, output));

1053var exceptionAdd = Assert.Throws<ArgumentException>(() => tagHelperOutput.AddClass(classValue, htmlEncoder)); 1054var exceptionRemove = Assert.Throws<ArgumentException>(() => tagHelperOutput.RemoveClass(classValue, htmlEncoder));

59Assert.Throws<InvalidOperationException>(() => attributes.Add("one", "15"));

136var exception = Assert.Throws<InvalidOperationException>(() => provider.OnProvidersExecuting(context));

42var ex = Assert.Throws<InvalidOperationException>(() => provider.OnProvidersExecuting(context)); 59var ex = Assert.Throws<InvalidOperationException>(() => provider.OnProvidersExecuting(context));

176var actual = Assert.Throws<InvalidOperationException>(() => partialMethod(helper.Object));

26Assert.Throws<InvalidOperationException>(() => 39Assert.Throws<InvalidOperationException>(() =>

175var ex = Assert.Throws<InvalidOperationException>(() => result.Execute(viewComponentContext)); 213var ex = Assert.Throws<InvalidOperationException>(() => result.Execute(viewComponentContext)); 253var ex = Assert.Throws<InvalidOperationException>(() => result.Execute(viewComponentContext));

141var exception = Assert.Throws<InvalidOperationException>(() => viewData.SetModelPublic(model)); 402var exception = Assert.Throws<InvalidOperationException>(() => viewData.SetModelPublic(value: null));

299Assert.Throws<ArgumentException>(() =>

149Assert.Throws<ArgumentNullException>(() => collection.CopyTo(null, 0)); // array is null 150Assert.Throws<ArgumentOutOfRangeException>(() => collection.CopyTo(kvp, -1)); // arrayIndex is less than 0 151Assert.Throws<ArgumentException>(() => collection.CopyTo(kvp, 1)); // The number of elements in the source ICollection<T> is greater than the available space from arrayIndex to the end of the destination array.

215var ex = Assert.Throws<InvalidOperationException>(() =>

139Assert.Throws<ArgumentNullException>(() => 153Assert.Throws<ArgumentNullException>(() =>

17Assert.Throws<ArgumentNullException>(() =>

606Assert.Throws<ArgumentNullException>(() => 621Assert.Throws<ArgumentNullException>(() => 637Assert.Throws<ArgumentNullException>(() =>

18Assert.Throws<ArgumentNullException>(() => 32Assert.Throws<ArgumentNullException>(() =>

15Assert.Throws<ArgumentNullException>(() =>

20var ex = Assert.Throws<NotSupportedException>(() => builder.AddAction(null, flags));

470Assert.Throws<InvalidOperationException>(() => endpointBuilder.Finally(b => b.Metadata.Add(new RouteNameMetadata("Foo"))));

500Assert.Throws<InvalidOperationException>(() => endpointBuilder.Finally(b => b.Metadata.Add(new RouteNameMetadata("Foo"))));

290var ex = Assert.Throws<InvalidOperationException>(() => routeOptions.SetParameterPolicy("custom", typeof(string)));

321var ex = Assert.Throws<InvalidOperationException>(() => candidateSet.ExpandEndpoint(0, Array.Empty<Endpoint>(), comparer));

225var exception = Assert.Throws<AggregateException>(

97Assert.Throws<InvalidOperationException>(() => 189Assert.Throws<InvalidOperationException>(() =>

305Assert.Throws<InvalidOperationException>(() => 608var exception = Assert.Throws<InvalidOperationException>(() =>

101var ex = Assert.Throws<InvalidOperationException>(() => 114var ex = Assert.Throws<InvalidOperationException>(() =>

108var ex = Assert.Throws<RouteCreationException>(() =>

92Assert.Throws<InvalidOperationException>(() => delegateFeature.DelegateRequest(destination)); 158Assert.Throws<InvalidOperationException>(() => delegateFeature.DelegateRequest(destination));

31Assert.Throws<InvalidOperationException>(() => context.Response.Body.Flush()); 32Assert.Throws<InvalidOperationException>(() => context.Response.Body.Write(new byte[10], 0, 10)); 33Assert.Throws<InvalidOperationException>(() => context.Response.Body.Flush()); 261Assert.Throws<ObjectDisposedException>(() => context.Response.Body.Write(Utilities.WriteBuffer, 0, Utilities.WriteBuffer.Length));

305Assert.Throws<InvalidOperationException>(() => 310Assert.Throws<InvalidOperationException>(() => 315Assert.Throws<InvalidOperationException>(() => 320Assert.Throws<InvalidOperationException>(() => 326Assert.Throws<InvalidOperationException>(() =>

138var exception = Assert.Throws<HttpSysException>(() => listener.Start());

190var ex = Assert.Throws<BadHttpRequestException>(() => { var t = httpContext.Request.Body.ReadAsync(input, 0, input.Length); }); 193ex = Assert.Throws<BadHttpRequestException>(() => { var t = httpContext.Request.Body.ReadAsync(input, 0, input.Length); });

229Assert.Throws<InvalidOperationException>(() => responseHeaders.Add("Custom3", new string[] { "value3a, value3b", "value3c" })); 260Assert.Throws<InvalidOperationException>(() => responseHeaders.Add("Custom3", new string[] { "value3a, value3b", "value3c" }));

205Assert.Throws<InvalidTimeZoneException>(() => httpContext.Response.Body.Write(new byte[10], 0, 10));

66Assert.Throws<InvalidOperationException>(() => httpContext.Response.AppendTrailer(header, "value")); 128Assert.Throws<InvalidOperationException>(() => httpContext.Response.AppendTrailer("TrailerName", "Trailer Value"));

95Assert.Throws<Exception>(() => requestPipe.AdvanceTo(new SequencePosition()))); 97Assert.Throws<Exception>(() => requestPipe.AdvanceTo(new SequencePosition(), new SequencePosition()))); 99Assert.Throws<Exception>(() => requestPipe.CancelPendingRead())); 103Assert.Throws<Exception>(() => requestPipe.Complete())); 115Assert.Throws<ObjectDisposedException>(() => requestPipe.AdvanceTo(new SequencePosition())); 116Assert.Throws<ObjectDisposedException>(() => requestPipe.AdvanceTo(new SequencePosition(), new SequencePosition())); 117Assert.Throws<ObjectDisposedException>(() => requestPipe.CancelPendingRead()); 119Assert.Throws<ObjectDisposedException>(() => requestPipe.Complete()); 132Assert.Throws<ObjectDisposedException>(() => responsePipe.Advance(1)); 133Assert.Throws<ObjectDisposedException>(() => responsePipe.CancelPendingFlush()); 135Assert.Throws<ObjectDisposedException>(() => responsePipe.GetSpan()); 136Assert.Throws<ObjectDisposedException>(() => responsePipe.Complete());

22var exception = Assert.Throws<InvalidOperationException>(() => memoryPool.Dispose()); 33var exception = Assert.Throws<InvalidOperationException>(() => block.Dispose()); 43var exception = Assert.Throws<InvalidOperationException>(() => block.Dispose()); 218var exception = Assert.Throws<InvalidOperationException>(() => memoryPool.Dispose()); 224var exception = Assert.Throws<AggregateException>(() => memoryPool.Dispose());

325Assert.Throws<InvalidOperationException>(() => ((IHttpResponseFeature)_http1Connection).OnStarting(_ => Task.CompletedTask, null));

332Assert.Throws<BadHttpRequestException>(() => VerifyRawHeaders(rawHeaders, expectedHeaderNames, expectedHeaderValues, disableHttp1LineFeedTerminators: true)); 384Assert.Throws<BadHttpRequestException>(() => VerifyRawHeaders(rawHeaders, expectedHeaderNames, expectedHeaderValues, disableHttp1LineFeedTerminators: true)); 487var exception = Assert.Throws<BadHttpRequestException>(() => 507var exception = Assert.Throws<BadHttpRequestException>(() => 550exception = Assert.Throws<BadHttpRequestException>(() => 586var badHttpRequestException = Assert.Throws<BadHttpRequestException>(() => 605var exception = Assert.Throws<BadHttpRequestException>(() => 625var exception = Assert.Throws<BadHttpRequestException>(() => 787var exception = Assert.Throws<BadHttpRequestException>(() => 811var exception = Assert.Throws<BadHttpRequestException>(() =>

299Assert.Throws<ArgumentException>(() => headers.Add("host", new[] { "localhost" })); 300Assert.Throws<ArgumentException>(() => headers.Add("custom", new[] { "value" })); 301Assert.Throws<ArgumentException>(() => headers.Add("Content-Length", new[] { "0" })); 401var exception = Assert.Throws<BadHttpRequestException>( 562Assert.Throws<InvalidOperationException>((Action)(() => 654Assert.Throws<InvalidOperationException>(() => 685Assert.Throws<InvalidOperationException>(() => headers.Append(acceptNameBytes, headerValueBytes, checkForNewlineChars: false)); 709Assert.Throws<InvalidOperationException>(() =>

57Assert.Throws<NotSupportedException>(() => stream.SetLength(0)); 72Assert.Throws<NotSupportedException>(() => stream.Write(new byte[1], 0, 1)); 79Assert.Throws<NotSupportedException>(() => stream.WriteByte(0)); 123var ioEx2 = Assert.Throws<InvalidOperationException>(() => stream.CopyTo(Stream.Null));

110Assert.Throws<InvalidOperationException>(() => 115Assert.Throws<InvalidOperationException>(() => 120Assert.Throws<InvalidOperationException>(() => 125Assert.Throws<InvalidOperationException>(() => 131Assert.Throws<InvalidOperationException>(() => 155Assert.Throws<InvalidOperationException>(() => 161Assert.Throws<InvalidOperationException>(() => 193Assert.Throws<InvalidOperationException>(() => 199Assert.Throws<InvalidOperationException>(() => 204Assert.Throws<InvalidOperationException>(() => 209Assert.Throws<InvalidOperationException>(() => 214Assert.Throws<InvalidOperationException>(() => 219Assert.Throws<InvalidOperationException>(() => 225Assert.Throws<InvalidOperationException>(() => 267Assert.Throws<InvalidOperationException>(() => ((IDictionary<string, StringValues>)headers).Add("my-header", new[] { "value" })); 309Assert.Throws<InvalidOperationException>(() => dictionary.Clear()); 319var exception = Assert.Throws<InvalidOperationException>(() => dictionary.Add("Content-Length", new[] { contentLength }));

19var ex = Assert.Throws<ObjectDisposedException>(() => { pipeWriter.Advance(1); }); 29var ex = Assert.Throws<ObjectDisposedException>(() => { pipeWriter.GetMemory(); }); 39var ex = Assert.Throws<ObjectDisposedException>(() => { pipeWriter.GetSpan(); }); 49var ex = Assert.Throws<ObjectDisposedException>(() => { pipeWriter.Complete(); }); 59var ex = Assert.Throws<ObjectDisposedException>(() => { pipeWriter.FlushAsync(); }); 69var ex = Assert.Throws<ObjectDisposedException>(() => { pipeWriter.WriteAsync(new Memory<byte>()); });

85Assert.Throws<NotSupportedException>(() => stream.SetLength(0)); 123var ioEx = Assert.Throws<InvalidOperationException>(() => stream.Write(new byte[1], 0, 1));

23Assert.Throws<ArgumentOutOfRangeException>(() => 52Assert.Throws<ArgumentOutOfRangeException>(() => 80Assert.Throws<ArgumentOutOfRangeException>(() => 134Assert.Throws<ArgumentOutOfRangeException>(() =>

55var exception = Assert.Throws<FormatException>(() => StartDummyApplication(server)); 87var ex = Assert.Throws<InvalidOperationException>(() => StartDummyApplication(server)); 126var exception = Assert.Throws<InvalidOperationException>(() => StartDummyApplication(server)); 232var exception = Assert.Throws<InvalidOperationException>(() => StartDummyApplication(server)); 259var exception = Assert.Throws<InvalidOperationException>(() => StartDummyApplication(server));

176HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => 253HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(new byte[] { 0x7e }, endHeaders: true, handler: _handler)); 277HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler)); 301HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler)); 325HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler)); 371HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler)); 403HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(new byte[] { 0x0f, 0x2f }, endHeaders: true, handler: _handler)); 498HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(new byte[] { 0x1f, 0x2f }, endHeaders: true, handler: _handler)); 621HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(data, endHeaders: true, handler: _handler)); 636HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(data, endHeaders: true, handler: _handler)); 663HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => 676HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler)); 727var ex = Assert.Throws<HPackDecodingException>(() => decoder.Decode(encoded, endHeaders: true, handler: _handler)); 867HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler)); 901HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler));

295QPackDecodingException exception = Assert.Throws<QPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler));

22Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, Assert.Throws<InvalidOperationException>(() => stream.Write(new byte[1], 0, 1)).Message); 24Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, Assert.Throws<InvalidOperationException>(() => stream.Flush()).Message);

46Assert.Throws<InvalidOperationException>(host.Run); 73Assert.Throws<InvalidOperationException>(host.Run); 106Assert.Throws<InvalidOperationException>(host.Run); 176Assert.Throws<InvalidOperationException>(host.Run);

599var ex = Assert.Throws<ArgumentException>(() => 624var ex = Assert.Throws<ArgumentException>(() => 649var ex = Assert.Throws<CryptographicException>(() => 673var ex = Assert.Throws<InvalidOperationException>(() => 802var ex = Assert.Throws<InvalidOperationException>(() => serverOptions.Configure(config).Load()); 811ex = Assert.Throws<InvalidOperationException>(() => serverOptions.Configure(config).Load()); 820ex = Assert.Throws<InvalidOperationException>(() => serverOptions.Configure(config).Load()); 829ex = Assert.Throws<InvalidOperationException>(() => serverOptions.Configure(config).Load()); 838ex = Assert.Throws<InvalidOperationException>(() => serverOptions.Configure(config).Load()); 1792Assert.Throws<InvalidOperationException>(serverOptions.ConfigurationLoader.ProcessEndpointsToAdd);

582Assert.Throws<ArgumentOutOfRangeException>(() => protocolErrorCodeFeature.AbortRead(errorCode, new ConnectionAbortedException())); 583Assert.Throws<ArgumentOutOfRangeException>(() => protocolErrorCodeFeature.AbortWrite(errorCode, new ConnectionAbortedException()));

176HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => 253HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(new byte[] { 0x7e }, endHeaders: true, handler: _handler)); 277HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler)); 301HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler)); 325HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler)); 371HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler)); 403HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(new byte[] { 0x0f, 0x2f }, endHeaders: true, handler: _handler)); 498HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(new byte[] { 0x1f, 0x2f }, endHeaders: true, handler: _handler)); 621HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(data, endHeaders: true, handler: _handler)); 636HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(data, endHeaders: true, handler: _handler)); 663HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => 676HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler)); 727var ex = Assert.Throws<HPackDecodingException>(() => decoder.Decode(encoded, endHeaders: true, handler: _handler)); 867HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler)); 901HPackDecodingException exception = Assert.Throws<HPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler));

295QPackDecodingException exception = Assert.Throws<QPackDecodingException>(() => _decoder.Decode(encoded, endHeaders: true, handler: _handler));

33Assert.Throws<FormatException>(() =>

68var ex = Assert.Throws<FormatException>(() =>

91var exception = Assert.Throws<InvalidDataException>(() =>

61Assert.Throws<ArgumentNullException>(

21var ex = Assert.Throws<NotSupportedException>(() => 50var ex = Assert.Throws<InvalidOperationException>(() =>

35var exception = Assert.Throws<InvalidOperationException>(

48Assert.Throws<InvalidOperationException>(() =>

1818Assert.Throws<InvalidOperationException>(() => builder.Services.TryAddSingleton(new Service())); 1820Assert.Throws<InvalidOperationException>(() => builder.Services.TryAddScoped<IService, Service>());

255var exception = Assert.Throws<IOException>(() => bufferingStream.Write(input, 0, input.Length)); 270var exception = Assert.Throws<IOException>(() => bufferingStream.Write(input, 0, input.Length));

226var exception = Assert.Throws<InvalidDataException>( 455var exception = Assert.Throws<InvalidDataException>(() => formReader.ParseFormValues(ref readOnlySequence, ref accumulator, isFinalBlock: true)); 469var exception = Assert.Throws<InvalidDataException>(() => formReader.ParseFormValues(ref readOnlySequence, ref accumulator, isFinalBlock: true)); 483var exception = Assert.Throws<InvalidDataException>(() => formReader.ParseFormValues(ref readOnlySequence, ref accumulator, isFinalBlock: true)); 497var exception = Assert.Throws<InvalidDataException>(() => formReader.ParseFormValues(ref readOnlySequence, ref accumulator, isFinalBlock: true)); 511var exception = Assert.Throws<InvalidDataException>(() => formReader.ParseFormValues(ref readOnlySequence, ref accumulator, isFinalBlock: true)); 525var exception = Assert.Throws<InvalidDataException>(() => formReader.ParseFormValues(ref readOnlySequence, ref accumulator, isFinalBlock: true));

346Assert.Throws<ArgumentNullException>(() => 357Assert.Throws<ArgumentOutOfRangeException>(() => 368Assert.Throws<ArgumentException>(() => 381Assert.Throws<ObjectDisposedException>(() =>

734Assert.Throws<ArgumentNullException>(() => 745Assert.Throws<ArgumentOutOfRangeException>(() => 756Assert.Throws<ArgumentException>(() => 769Assert.Throws<ObjectDisposedException>(() =>

311Assert.Throws<ArgumentOutOfRangeException>(() =>

135Assert.Throws<ArgumentException>(() => workspace.OnProjectRemoved(project.Id)); 149Assert.Throws<ArgumentException>(() => workspace.OnProjectRemoved(project2.Id)); 266Assert.Throws<ArgumentException>(() => workspace.OnProjectReferenceAdded(project1.Id, new ProjectReference(project2.Id))); 305Assert.Throws<ArgumentException>(() => workspace.OnProjectReferenceAdded(project1.Id, new ProjectReference(project2.Id))); 344Assert.Throws<ArgumentException>(() => workspace.OnProjectReferenceAdded(project2.Id, new ProjectReference(project1.Id)));

106Assert.Throws<ArgumentException>(() => context.AddSource("hint3", SourceText.From("class G3 { void F() {} }", encoding: null, checksumAlgorithm: SourceHashAlgorithm.Sha256)));

71Assert.Throws<NotSupportedException>(() => { symbol.WithNullableAnnotation(CodeAnalysis.NullableAnnotation.Annotated); });

767Assert.Throws<ArgumentNullException>(() => { compilation.IsSymbolAccessibleWithin(classA, nullSymbol); }); 768Assert.Throws<ArgumentNullException>(() => { compilation.IsSymbolAccessibleWithin(nullSymbol, classA); }); 769Assert.Throws<ArgumentException>(() => { compilation.IsSymbolAccessibleWithin(classA, pubField); }); 861Assert.Throws<ArgumentException>(() => { compilation.IsSymbolAccessibleWithin(classA, classOther); }); 945Assert.Throws<ArgumentException>(() => { compilation3.IsSymbolAccessibleWithin(Outer, InOtherCompilation); }); 946Assert.Throws<ArgumentException>(() => { compilation3.IsSymbolAccessibleWithin(Outer, InFriendCompilation); });

108Assert.Throws<InvalidCastException>(() => { var _ = (CSharpSyntaxTree)(Object)tree.GetCompilationUnitRoot(); }); 109Assert.Throws<ArgumentNullException>(() => { tree.GetDiagnostics((CSharpSyntaxNode)null); }); 110Assert.Throws<InvalidOperationException>(() => { tree.GetDiagnostics(default(SyntaxToken)); }); 111Assert.Throws<ArgumentNullException>(() => { tree.GetDiagnostics((SyntaxNode)null); }); 112Assert.Throws<InvalidOperationException>(() => { tree.GetDiagnostics(default(SyntaxTrivia)); });

229Assert.Throws<ArgumentException>(() => asc.Add("file4.cs", SourceText.From(""))); 232Assert.Throws<ArgumentException>(() => asc.Add("file5.cs", SourceText.From("", encoding: null))); 234var exception = Assert.Throws<ArgumentException>(() => asc.Add("file5.cs", SourceText.From("", encoding: null)));

188Assert.Throws<InvalidOperationException>(() => 196Assert.Throws<InvalidOperationException>(() => 204Assert.Throws<InvalidOperationException>(() => 212Assert.Throws<InvalidOperationException>(() =>

1323Assert.Throws<NullReferenceException>( 1329Assert.Throws<NullReferenceException>( 1357Assert.Throws<ArgumentNullException>( 1364Assert.Throws<ArgumentNullException>( 1384Assert.Throws<ArgumentNullException>( 1453Assert.Throws<ArgumentException>( 1460Assert.Throws<ArgumentNullException>( 1474Assert.Throws<ArgumentException>( 1482Assert.Throws<ArgumentException>( 1509Assert.Throws<ArgumentOutOfRangeException>( 1515Assert.Throws<ArgumentOutOfRangeException>( 1521Assert.Throws<ArgumentOutOfRangeException>( 1527Assert.Throws<ArgumentOutOfRangeException>( 1541Assert.Throws<ArgumentException>( 1565Assert.Throws<ArgumentNullException>( 1572Assert.Throws<ArgumentNullException>( 1584Assert.Throws<ArgumentNullException>( 1601Exception invalidCastSynTreeEx = Assert.Throws<InvalidCastException>( 1606invalidCastSynTreeEx = Assert.Throws<InvalidCastException>( 1611invalidCastSynTreeEx = Assert.Throws<InvalidCastException>( 1619Assert.Throws<ArgumentException>( 2385Assert.Throws<ArgumentException>(() =>

1327Assert.Throws<TestException>(() => { var a = c.Assembly; });

647Assert.Throws<ArgumentException>(() =>

20Assert.Throws<ArgumentException>(() => 26Assert.Throws<ArgumentException>(() => 32Assert.Throws<ArgumentException>(() => 38Assert.Throws<ArgumentException>(() => 48Assert.Throws<ArgumentNullException>(() => 54Assert.Throws<ArgumentNullException>(() => 64Assert.Throws<ArgumentNullException>(() => 70Assert.Throws<ArgumentNullException>(() =>

188Assert.Throws<ArgumentException>(() =>

206Assert.Throws<ArgumentOutOfRangeException>(() => parser.SkipForwardTo(0));

197Assert.Throws<System.ArgumentOutOfRangeException>(delegate 202Assert.Throws<System.ArgumentOutOfRangeException>(delegate 208Assert.Throws<System.ArgumentOutOfRangeException>(delegate

3624Assert.Throws<System.ArgumentNullException>(delegate

465Assert.Throws<ObjectDisposedException>(() =>

2261Assert.Throws<InvalidOperationException>(() => debuggingSession.CommitSolutionUpdate()); 2262Assert.Throws<InvalidOperationException>(() => debuggingSession.DiscardSolutionUpdate()); 4903Assert.Throws<ObjectDisposedException>(() => debuggingSession.BreakStateOrCapabilitiesChanged(inBreakState: true)); 4904Assert.Throws<ObjectDisposedException>(() => debuggingSession.DiscardSolutionUpdate()); 4905Assert.Throws<ObjectDisposedException>(() => debuggingSession.CommitSolutionUpdate()); 4906Assert.Throws<ObjectDisposedException>(() => debuggingSession.EndSession(out _));

62Assert.Throws<ArgumentNullException>(() => _provider.SuppressShadowCopy(null)); 63Assert.Throws<ArgumentException>(() => _provider.SuppressShadowCopy("c:goo.dll")); 64Assert.Throws<ArgumentException>(() => _provider.SuppressShadowCopy("bar.dll")); 65Assert.Throws<ArgumentException>(() => _provider.SuppressShadowCopy(@"\bar.dll")); 66Assert.Throws<ArgumentException>(() => _provider.SuppressShadowCopy(@"../bar.dll")); 160Assert.Throws<IOException>(() => File.Delete(sc));

1470Assert.Throws<UnauthorizedAccessException>(() => File.Delete(testFixture.Delta1));

38Assert.Throws<InvalidOperationException>(() => queue.Enqueue(42)); 56Assert.Throws<InvalidOperationException>(() =>

323Assert.Throws<ArgumentNullException>(() => set.ExceptWith(null!)); 324Assert.Throws<ArgumentNullException>(() => set.IntersectWith(null!)); 325Assert.Throws<ArgumentNullException>(() => set.SymmetricExceptWith(null!)); 326Assert.Throws<ArgumentNullException>(() => set.UnionWith(null!)); 331Assert.Throws<NotSupportedException>(() => set.ExceptWith(null!)); 332Assert.Throws<NotSupportedException>(() => set.IntersectWith(null!)); 333Assert.Throws<NotSupportedException>(() => set.SymmetricExceptWith(null!)); 334Assert.Throws<NotSupportedException>(() => set.UnionWith(null!));

271Assert.Throws<ArgumentOutOfRangeException>(() => set.CopyTo(arr, 0, -1)); 272Assert.Throws<ArgumentOutOfRangeException>(() => set.CopyTo(arr, 0, int.MinValue));

81Assert.Throws<NotSupportedException>(() => collection.Add("x")); 83Assert.Throws<NotSupportedException>(() => collection.Clear());

131Assert.Throws<NotSupportedException>(() => dictionary.Add(new KeyValuePair<string, int>())); 133Assert.Throws<NotSupportedException>(() => dictionary.Clear()); 157Assert.Throws<NotSupportedException>(() => dictionary.Add("a", 1)); 168Assert.Throws<NotSupportedException>(() => dictionary.Add("a", 1)); 169Assert.Throws<NotSupportedException>(() => dictionary.Remove("a")); 171Assert.Throws<NotSupportedException>(() => dictionary.Clear());

57Assert.Throws<NotSupportedException>(() => map.Add(5, 3)); 290Assert.Throws<NotSupportedException>(() => collection.Add(default(T)!)); 291Assert.Throws<NotSupportedException>(() => collection.Clear());

154Assert.Throws<ArgumentOutOfRangeException>(() => mutable.InsertRange(-1, new int[0])); 155Assert.Throws<ArgumentOutOfRangeException>(() => mutable.InsertRange(mutable.Count + 1, new int[0]));

749Assert.Throws<NotSupportedException>(() => list.Clear()); 750Assert.Throws<NotSupportedException>(() => list.Insert(0, 1)); 751Assert.Throws<NotSupportedException>(() => list.Remove(1)); 752Assert.Throws<NotSupportedException>(() => list.RemoveAt(0)); 761Assert.Throws<NotSupportedException>(() => list.Add(1)); 762Assert.Throws<NotSupportedException>(() => list.Clear()); 763Assert.Throws<NotSupportedException>(() => list.Insert(0, 1)); 765Assert.Throws<NotSupportedException>(() => list.RemoveAt(0));

173Assert.Throws<NotSupportedException>(() => set.ExceptWith(null!)); 174Assert.Throws<NotSupportedException>(() => set.UnionWith(null!)); 175Assert.Throws<NotSupportedException>(() => set.IntersectWith(null!)); 176Assert.Throws<NotSupportedException>(() => set.SymmetricExceptWith(null!)); 183Assert.Throws<NotSupportedException>(() => set.Add(1)); 184Assert.Throws<NotSupportedException>(() => set.Clear());

284Assert.Throws<NotSupportedException>(() => collection.Add(CreateT(0))); 317Assert.Throws<NotSupportedException>(() => collection.Clear()); 334Assert.Throws<NotSupportedException>(() => collection.Clear()); 335Assert.Throws<NotSupportedException>(() => collection.Clear()); 336Assert.Throws<NotSupportedException>(() => collection.Clear()); 483Assert.Throws<ArgumentNullException>(() => collection.CopyTo(null!, 0)); 492Assert.Throws<ArgumentOutOfRangeException>(() => collection.CopyTo(array, -1)); 493Assert.Throws<ArgumentOutOfRangeException>(() => collection.CopyTo(array, int.MinValue));

182Assert.Throws<ArgumentNullException>(() => collection.CopyTo(null!, 0)); 252Assert.Throws<ArgumentOutOfRangeException>(() => collection.CopyTo(array, -1)); 253Assert.Throws<ArgumentOutOfRangeException>(() => collection.CopyTo(array, int.MinValue)); 263Assert.Throws<ArgumentException>(() => collection.CopyTo(array, count)); 286Assert.Throws<ArgumentException>(() => collection.CopyTo(array, 1));

697Assert.Throws<NotSupportedException>(() => enumerator.Reset()); 714Assert.Throws<InvalidOperationException>(() => enumerator.Reset()); 757Assert.Throws<InvalidOperationException>(() => enumerator.Reset()); 801Assert.Throws<InvalidOperationException>(() => enumerator.Reset()); 839Assert.Throws<NotSupportedException>( 856Assert.Throws<NotSupportedException>( 872Assert.Throws<NotSupportedException>(

366Assert.Throws<NotSupportedException>(() => enumerator.Reset()); 381Assert.Throws<InvalidOperationException>(() => enumerator.Reset()); 407Assert.Throws<InvalidOperationException>(() => enumerator.Reset()); 430Assert.Throws<InvalidOperationException>(() => enumerator.Reset());

406Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(-1, validAdd)); 407Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(int.MinValue, validAdd)); 433Assert.Throws<NotSupportedException>(() => list.Insert(count / 2, CreateT(321432))); 506Assert.Throws<NotSupportedException>(() => list.Insert(0, value)); 528Assert.Throws<ArgumentException>(() => list.Insert(count / 2, value)); 545Assert.Throws<ArgumentOutOfRangeException>(() => list.RemoveAt(-1)); 546Assert.Throws<ArgumentOutOfRangeException>(() => list.RemoveAt(int.MinValue)); 559Assert.Throws<ArgumentOutOfRangeException>(() => list.RemoveAt(count)); 560Assert.Throws<ArgumentOutOfRangeException>(() => list.RemoveAt(count + 1)); 572Assert.Throws<NotSupportedException>(() => list.RemoveAt(count / 2));

544Assert.Throws<NotSupportedException>(() => collection.Clear()); 766Assert.Throws<NotSupportedException>(() => list.Insert(count / 2, CreateT(321432))); 854Assert.Throws<ArgumentException>(() => list.Insert(count / 2, value)); 870Assert.Throws<NotSupportedException>(() => collection.Remove(CreateT(34543))); 908Assert.Throws<ArgumentException>(() => list.Remove(value)); 999Assert.Throws<ArgumentException>(() => collection.Remove(value)); 1044Assert.Throws<NotSupportedException>(() => list.RemoveAt(count / 2));

117Assert.Throws<ArgumentNullException>(() => list.AddRange(null!)); 139Assert.Throws<InvalidOperationException>(() => list.AddRange(list.Where(_ => true))); 141Assert.Throws<InvalidOperationException>(() => list.AddRange(list.Where(_ => true))); 151Assert.Throws<OverflowException>(() => list.AddRange(collection));

77Assert.Throws<ArgumentNullException>(() => { SegmentedList<T> _list = new SegmentedList<T>(null!); }); //"Expected ArgumentnUllException for null items"

40Assert.Throws<ArgumentNullException>(() => list.ForEach(null!));

75Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(bad[i], items[0])); //"ArgumentOutOfRangeException expected." 115Assert.Throws<ArgumentOutOfRangeException>(() => _ilist.Insert(bad[i], items[0])); //"ArgumentOutOfRangeException expected." 187Assert.Throws<ArgumentOutOfRangeException>(() => list.InsertRange(bad[i], constructIEnumerable(items))); //"ArgumentOutOfRangeException expected" 190Assert.Throws<ArgumentNullException>(() => list.InsertRange(0, null!)); //"ArgumentNullException expected."

150Assert.Throws<ArgumentOutOfRangeException>(() => list.RemoveRange(invalidSet.Item1, invalidSet.Item2));

163Assert.Throws<ArgumentOutOfRangeException>(() => list.Reverse(invalidSet.Item1, invalidSet.Item2));

182Assert.Throws<ArgumentOutOfRangeException>(() => list.Sort(invalidSet.Item1, invalidSet.Item2, GetIComparer()));

92Assert.Throws<ArgumentNullException>(() => { Rope.ForString(null); }); 100Assert.Throws<ArgumentNullException>(() => { Rope.Concat(r, null); }); 101Assert.Throws<ArgumentNullException>(() => { Rope.Concat(null, r); });

64Assert.Throws<NullReferenceException>(() => data.CopyTo(Array.Empty<IntPtr>(), 0)); 65Assert.Throws<NullReferenceException>(() => ((ICollection<IntPtr>)data).CopyTo(Array.Empty<IntPtr>(), 0)); 77Assert.Throws<NotSupportedException>(() => ((ICollection<IntPtr>)data).Add(IntPtr.Zero)); 78Assert.Throws<NotSupportedException>(() => ((ICollection<IntPtr>)data).Clear()); 79Assert.Throws<NotSupportedException>(() => ((IList)data).Insert(0, IntPtr.Zero)); 80Assert.Throws<NotSupportedException>(() => ((IList<IntPtr>)data).Insert(0, IntPtr.Zero)); 81Assert.Throws<NotSupportedException>(() => ((IList)data).Remove(IntPtr.Zero)); 83Assert.Throws<NotSupportedException>(() => ((IList)data).RemoveAt(0)); 84Assert.Throws<NotSupportedException>(() => ((IList<IntPtr>)data).RemoveAt(0)); 86Assert.Throws<NullReferenceException>(() => ((IList)data).Clear());

24Assert.Throws<IndexOutOfRangeException>(() => 31Assert.Throws<IndexOutOfRangeException>(() =>

20Assert.Throws<NullReferenceException>(a);

95Assert.Throws<InvalidOperationException>(() => { ConstantValue.Create(null, ConstantValueTypeDiscriminator.Bad); }); 98Assert.Throws<InvalidOperationException>(() => { var c = cv1.StringValue; }); 99Assert.Throws<InvalidOperationException>(() => { var c = cv1.DateTimeValue; }); 102Assert.Throws<InvalidOperationException>(() => { var c = cv2.StringValue; }); 103Assert.Throws<InvalidOperationException>(() => { var c = cv2.CharValue; }); 104Assert.Throws<InvalidOperationException>(() => { var c = cv2.DateTimeValue; }); 107Assert.Throws<InvalidOperationException>(() => { var c = cvNull.BooleanValue; }); 108Assert.Throws<InvalidOperationException>(() => { var c = cvNull.DecimalValue; }); 109Assert.Throws<InvalidOperationException>(() => { var c = cvNull.DoubleValue; }); 110Assert.Throws<InvalidOperationException>(() => { var c = cvNull.SingleValue; }); 111Assert.Throws<InvalidOperationException>(() => { var c = cvNull.SByteValue; }); 112Assert.Throws<InvalidOperationException>(() => { var c = cvNull.ByteValue; });

35Assert.Throws<ArgumentNullException>( 41Assert.Throws<ArgumentException>( 47Assert.Throws<ArgumentException>(

21Assert.Throws<ArgumentException>(() => dictionary.Add(0, 0));

40Assert.Throws<NotSupportedException>(() => ((ICollection<int>)(emptySet)).Add(0)); 42Assert.Throws<NotSupportedException>(() => emptySet.Clear()); 60Assert.Throws<NotSupportedException>(() => emptySet.ExceptWith(new int[0])); 61Assert.Throws<NotSupportedException>(() => emptySet.IntersectWith(new int[0])); 62Assert.Throws<NotSupportedException>(() => emptySet.SymmetricExceptWith(new int[0])); 63Assert.Throws<NotSupportedException>(() => emptySet.UnionWith(new int[0]));

31Assert.Throws<ArgumentOutOfRangeException>( 38Assert.Throws<ArgumentOutOfRangeException>(

81Assert.Throws<ArgumentNullException>(() => { AssemblyIdentity.FromAssemblyDefinition(asm); });

24Assert.Throws<ArgumentOutOfRangeException>(() => { fixed (byte* ptr = new byte[] { 1, 2, 3 }) ModuleMetadata.CreateFromMetadata((IntPtr)ptr, 0); }); 25Assert.Throws<ArgumentOutOfRangeException>(() => { fixed (byte* ptr = new byte[] { 1, 2, 3 }) ModuleMetadata.CreateFromMetadata((IntPtr)ptr, -1); }); 90Assert.Throws<ArgumentOutOfRangeException>(() => { fixed (byte* ptr = new byte[] { 1, 2, 3 }) ModuleMetadata.CreateFromImage((IntPtr)ptr, 0); }); 91Assert.Throws<ArgumentOutOfRangeException>(() => { fixed (byte* ptr = new byte[] { 1, 2, 3 }) ModuleMetadata.CreateFromImage((IntPtr)ptr, -1); });

159Assert.Throws<DecoderFallbackException>(() =>

84Assert.Throws<IndexOutOfRangeException>(

50Assert.Throws<IndexOutOfRangeException>(

19Assert.Throws<ArgumentOutOfRangeException>(

243Assert.Throws<ArgumentOutOfRangeException>(() => newText.CopyTo(-1, destination, 0, 2)); 244Assert.Throws<ArgumentOutOfRangeException>(() => newText.CopyTo(0, destination, -1, 2)); 245Assert.Throws<ArgumentOutOfRangeException>(() => newText.CopyTo(0, destination, 0, -1)); 246Assert.Throws<ArgumentNullException>(() => newText.CopyTo(0, null, 0, 2)); 247Assert.Throws<ArgumentOutOfRangeException>(() => newText.CopyTo(newText.Length - 1, destination, 0, 2)); 248Assert.Throws<ArgumentOutOfRangeException>(() => newText.CopyTo(0, destination, destination.Length - 1, 2));

88Assert.Throws(Of ArgumentException)(Sub() primitiveFormatter.TestEscapeStringWithoutQuotes()) 89Assert.Throws(Of ArgumentException)(Sub() primitiveFormatter.TestEscapeCharWithoutQuotes())

18Assert.Throws(Of ArgumentNullException)(Sub() s_formatter.FormatObject("hello", options:=Nothing)) 23Assert.Throws(Of ArgumentOutOfRangeException)( 32Assert.Throws(Of ArgumentOutOfRangeException)( 41Assert.Throws(Of ArgumentOutOfRangeException)( 46Assert.Throws(Of ArgumentOutOfRangeException)(

2189Assert.Throws<NotSupportedException>(delegate 2199Assert.Throws<NotSupportedException>(delegate

37Assert.Throws<InvalidOperationException>(delegate

80Assert.Throws<ArgumentException>(() => ExtensionOrderer.TestAccessor.CheckForCycles(extensions)); 97Assert.Throws<ArgumentException>(() => ExtensionOrderer.TestAccessor.CheckForCycles(extensions)); 112Assert.Throws<ArgumentException>(() => ExtensionOrderer.TestAccessor.CheckForCycles(extensions)); 127Assert.Throws<ArgumentException>(() => ExtensionOrderer.TestAccessor.CheckForCycles(extensions)); 146Assert.Throws<ArgumentException>(() => ExtensionOrderer.TestAccessor.CheckForCycles(extensions)); 165Assert.Throws<ArgumentException>(() => ExtensionOrderer.TestAccessor.CheckForCycles(extensions)); 183Assert.Throws<ArgumentException>(() => ExtensionOrderer.TestAccessor.CheckForCycles(extensions)); 201Assert.Throws<ArgumentException>(() => ExtensionOrderer.TestAccessor.CheckForCycles(extensions));

243Assert.Throws<ArgumentException>(() => TestRoundTripCompressedUint(uint.MaxValue)); // max uint not allowed 244Assert.Throws<ArgumentException>(() => TestRoundTripCompressedUint(0x80000000u)); // highest bit set not allowed 245Assert.Throws<ArgumentException>(() => TestRoundTripCompressedUint(0x40000000u)); // second highest bit set not allowed 246Assert.Throws<ArgumentException>(() => TestRoundTripCompressedUint(0xC0000000u)); // both high bits set not allowed

248var thrownException = Assert.Throws<OperationCanceledException>(() =>

30Assert.Throws<ArgumentException>(() => 39Assert.Throws<ArgumentException>(() =>

1079Assert.Throws<ArgumentException>(() => DataFrame.SaveCsv(dataFrame, csvStream, separator: separator, cultureInfo: cultureInfo));

78Assert.Throws<ArgumentException>(() => dataFrame.Columns.Insert(2, bigColumn)); 79Assert.Throws<ArgumentException>(() => dataFrame.Columns.Add(bigColumn)); 83Assert.Throws<ArgumentException>(() => dataFrame.Columns.Insert(2, smallColumn)); 84Assert.Throws<ArgumentException>(() => dataFrame.Columns.Add(smallColumn)); 88Assert.Throws<ArgumentException>(() => dataFrame.Columns.Insert(2, repeatedName)); 93Assert.Throws<ArgumentOutOfRangeException>(() => dataFrame.Columns.Insert(columnCount + 1, repeatedName)); 806Assert.Throws<ArgumentException>(() => df.Columns.Insert(1, new Int32DataFrameColumn("Int2", Enumerable.Range(0, 5).Select(x => x))));

113Assert.Throws<ArgumentException>(() => parser.SetFieldWidths(new[] { -1, -1 }));

50Assert.Throws<ArgumentOutOfRangeException>(() => { WorkloadSetPackage p = new(workloadSetPackageItem, PackageRootDirectory, new Version("256.12.3")); });

28Exception e = Assert.Throws<Exception>(() =>

138var e1 = Assert.Throws<InvalidOperationException>(() => NuGetVersionUpdater.Run(new[] { c_daily }, outDirectoryOpt: null, VersionTranslation.Release, exactVersions: false)); 141var e2 = Assert.Throws<AggregateException>(() => NuGetVersionUpdater.Run(new[] { a_daily }, outDirectoryOpt: null, VersionTranslation.Release, exactVersions: false)); 149var e3 = Assert.Throws<AggregateException>(() => NuGetVersionUpdater.Run(new[] { a_daily, b_daily }, outDirectoryOpt: null, VersionTranslation.Release, exactVersions: false)); 156var e4 = Assert.Throws<AggregateException>(() => NuGetVersionUpdater.Run(new[] { a_daily, c_daily }, outDirectoryOpt: null, VersionTranslation.Release, exactVersions: false));

26Assert.Throws<RemoteExecutionException>(() => 51Assert.Throws<RemoteExecutionException>(() => 64Assert.Throws<RemoteExecutionException>(() =>

175 Assert.Throws<ArgumentNullException>("testCode", () => Assert.Throws<ArgumentException>(default(Action)!)); 183 var ex = Record.Exception(() => Assert.Throws<ArgumentException>(testCode)); 199 Assert.Throws<ArgumentException>(testCode); 208 var ex = Record.Exception(() => Assert.Throws<ArgumentException>(testCode)); 226 var ex = Record.Exception(() => Assert.Throws<ArgumentException>(testCode)); 327 Assert.Throws<ArgumentNullException>("testCode", () => Assert.Throws<ArgumentException>(default(Action)!));

55 Assert.Throws<SameException>(() => Assert.Same(0, 0));

334 var ex = Assert.Throws<SupersetException>(() => Assert.Superset(expectedSuperset, actual));

953Assert.Throws<InvalidOperationException>(() => AIJsonUtilities.DefaultOptions.AddAIContentType<DerivedAIContent>("derivativeContent")); 969Assert.Throws<ArgumentException>(() => options.AddAIContentType<AIContent>("discriminator")); 970Assert.Throws<ArgumentException>(() => options.AddAIContentType<TextContent>("discriminator"));

99Assert.Throws<ArgumentNullException>(() => cache.Set(key, value));

115Assert.Throws<OptionsValidationException>(action);

99Assert.Throws<AggregateException>(() =>

362Assert.Throws<ObjectDisposedException>(() => collector.Clear()); 364Assert.Throws<ObjectDisposedException>(() => collector.RecordObservableInstruments()); 379Assert.Throws<ObjectDisposedException>(() => collector.Clear());

18Assert.Throws<ArgumentNullException>(() => ((HttpRetryStrategyOptions)null!).DisableFor(HttpMethod.Get)); 24Assert.Throws<ArgumentNullException>(() => new HttpRetryStrategyOptions().DisableFor(null!)); 30Assert.Throws<ArgumentException>(() => new HttpRetryStrategyOptions().DisableFor([])); 37Assert.Throws<ArgumentException>(() => options.DisableFor(HttpMethod.Get));

107Assert.Throws<ArgumentNullException>(() => AddStandardResilienceHandler(mode, builder, _validConfigurationSection, options => { })); 117Assert.Throws<ArgumentNullException>(() => AddStandardResilienceHandler(mode, builder, _validConfigurationSection, null!)); 128Assert.Throws<ArgumentNullException>(() => AddStandardResilienceHandler(mode, builder, null!, options => { })); 138Assert.Throws<ArgumentException>(() => AddStandardResilienceHandler(mode, builder, _emptyConfigurationSection, options => { }));

54Assert.Throws<ArgumentNullException>(() => context.SetRequestMessage(request));

128Assert.Throws<AggregateException>(() => provider.Reload([]));

194var exception = Assert.Throws<MissingManifestResourceException>(() =>

138Assert.Throws<ArgumentException>(() =>

26Assert.Throws<ObjectDisposedException>(() => factory.AddProvider(CreateProvider())); 34Assert.Throws<ArgumentNullException>(() => factory.AddProvider(null!));

212Assert.Throws<ArgumentOutOfRangeException>(() => timeProvider.Advance(TimeSpan.FromTicks(-1))); 220Assert.Throws<ArgumentOutOfRangeException>(() => timeProvider.SetUtcNow(timeProvider.GetUtcNow() - TimeSpan.FromTicks(1)));

43var ex = Assert.Throws<ArgumentException>(() => 65var ex = Assert.Throws<ArgumentException>(() => 588var ex = Assert.Throws<ArgumentException>(() => 611var ex = Assert.Throws<JsonException>(() =>

392var ex = Assert.Throws<ArgumentOutOfRangeException>(() => runtime.ReceiveByteArray(7, byteArray));

48Assert.Throws<ArgumentException>(new System.Action(() => context.Auto().InferColumns(dataPath, "Junk", groupColumns: false)));

67var ex = Assert.Throws<InvalidOperationException>(() => CacheOnEmptyEstimatorChain());

46var ex = Assert.Throws<System.Reflection.TargetInvocationException>(() => IrisLightGbmImpl(dbs));

1302Assert.Throws<ArgumentException>(() => image1.Save(imageTempPath));

263Assert.Throws<InvalidOperationException>(() => idv.Schema[1].Annotations.GetValue(kindFloat, ref retrievedReadOnlyMemoryVBuffer));

236var ex = Assert.Throws<InvalidOperationException>(() => 507var ex = Assert.Throws<InvalidOperationException>(() => 515ex = Assert.Throws<InvalidOperationException>(() => 523ex = Assert.Throws<InvalidOperationException>(() => 531ex = Assert.Throws<InvalidOperationException>(() =>

46Assert.Throws<ArgumentException>(() => cacheControl.NoCacheHeaders.Add(null)); 47Assert.Throws<FormatException>(() => cacheControl.NoCacheHeaders.Add("invalid PLACEHOLDER")); 53Assert.Throws<ArgumentException>(() => cacheControl.PrivateHeaders.Add(null)); 54Assert.Throws<FormatException>(() => cacheControl.PrivateHeaders.Add("invalid PLACEHOLDER")); 61Assert.Throws<ArgumentNullException>(() => cacheControl.Extensions.Add(null!));

59Assert.Throws<ArgumentNullException>(() => contentDisposition.Parameters.Add(null!));

287Assert.Throws<FormatException>(() => { var actual = HeaderUtilities.EscapeAsQuotedString(input); }); 293Assert.Throws<FormatException>(() => { var actual = HeaderUtilities.EscapeAsQuotedString($"{(char)0x7F}"); });

123Assert.Throws<ArgumentNullException>(() => mediaType.Parameters.Add(null!)); 149Assert.Throws<InvalidOperationException>(() => { mediaType1.MediaType = "some/value"; }); 184Assert.Throws<NotSupportedException>(() => mediaType1.Parameters.Add(new NameValueHeaderValue("name"))); 186Assert.Throws<NotSupportedException>(() => mediaType1.Parameters.Clear());

89Assert.Throws<InvalidOperationException>(() => { pair1.Value = "othervalue"; }); 122Assert.Throws<InvalidOperationException>(() => { pair1.Value = "othervalue"; }); 145Assert.Throws<FormatException>(() => { var x = new NameValueHeaderValue("name"); x.Value = " x "; }); 146Assert.Throws<FormatException>(() => { var x = new NameValueHeaderValue("name"); x.Value = "x y"; }); 615Assert.Throws<FormatException>(() => header.SetAndEscapeValue(input));

37Assert.Throws<COMException>(() => { var value = import.Name; }); 44Assert.Throws<COMException>(() => { var value = import.FullName; });

312Assert.Throws<ArgumentException>(() => project.ReorderSourceFiles([sourceFileFullPath4, sourceFileFullPath5])); 315Assert.Throws<InvalidOperationException>(() => project.ReorderSourceFiles([@"C:\invalid source file", sourceFileFullPath2, sourceFileFullPath3, sourceFileFullPath4, sourceFileFullPath5])); 317Assert.Throws<ArgumentOutOfRangeException>(() => project.ReorderSourceFiles([])); 318Assert.Throws<ArgumentOutOfRangeException>(() => project.ReorderSourceFiles(null)); 337Assert.Throws<ArgumentException>(() => project.ReorderSourceFiles([sourceFileFullPath4, sourceFileFullPath5])); 338Assert.Throws<ArgumentException>(() => project.ReorderSourceFiles([@"C:\invalid source file"])); // no files were added, therefore we should get an argument exception 339Assert.Throws<ArgumentOutOfRangeException>(() => project.ReorderSourceFiles([])); 340Assert.Throws<ArgumentOutOfRangeException>(() => project.ReorderSourceFiles(null)); 345Assert.Throws<ArgumentException>(() => project.ReorderSourceFiles([sourceFileFullPath4, sourceFileFullPath5])); 346Assert.Throws<InvalidOperationException>(() => project.ReorderSourceFiles([@"C:\invalid source file"])); 347Assert.Throws<ArgumentOutOfRangeException>(() => project.ReorderSourceFiles([])); 348Assert.Throws<ArgumentOutOfRangeException>(() => project.ReorderSourceFiles(null)); 361Assert.Throws<ArgumentException>(() => project.ReorderSourceFiles([sourceFileFullPath4, sourceFileFullPath5])); 362Assert.Throws<InvalidOperationException>(() => project.ReorderSourceFiles([@"C:\invalid source file", sourceFileFullPath2, sourceFileFullPath3, sourceFileFullPath4, sourceFileFullPath5])); 363Assert.Throws<ArgumentOutOfRangeException>(() => project.ReorderSourceFiles([])); 364Assert.Throws<ArgumentOutOfRangeException>(() => project.ReorderSourceFiles(null)); 386Assert.Throws<InvalidOperationException>(() => project.ReorderSourceFiles([sourceFileFullPath2]));

30Assert.Throws<NotSupportedException>(image.EndInit); 76Assert.Throws<NotSupportedException>(image.EndInit);

118MessageSecurityException exception = Assert.Throws<MessageSecurityException>(() => 178ArgumentException exception = Assert.Throws<ArgumentException>(() =>

337Assert.Throws<SecurityNegotiationException>(() => { _ = serviceProxy.Echo(testString); });

86Assert.Throws<System.ServiceModel.ProtocolException>(() => { result = serviceProxy.Echo(testString); });

36var exception = Assert.Throws<MessageSecurityException>(() =>

221Assert.Throws<TimeoutException>(() =>

37Assert.Throws<NotSupportedException>(() => dict.Add(1, "One")); 48Assert.Throws<NotSupportedException>(() => dict.Add(1, "One")); 60Assert.Throws<NotSupportedException>(() => coll.Add(new KeyValuePair<int, string>(1, "One")));

57Assert.Throws<NotSupportedException>(() => coll.Add(1));

556var exception = Assert.Throws<IOException>(() => host.Start()); 591var exception = Assert.Throws<IOException>(() => host.Start()); 758Assert.Throws<InvalidOperationException>(() => host.Start()); 783Assert.Throws<InvalidOperationException>(() => host.Start()); 973var exception = Assert.Throws<IOException>(() => host.Start());

36Assert.Throws<PlatformNotSupportedException>(() =>

23Assert.Throws <PlatformNotSupportedException>(() => 35Assert.Throws<PlatformNotSupportedException>(() =>

316InvalidOperationException actualException = Assert.Throws<InvalidOperationException>(() => 343InvalidOperationException actualException = Assert.Throws<InvalidOperationException>(() => 368InvalidOperationException actualException = Assert.Throws<InvalidOperationException>(() => 399InvalidOperationException actualException = Assert.Throws<InvalidOperationException>(() =>

56Assert.Throws<ArgumentException>(() =>

245InvalidOperationException actualException = Assert.Throws<InvalidOperationException>(() => 299InvalidOperationException actualException = Assert.Throws<InvalidOperationException>(() => 623Assert.Throws<InvalidOperationException>(() => ((IClientChannel)channel).Open()); 676Assert.Throws<InvalidOperationException>(() => ((IClientChannel)channel).DisplayInitializationUI());

30var exception = Assert.Throws<InvalidOperationException>(() => 43var exception = Assert.Throws<InvalidOperationException>(() =>

66Assert.Throws<ArgumentNullException>(() => sts.WriteToken(null, null)); 67Assert.Throws<ArgumentNullException>(() => sts.WriteKeyIdentifier(null, null)); 68Assert.Throws<ArgumentNullException>(() => sts.WriteKeyIdentifierClause(null, null));

29Assert.Throws<InvalidOperationException>(() => factory.Open()); 59Assert.Throws<InvalidOperationException>(() => factory.Open()); 68Assert.Throws<InvalidOperationException>(() => factory.Open());

28Assert.Throws<InvalidOperationException>(() => 46Assert.Throws<UriFormatException>(() => 58Assert.Throws<UriFormatException>(() => 103var exception = Assert.Throws<InvalidOperationException>(() => 133Assert.Throws<InvalidOperationException>(() =>

96Assert.Throws<ArgumentOutOfRangeException>(() => 101Assert.Throws<ArgumentOutOfRangeException>(() => 106Assert.Throws<ArgumentOutOfRangeException>(() => 111Assert.Throws<ArgumentOutOfRangeException>(() => 118Assert.Throws<ArgumentOutOfRangeException>(() => 123Assert.Throws<ArgumentOutOfRangeException>(() =>

147Assert.Throws<NotSupportedException>(() => invoker.SetValue(instance, 1)); 154Assert.Throws<NotSupportedException>(() => invoker.SetValue(new object(), "value"));

85Assert.Throws<NotSupportedException>(() => invoker.AddToCollection(new object(), 1)); 92Assert.Throws<NotSupportedException>(() => invoker.AddToCollection(new object(), 1)); 99Assert.Throws<XamlSchemaException>(() => invoker.AddToCollection(new GetEnumeratorClass(), "a")); 135Assert.Throws<NotSupportedException>(() => invoker.AddToDictionary(new object(), 1, 2)); 142Assert.Throws<NotSupportedException>(() => invoker.AddToDictionary(new object(), 1, 2)); 149Assert.Throws<XamlSchemaException>(() => invoker.AddToDictionary(new GetEnumeratorClass(), new object(), "a"));

301Assert.Throws<InvalidOperationException>(() => reader.StartThread()); 316Assert.Throws<ObjectDisposedException>(() => reader.Close());

92Assert.Throws<NotSupportedException>(() => directive.Invoker.SetValue(null, null));

265Assert.Throws<ObjectDisposedException>(() => writer.WriteGetObject()); 295Assert.Throws<ObjectDisposedException>(() => writer.WriteStartObject(null)); 325Assert.Throws<ObjectDisposedException>(() => writer.WriteEndObject()); 355Assert.Throws<ObjectDisposedException>(() => writer.WriteStartMember(null)); 385Assert.Throws<ObjectDisposedException>(() => writer.WriteEndMember()); 415Assert.Throws<ObjectDisposedException>(() => writer.WriteValue(null)); 446Assert.Throws<ObjectDisposedException>(() => writer.WriteNamespace(null)); 542Assert.Throws<ObjectDisposedException>(() => consumer.SetLineInfo(1, 2));

121Assert.Throws<ObjectDisposedException>(() => writer.WriteGetObject()); 159Assert.Throws<ObjectDisposedException>(() => writer.WriteStartObject(null)); 188Assert.Throws<ObjectDisposedException>(() => writer.WriteEndObject()); 226Assert.Throws<ObjectDisposedException>(() => writer.WriteStartMember(null)); 255Assert.Throws<ObjectDisposedException>(() => writer.WriteEndMember()); 291Assert.Throws<ObjectDisposedException>(() => writer.WriteValue(null)); 329Assert.Throws<ObjectDisposedException>(() => writer.WriteNamespace(null)); 451Assert.Throws<ObjectDisposedException>(() => consumer.SetLineInfo(1, 2));

52Assert.Throws<XamlInternalException>(() => reader.Skip());

92Assert.Throws<NotImplementedException>(() => writer.WriteNode(reader));

381Assert.Throws<NullReferenceException>(() => CurrentChangingEventManager.AddHandler(null, handler)); 384Assert.Throws<NullReferenceException>(() => CurrentChangingEventManager.RemoveHandler(null, handler));

398Assert.Throws<NullReferenceException>(() => PropertyChangedEventManager.AddHandler(null, handler, "propertyName")); 401Assert.Throws<NullReferenceException>(() => PropertyChangedEventManager.AddHandler(null, handler, "propertyName"));

791Assert.Throws<NotSupportedException>(() => collection.Add(new SortDescription("Name", ListSortDirection.Ascending))); 792Assert.Throws<NotSupportedException>(() => collection.Insert(0, new SortDescription("Name", ListSortDirection.Ascending))); 793Assert.Throws<NotSupportedException>(() => collection.Clear());

419Assert.Throws<InvalidOperationException>(() => obj.ClearValue(property)); 429Assert.Throws<InvalidOperationException>(() => obj.ClearValue(property)); 784Assert.Throws<InvalidOperationException>(() => obj.ClearValue(key)); 1161Assert.Throws<NullReferenceException>(() => obj.CoerceValue(null!)); 1190Assert.Throws<ArgumentException>(() => obj.CoerceValue(property)); 1229Assert.Throws<ArgumentException>(() => obj.CoerceValue(property)); 1240Assert.Throws<InvalidOperationException>(() => obj.CoerceValue(property)); 1721Assert.Throws<InvalidOperationException>(() => obj.InvalidateProperty(property)); 1752Assert.Throws<ArgumentException>(() => obj.InvalidateProperty(property)); 1757Assert.Throws<ArgumentException>(() => obj.InvalidateProperty(property)); 2394Assert.Throws<InvalidOperationException>(() => obj.SetValue(property, "value")); 2406Assert.Throws<ArgumentException>(() => obj.SetValue(property, value)); 2417Assert.Throws<ArgumentException>(() => obj.SetValue(property, value)); 2433Assert.Throws<ArgumentException>(() => obj.SetValue(property, value)); 2443Assert.Throws<InvalidOperationException>(() => obj.SetValue(property, "value")); 2829Assert.Throws<ArgumentException>(() => obj.SetValue(key, value)); 2840Assert.Throws<ArgumentException>(() => obj.SetValue(key, value)); 2856Assert.Throws<ArgumentException>(() => obj.SetValue(key, value)); 2866Assert.Throws<InvalidOperationException>(() => obj.SetValue(key, "value"));

43Assert.Throws<ArgumentException>(() => key.OverrideMetadata(forType, new PropertyMetadata())); 58Assert.Throws<ArgumentException>(() => key.OverrideMetadata(typeof(int), property.DefaultMetadata)); 65Assert.Throws<ArgumentException>(() => key.OverrideMetadata(typeof(DependencyObject), new PropertyMetadata()));

58Assert.Throws<InvalidOperationException>(() => freezable.Changed += handler); 59Assert.Throws<InvalidOperationException>(() => freezable.Changed += null); 60Assert.Throws<InvalidOperationException>(() => freezable.Changed -= handler); 61Assert.Throws<InvalidOperationException>(() => freezable.Changed -= null); 74Assert.Throws<InvalidOperationException>(() => freezable.Changed += handler); 75Assert.Throws<InvalidOperationException>(() => freezable.Changed += null); 76Assert.Throws<InvalidOperationException>(() => freezable.Changed -= handler); 77Assert.Throws<InvalidOperationException>(() => freezable.Changed -= null); 91Assert.Throws<InvalidOperationException>(() => freezable.Changed += handler); 92Assert.Throws<InvalidOperationException>(() => freezable.Changed += null); 93Assert.Throws<InvalidOperationException>(() => freezable.Changed -= handler); 94Assert.Throws<InvalidOperationException>(() => freezable.Changed -= null); 815Assert.Throws<InvalidOperationException>(() => obj.ClearValue(property)); 825Assert.Throws<InvalidOperationException>(() => obj.ClearValue(property)); 835Assert.Throws<InvalidOperationException>(() => obj.ClearValue(property)); 848Assert.Throws<InvalidOperationException>(() => obj.ClearValue(property)); 1290Assert.Throws<InvalidOperationException>(() => obj.ClearValue(key)); 1301Assert.Throws<InvalidOperationException>(() => obj.ClearValue(key)); 1314Assert.Throws<InvalidOperationException>(() => obj.ClearValue(key)); 1911Assert.Throws<InvalidOperationException>(() => freezable.CloneCore(sourceFreezable)); 1995Assert.Throws<InvalidOperationException>(() => freezable.CloneCore(sourceFreezable)); 2085Assert.Throws<InvalidOperationException>(() => freezable.CloneCore(sourceFreezable)); 2175Assert.Throws<InvalidOperationException>(() => freezable.CloneCore(sourceFreezable)); 2201Assert.Throws<NullReferenceException>(() => freezable.CloneCore(null!)); 2794Assert.Throws<InvalidOperationException>(() => freezable.CloneCurrentValueCore(sourceFreezable)); 2879Assert.Throws<InvalidOperationException>(() => freezable.CloneCurrentValueCore(sourceFreezable)); 2970Assert.Throws<InvalidOperationException>(() => freezable.CloneCurrentValueCore(sourceFreezable)); 3061Assert.Throws<InvalidOperationException>(() => freezable.CloneCurrentValueCore(sourceFreezable)); 3087Assert.Throws<NullReferenceException>(() => freezable.CloneCurrentValueCore(null!)); 3564Assert.Throws<NullReferenceException>(() => obj.CoerceValue(null!)); 3593Assert.Throws<ArgumentException>(() => obj.CoerceValue(property)); 3632Assert.Throws<ArgumentException>(() => obj.CoerceValue(property)); 3659Assert.Throws<InvalidOperationException>(() => obj.CoerceValue(property)); 3819Assert.Throws<InvalidOperationException>(() => freezable.Freeze()); 3843Assert.Throws<InvalidOperationException>(() => freezable.Freeze()); 4017Assert.Throws<InvalidOperationException>(() => freezable.Freeze()); 4063Assert.Throws<InvalidOperationException>(() => freezable.Freeze()); 4907Assert.Throws<InvalidOperationException>(() => freezable.GetAsFrozenCore(sourceFreezable)); 4992Assert.Throws<InvalidOperationException>(() => freezable.GetAsFrozenCore(sourceFreezable)); 5083Assert.Throws<InvalidOperationException>(() => freezable.GetAsFrozenCore(sourceFreezable)); 5174Assert.Throws<InvalidOperationException>(() => freezable.GetAsFrozenCore(sourceFreezable)); 5200Assert.Throws<NullReferenceException>(() => freezable.GetAsFrozenCore(null!)); 5760Assert.Throws<InvalidOperationException>(() => freezable.GetCurrentValueAsFrozenCore(sourceFreezable)); 5845Assert.Throws<InvalidOperationException>(() => freezable.GetCurrentValueAsFrozenCore(sourceFreezable)); 5936Assert.Throws<InvalidOperationException>(() => freezable.GetCurrentValueAsFrozenCore(sourceFreezable)); 6026Assert.Throws<InvalidOperationException>(() => freezable.GetCurrentValueAsFrozenCore(sourceFreezable)); 6051Assert.Throws<NullReferenceException>(() => freezable.GetCurrentValueAsFrozenCore(null!)); 6235Assert.Throws<InvalidOperationException>(() => freezable.ReadPreamble()); 6364Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(null!, value1)); 6365Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(null!, value3)); 6368Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value1, value3)); 6370Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value2, value1)); 6371Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value2, value3)); 6373Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value3, value1)); 6419Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(null!, value1)); 6420Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(null!, value3)); 6423Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value1, value3)); 6425Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value2, value1)); 6426Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value2, value3)); 6428Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value3, value1)); 6540Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(null!, value1, property)); 6541Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(null!, value3, property)); 6544Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value1, value3, property)); 6546Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value2, value1, property)); 6547Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value2, value3, property)); 6549Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value3, value1, property)); 6597Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(null!, value1, property)); 6598Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(null!, value3, property)); 6601Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value1, value3, property)); 6603Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value2, value1, property)); 6604Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value2, value3, property)); 6606Assert.Throws<InvalidOperationException>(() => freezable.OnFreezablePropertyChanged(value3, value1, property)); 6807Assert.Throws<InvalidOperationException>(() => obj.SetValue(property, "value")); 6819Assert.Throws<ArgumentException>(() => obj.SetValue(property, value)); 6830Assert.Throws<ArgumentException>(() => obj.SetValue(property, value)); 6846Assert.Throws<ArgumentException>(() => obj.SetValue(property, value)); 6858Assert.Throws<InvalidOperationException>(() => freezable.SetValue(property, true)); 6862Assert.Throws<InvalidOperationException>(() => freezable.SetValue(property, true)); 6866Assert.Throws<InvalidOperationException>(() => freezable.SetValue(property, false)); 6879Assert.Throws<InvalidOperationException>(() => freezable.SetValue(property, value)); 6894Assert.Throws<InvalidOperationException>(() => freezable.SetValue(property, value)); 7244Assert.Throws<InvalidOperationException>(() => freezable.WritePreamble()); 7247Assert.Throws<InvalidOperationException>(() => freezable.WritePreamble()); 7256Assert.Throws<InvalidOperationException>(() => freezable.WritePreamble()); 7268Assert.Throws<InvalidOperationException>(() => freezable.WritePreamble());

1231Assert.Throws<InvalidOperationException>(() => matrix.Invert());

190Assert.Throws<ArgumentException>(() => nameScope.Add(string.Empty, scopedElement)); 303Assert.Throws<ArgumentNullException>(() => nameScope.Add(null, scopedElement)); 311Assert.Throws<ArgumentException>(() => nameScope.Add(string.Empty, scopedElement)); 322Assert.Throws<ArgumentException>(() => nameScope.Add(name, scopedElement)); 405Assert.Throws<ArgumentException>(() => nameScope.Add(new KeyValuePair<string, object>(string.Empty, scopedElement))); 416Assert.Throws<ArgumentException>(() => nameScope.Add(new KeyValuePair<string, object>(name, scopedElement))); 432Assert.Throws<ArgumentException>(() => nameScope.Add("name", new object())); 433Assert.Throws<ArgumentException>(() => nameScope.Add(new KeyValuePair<string, object>("name", new object()))); 532Assert.Throws<NullReferenceException>(() => nameScope.CopyTo(null, 0)); 543Assert.Throws<IndexOutOfRangeException>(() => nameScope.CopyTo(array, 0)); 554Assert.Throws<IndexOutOfRangeException>(() => nameScope.CopyTo(array, -1)); 555Assert.Throws<IndexOutOfRangeException>(() => nameScope.CopyTo(array, 1)); 908Assert.Throws<ArgumentException>(() => nameScope.RegisterName(string.Empty, scopedElement)); 919Assert.Throws<ArgumentException>(() => nameScope.RegisterName(name, scopedElement)); 935Assert.Throws<ArgumentException>(() => nameScope.RegisterName("name", new object())); 1136Assert.Throws<ArgumentException>(() => nameScope.UnregisterName("name")); 1152Assert.Throws<ArgumentException>(() => nameScope.UnregisterName(string.Empty)); 1168Assert.Throws<ArgumentException>(() => nameScope.UnregisterName(name)); 1186Assert.Throws<ArgumentException>(() => nameScope.UnregisterName(name));

507Assert.Throws<InvalidOperationException>(() => metadata.Merge(new PropertyMetadata(), null!));

1807Assert.Throws<InvalidOperationException>(() => Rect.Empty.Inflate(0, 0)); 1808Assert.Throws<InvalidOperationException>(() => Rect.Empty.Inflate(new Size(0, 0))); 2752Assert.Throws<InvalidOperationException>(() => Rect.Empty.Offset(0, 0)); 2753Assert.Throws<InvalidOperationException>(() => Rect.Empty.Offset(new Vector(0, 0)));

71Assert.Throws<MissingManifestResourceException>(() => splashScreen.Show(false)); 72Assert.Throws<MissingManifestResourceException>(() => splashScreen.Show(true)); 73Assert.Throws<MissingManifestResourceException>(() => splashScreen.Show(false, false)); 74Assert.Throws<MissingManifestResourceException>(() => splashScreen.Show(false, true)); 75Assert.Throws<MissingManifestResourceException>(() => splashScreen.Show(true, false)); 76Assert.Throws<MissingManifestResourceException>(() => splashScreen.Show(true, true));

131Assert.Throws<ArgumentNullException>(() => awaiter.OnCompleted(null)); 139Assert.Throws<InvalidOperationException>(() => awaiter.OnCompleted(null)); 140Assert.Throws<InvalidOperationException>(() => awaiter.OnCompleted(() => { })); 147Assert.Throws<InvalidOperationException>(() => awaiter.OnCompleted(null)); 148Assert.Throws<InvalidOperationException>(() => awaiter.OnCompleted(() => { }));

83Assert.Throws<InvalidEnumArgumentException>(() => Dispatcher.ValidatePriority(priority, null));

337Assert.Throws<InvalidCastException>(() => manager.DeliverEvent(source, args)); 352Assert.Throws<InvalidCastException>(() => manager.DeliverEvent(source, args)); 368Assert.Throws<InvalidCastException>(() => manager.DeliverEvent(source, args)); 425Assert.Throws<InvalidCastException>(() => manager.DeliverEvent(source, args)); 612Assert.Throws<InvalidCastException>(() => manager.DeliverEventToList(sender, args, list)); 625Assert.Throws<InvalidCastException>(() => manager.DeliverEventToList(sender, args, list)); 639Assert.Throws<InvalidCastException>(() => manager.DeliverEventToList(sender, args, list)); 1237Assert.Throws<InvalidCastException>(() => manager.ProtectedAddHandler(source, handler)); 1602Assert.Throws<InvalidCastException>(() => manager.ProtectedAddListener(source, listener)); 2141Assert.Throws<InvalidCastException>(() => manager.ProtectedRemoveHandler(source, handler)); 2565Assert.Throws<InvalidCastException>(() => manager.ProtectedRemoveListener(source, listener)); 3912Assert.Throws<NullReferenceException>(() => list.AddHandler(null)); 4294Assert.Throws<NullReferenceException>(() => list.CopyTo(null!)); 5641Assert.Throws<NullReferenceException>(() => list.RemoveHandler(null));

189Assert.Throws<NullReferenceException>(() => WeakEventManager<object, EventArgs>.AddHandler(new object(), null, (sender, e) => { })); 192Assert.Throws<NullReferenceException>(() => WeakEventManager<object, EventArgs>.AddHandler(new object(), null, (sender, e) => { })); 213Assert.Throws<ArgumentException>(() => WeakEventManager<object, EventArgs>.AddHandler(source, eventName, handler)); 216Assert.Throws<ArgumentException>(() => WeakEventManager<object, EventArgs>.AddHandler(source, eventName, handler)); 351Assert.Throws<NullReferenceException>(() => WeakEventManager<object, EventArgs>.RemoveHandler(new object(), null, (sender, e) => { })); 372Assert.Throws<ArgumentException>(() => WeakEventManager<object, EventArgs>.RemoveHandler(source, eventName, handler)); 375Assert.Throws<ArgumentException>(() => WeakEventManager<object, EventArgs>.RemoveHandler(source, eventName, handler));

141 var ex = Throws<T>(testCode);