Throws

ResultsTests.cs (17)

TypedResultsTests.cs (21)

ValidationProblemResultTests.cs (2)

83Assert.Throws<ArgumentNullException>("problemDetails", () => new ValidationProblem(null)); 89Assert.Throws<ArgumentException>("problemDetails", () => new ValidationProblem(

HttpServiceCollectionExtensionsTests.cs (1)

28Assert.Throws<ArgumentNullException>("services", () => HttpServiceCollectionExtensions.AddHttpContextAccessor(null));

UserStoreTest.cs (1)

105Assert.Throws<ArgumentNullException>("context", () => new UserStore(null));

RoleManagerTest.cs (1)

123Assert.Throws<ArgumentNullException>("store",

SignInManagerTest.cs (3)

28Assert.Throws<ArgumentNullException>("userManager", () => new SignInManager<PocoUser>(null, null, null, null, null, null, null)); 30Assert.Throws<ArgumentNullException>("contextAccessor", () => new SignInManager<PocoUser>(userManager, null, null, null, null, null, null)); 34Assert.Throws<ArgumentNullException>("claimsFactory", () => new SignInManager<PocoUser>(userManager, contextAccessor.Object, null, null, null, null, null));

UserClaimsPrincipalFactoryTest.cs (1)

18Assert.Throws<ArgumentException>("optionsAccessor",

UserManagerTest.cs (1)

1350Assert.Throws<ArgumentNullException>("store",

Formatters\FormatterMappingsTest.cs (1)

20Assert.Throws<ArgumentException>("format", () => options.GetMediaTypeMappingForFormat(format));

Formatters\MediaTypeTest.cs (3)

108Assert.Throws<ArgumentNullException>("mediaType", () => new MediaType(null, 0, 2)); 117Assert.Throws<ArgumentOutOfRangeException>("offset", () => new MediaType("media", offset, 5)); 124Assert.Throws<ArgumentOutOfRangeException>("length", () => new MediaType("media", 0, -1));

TagHelpers\ReadOnlyTagHelperAttributeListTest.cs (1)

115var exception = Assert.Throws<ArgumentOutOfRangeException>("index", () => attributes[index]);

TagHelpers\TagHelperAttributeListTest.cs (1)

86var exception = Assert.Throws<ArgumentOutOfRangeException>("index", () => attributes[index]);

RequestBodyTests.cs (6)

129Assert.Throws<ArgumentNullException>("buffer", () => httpContext.Request.Body.Read(null, 0, 1)); 130Assert.Throws<ArgumentOutOfRangeException>("offset", () => httpContext.Request.Body.Read(input, -1, 1)); 131Assert.Throws<ArgumentOutOfRangeException>("count", () => httpContext.Request.Body.Read(input, input.Length + 1, 1)); 132Assert.Throws<ArgumentOutOfRangeException>("count", () => httpContext.Request.Body.Read(input, 10, -1)); 133Assert.Throws<ArgumentOutOfRangeException>("count", () => httpContext.Request.Body.Read(input, 1, input.Length)); 134Assert.Throws<ArgumentOutOfRangeException>("count", () => httpContext.Request.Body.Read(input, 0, input.Length + 1));

QueryHelpersTests.cs (1)

107Assert.Throws<ArgumentNullException>("value", () => QueryHelpers.AddQueryString("http://contoso.com/", "hello", null!));

IOperation\IOperationTests_ICompoundAssignmentOperation.cs (2)

24Assert.Throws<ArgumentNullException>("compoundAssignment", () => nullAssignment.GetInConversion()); 25Assert.Throws<ArgumentNullException>("compoundAssignment", () => nullAssignment.GetOutConversion());

Semantics\AwaitExpressionTests.cs (2)

712Assert.Throws<ArgumentException>("node", () => model.GetAwaitExpressionInfo(usingDeclaration)); 738Assert.Throws<ArgumentException>("node", () => model.GetAwaitExpressionInfo(usingStatement));

Compilation\CompilationAPITests.cs (27)

Symbols\FunctionPointerTypeSymbolTests.cs (5)

1526Assert.Throws<ArgumentNullException>("returnType", () => comp.CreateFunctionPointerTypeSymbol(returnType: null!, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty)); 1527Assert.Throws<ArgumentNullException>("parameterTypes", () => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: default, parameterRefKinds: ImmutableArray<RefKind>.Empty)); 1528Assert.Throws<ArgumentNullException>("parameterTypes[0]", () => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray.Create((ITypeSymbol?)null)!, parameterRefKinds: ImmutableArray.Create(RefKind.None))); 1529Assert.Throws<ArgumentNullException>("parameterRefKinds", () => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: default)); 1530Assert.Throws<ArgumentNullException>("callingConventionTypes[0]", () => comp.CreateFunctionPointerTypeSymbol(returnType: @string, returnRefKind: RefKind.None, parameterTypes: ImmutableArray<ITypeSymbol>.Empty, parameterRefKinds: ImmutableArray<RefKind>.Empty, callingConvention: SignatureCallingConvention.Unmanaged, ImmutableArray.Create((INamedTypeSymbol)null!)));

ScriptOptionsTests.cs (39)

Compilation\TestOperationVisitor.cs (4)

1179Assert.Throws<ArgumentException>("compoundAssignment", () => VisualBasic.VisualBasicExtensions.GetInConversion(operation)); 1180Assert.Throws<ArgumentException>("compoundAssignment", () => VisualBasic.VisualBasicExtensions.GetOutConversion(operation)); 1186Assert.Throws<ArgumentException>("compoundAssignment", () => CSharp.CSharpExtensions.GetInConversion(operation)); 1187Assert.Throws<ArgumentException>("compoundAssignment", () => CSharp.CSharpExtensions.GetOutConversion(operation));

Analyzers\AnalyzerFileReferenceTests.cs (3)

47Assert.Throws<ArgumentNullException>("fullPath", () => new AnalyzerFileReference(null!, s_analyzerLoader)); 48Assert.Throws<ArgumentNullException>("assemblyLoader", () => new AnalyzerFileReference(TempRoot.Root, null!)); 51Assert.Throws<ArgumentException>("fullPath", () => new AnalyzerFileReference("a.dll", s_analyzerLoader));

Collections\HashSet\SegmentedHashSet_Generic_Tests`1.cs (5)

399Assert.Throws<ArgumentOutOfRangeException>("capacity", () => new SegmentedHashSet<T>(-1)); 400Assert.Throws<ArgumentOutOfRangeException>("capacity", () => new SegmentedHashSet<T>(int.MinValue)); 434Assert.Throws<ArgumentOutOfRangeException>("capacity", () => new SegmentedHashSet<T>(-1, comparer)); 435Assert.Throws<ArgumentOutOfRangeException>("capacity", () => new SegmentedHashSet<T>(int.MinValue, comparer)); 520Assert.Throws<ArgumentOutOfRangeException>("capacity", () => set.EnsureCapacity(-1));

Collections\ImmutableDictionaryTestBase.cs (2)

288Assert.Throws<ArgumentException>(null, () => map1.Add(key, value2)); 289Assert.Throws<ArgumentException>(null, () => map2.Add(key, value1));

Collections\ImmutableListTestBase.cs (1)

396Assert.Throws<ArgumentNullException>("comparison", () => this.SortTestHelper(ImmutableSegmentedList<int>.Empty, (Comparison<int>)null!));

Collections\ImmutableSegmentedDictionaryBuilderTest.cs (2)

219Assert.Throws<ArgumentException>(null, () => builder.KeyComparer = StringComparer.OrdinalIgnoreCase); 288Assert.Throws<ArgumentNullException>("builder", () => nullBuilder!.ToImmutableSegmentedDictionary());

Collections\ImmutableSegmentedDictionaryTest.cs (5)

150Assert.Throws<ArgumentNullException>("keySelector", () => list.ToImmutableSegmentedDictionary<int, int>(null!)); 151Assert.Throws<ArgumentNullException>("keySelector", () => list.ToImmutableSegmentedDictionary<int, int, int>(null!, v => v)); 152Assert.Throws<ArgumentNullException>("elementSelector", () => list.ToImmutableSegmentedDictionary<int, int, int>(k => k, null!)); 201Assert.Throws<ArgumentException>(null, () => map.WithComparer(StringComparer.OrdinalIgnoreCase)); 209var exception = Assert.Throws<ArgumentException>(null, () => map.Add("firstKey", "3"));

Collections\ImmutableSegmentedHashSetBuilderTest.cs (7)

212Assert.Throws<ArgumentNullException>("other", () => builder.IsProperSubsetOf(null!)); 221Assert.Throws<ArgumentNullException>("other", () => builder.IsProperSupersetOf(null!)); 230Assert.Throws<ArgumentNullException>("other", () => builder.IsSubsetOf(null!)); 240Assert.Throws<ArgumentNullException>("other", () => builder.IsSupersetOf(null!)); 250Assert.Throws<ArgumentNullException>("other", () => builder.Overlaps(null!)); 267Assert.Throws<ArgumentNullException>("other", () => builder.SetEquals(null!)); 340Assert.Throws<ArgumentNullException>("builder", () => nullBuilder!.ToImmutableSegmentedHashSet());

Collections\ImmutableSegmentedListBuilderTest.cs (5)

264Assert.Throws<ArgumentOutOfRangeException>("index", () => mutable[3] = 4); 265Assert.Throws<ArgumentOutOfRangeException>("index", () => mutable[-1] = 4); 266Assert.Throws<ArgumentOutOfRangeException>("index", () => mutable[3]); 267Assert.Throws<ArgumentOutOfRangeException>("index", () => mutable[-1]); 423Assert.Throws<ArgumentNullException>("builder", () => nullBuilder!.ToImmutableSegmentedList());

Collections\ImmutableSegmentedListTest.cs (28)

Collections\List\ICollection.Generic.Tests.cs (1)

468Assert.Throws<ArgumentNullException>("item", () => collection.Contains(default(T)!));

Collections\List\SegmentedList.Generic.Tests.BinarySearch.cs (2)

69Assert.Throws<ArgumentException>(null, () => list.BinarySearch(0, count + 1, element, GetIComparer())); //"Finding items longer than array should throw ArgumentException" 72Assert.Throws<ArgumentException>(null, () => list.BinarySearch(count + 1, count, element, GetIComparer())); //"ArgumentException should be thrown on index greater than length of array."

Collections\List\SegmentedList.Generic.Tests.Misc.cs (1)

305Assert.Throws<ArgumentException>(null, () =>

Collections\List\SegmentedList.Generic.Tests.Remove.cs (1)

63Assert.Throws<ArgumentNullException>("match", () => new SegmentedList<T>().RemoveAll(null!));

Collections\SegmentedArrayTests.cs (1)

96Assert.Throws<ArgumentOutOfRangeException>("length", () => new SegmentedArray<byte>(-1));

EmbeddedTextTests.cs (16)

Emit\SemanticEditTests.cs (13)

Simplifier\SimplifierTests.cs (6)

49Assert.Throws<ArgumentNullException>("node", () => Simplifier.Expand<SyntaxNode>(node: null!, semanticModel: null!, services: null!)); 50Assert.Throws<ArgumentNullException>("semanticModel", () => Simplifier.Expand(node, semanticModel: null!, services: null!)); 51Assert.Throws<ArgumentNullException>("services", () => Simplifier.Expand(node, semanticModel, services: null!)); 52Assert.Throws<ArgumentNullException>("workspace", () => Simplifier.Expand(node, semanticModel, workspace: null!)); 53Assert.Throws<ArgumentNullException>("workspace", () => Simplifier.Expand(token: default, semanticModel: null!, workspace: null!)); 54Assert.Throws<ArgumentNullException>("workspace", () => Simplifier.Expand(token: default, semanticModel, workspace: null!));

SolutionTests\ProjectDependencyGraphTests.cs (2)

117Assert.Throws<ArgumentNullException>("projectId", 339Assert.Throws<ArgumentNullException>("projectId",

SolutionTests\ProjectInfoTests.cs (6)

39Assert.Throws<ArgumentException>("documents[1]", 45Assert.Throws<ArgumentException>("additionalDocuments[1]", 52Assert.Throws<ArgumentException>("projectReferences[1]", 55Assert.Throws<ArgumentNullException>("analyzerReferences[0]", () => ProjectInfo.Create(pid, VersionStamp.Default, name: "Goo", assemblyName: "Bar", language: "C#", 59Assert.Throws<ArgumentException>("analyzerReferences[1]", 66Assert.Throws<ArgumentException>("metadataReferences[1]",

SolutionTests\SolutionTests.cs (52)

UtilityTest\SpecializedTasksTests.cs (2)

82Assert.Throws<ArgumentNullException>("func", () => SpecializedTasks.TransformWithoutIntermediateCancellationExceptionAsync(null!, transform, arg, cancellationToken)); 83Assert.Throws<ArgumentNullException>("transform", () => SpecializedTasks.TransformWithoutIntermediateCancellationExceptionAsync<StateType, IntermediateType, ResultType>(func, null!, arg, cancellationToken));

WorkspaceServiceTests\ReferenceCountedDisposableTests.cs (2)

20=> Assert.Throws<ArgumentNullException>("instance", () => new ReferenceCountedDisposable<IDisposable>(null)); 125=> Assert.Throws<ArgumentNullException>("reference", () => new ReferenceCountedDisposable<IDisposable>.WeakReference(null));

XxHash128Tests.cs (3)

22Assert.Throws<ArgumentNullException>("source", () => XxHash128.Hash(null)); 23Assert.Throws<ArgumentNullException>("source", () => XxHash128.Hash(null, 42)); 25Assert.Throws<ArgumentException>("destination", () => XxHash128.Hash(new byte[] { 1, 2, 3 }, new byte[7]));

AsyncCollectionAssertsTests.cs (3)

1384 Assert.Throws<ArgumentNullException>("collection", () => Assert.Single(default(IAsyncEnumerable<object>)!)); 1469 Assert.Throws<ArgumentNullException>("collection", () => Assert.Single(default(IAsyncEnumerable<object>)!, _ => true)); 1470 Assert.Throws<ArgumentNullException>("predicate", () => Assert.Single(new object[0].ToAsyncEnumerable(), null!));

CollectionAssertsTests.cs (4)

2281 Assert.Throws<ArgumentNullException>("collection", () => Assert.Single(null!)); 2416 Assert.Throws<ArgumentNullException>("collection", () => Assert.Single(default(IEnumerable<object>)!)); 2501 Assert.Throws<ArgumentNullException>("collection", () => Assert.Single(default(IEnumerable<object>)!, _ => true)); 2502 Assert.Throws<ArgumentNullException>("predicate", () => Assert.Single(new object[0], null!));

ExceptionAssertsTests.cs (15)

ChatCompletion\ChatClientExtensionsTests.cs (4)

17Assert.Throws<ArgumentNullException>("client", () => ChatClientExtensions.GetService<object>(null!)); 23Assert.Throws<ArgumentNullException>("client", () => ChatClientExtensions.GetRequiredService(null!, typeof(string))); 24Assert.Throws<ArgumentNullException>("client", () => ChatClientExtensions.GetRequiredService<object>(null!)); 27Assert.Throws<ArgumentNullException>("serviceType", () => client.GetRequiredService(null!));

ChatCompletion\ChatFinishReasonTests.cs (2)

21Assert.Throws<ArgumentNullException>("value", () => new ChatFinishReason(null!)); 22Assert.Throws<ArgumentException>("value", () => new ChatFinishReason(" "));

ChatCompletion\ChatResponseFormatTests.cs (4)

29Assert.Throws<ArgumentException>("schemaName", () => new ChatResponseFormatJson(null, "name")); 30Assert.Throws<ArgumentException>("schemaDescription", () => new ChatResponseFormatJson(null, null, "description")); 31Assert.Throws<ArgumentException>("schemaName", () => new ChatResponseFormatJson(null, "name", "description")); 93Assert.Throws<ArgumentNullException>("schemaType", () => ChatResponseFormat.ForJsonSchema(null!));

ChatCompletion\ChatResponseTests.cs (1)

27Assert.Throws<ArgumentNullException>("message", () => new ChatResponse((ChatMessage)null!));

ChatCompletion\ChatResponseUpdateExtensionsTests.cs (1)

21Assert.Throws<ArgumentNullException>("updates", () => ((List<ChatResponseUpdate>)null!).ToChatResponse());

ChatCompletion\ChatRoleTests.cs (2)

21Assert.Throws<ArgumentNullException>("value", () => new ChatRole(null!)); 22Assert.Throws<ArgumentException>("value", () => new ChatRole(" "));

ChatCompletion\DelegatingChatClientTests.cs (2)

17Assert.Throws<ArgumentNullException>("innerClient", () => new NoOpDelegatingChatClient(null!)); 95Assert.Throws<ArgumentNullException>("serviceType", () => delegating.GetService(null!));

Contents\DataContentTests.cs (1)

58Assert.Throws<ArgumentException>("mediaType", () => new DataContent("data:image/png;base64,aGVsbG8=", type));

Contents\FunctionApprovalRequestContentTests.cs (4)

18Assert.Throws<ArgumentNullException>("id", () => new FunctionApprovalRequestContent(null!, functionCall)); 19Assert.Throws<ArgumentException>("id", () => new FunctionApprovalRequestContent("", functionCall)); 20Assert.Throws<ArgumentException>("id", () => new FunctionApprovalRequestContent("\r\t\n ", functionCall)); 22Assert.Throws<ArgumentNullException>("functionCall", () => new FunctionApprovalRequestContent("id", null!));

Contents\FunctionApprovalResponseContentTests.cs (4)

17Assert.Throws<ArgumentNullException>("id", () => new FunctionApprovalResponseContent(null!, true, functionCall)); 18Assert.Throws<ArgumentException>("id", () => new FunctionApprovalResponseContent("", true, functionCall)); 19Assert.Throws<ArgumentException>("id", () => new FunctionApprovalResponseContent("\r\t\n ", true, functionCall)); 21Assert.Throws<ArgumentNullException>("functionCall", () => new FunctionApprovalResponseContent("id", true, null!));

Contents\FunctionCallContentTests.cs (4)

320Assert.Throws<ArgumentNullException>("encodedArguments", () => FunctionCallContent.CreateFromParsedArguments((string)null!, "callId", "functionName", _ => null)); 321Assert.Throws<ArgumentNullException>("callId", () => FunctionCallContent.CreateFromParsedArguments("{}", null!, "functionName", _ => null)); 322Assert.Throws<ArgumentNullException>("name", () => FunctionCallContent.CreateFromParsedArguments("{}", "callId", null!, _ => null)); 323Assert.Throws<ArgumentNullException>("argumentParser", () => FunctionCallContent.CreateFromParsedArguments("{}", "callId", "functionName", null!));

Contents\HostedFileContentTests.cs (7)

15Assert.Throws<ArgumentNullException>("fileId", () => new HostedFileContent(null!)); 16Assert.Throws<ArgumentException>("fileId", () => new HostedFileContent(string.Empty)); 17Assert.Throws<ArgumentException>("fileId", () => new HostedFileContent(" ")); 39Assert.Throws<ArgumentNullException>("value", () => c.FileId = null!); 40Assert.Throws<ArgumentException>("value", () => c.FileId = string.Empty); 41Assert.Throws<ArgumentException>("value", () => c.FileId = " "); 92Assert.Throws<ArgumentException>("value", () => c.MediaType = invalidMediaType);

Contents\HostedVectorStoreContentTests.cs (6)

15Assert.Throws<ArgumentNullException>("vectorStoreId", () => new HostedVectorStoreContent(null!)); 16Assert.Throws<ArgumentException>("vectorStoreId", () => new HostedVectorStoreContent(string.Empty)); 17Assert.Throws<ArgumentException>("vectorStoreId", () => new HostedVectorStoreContent(" ")); 38Assert.Throws<ArgumentNullException>("value", () => c.VectorStoreId = null!); 39Assert.Throws<ArgumentException>("value", () => c.VectorStoreId = string.Empty); 40Assert.Throws<ArgumentException>("value", () => c.VectorStoreId = " ");

Contents\McpServerToolCallContentTests.cs (4)

54Assert.Throws<ArgumentException>("callId", () => new McpServerToolCallContent(string.Empty, "name", null)); 55Assert.Throws<ArgumentException>("toolName", () => new McpServerToolCallContent("callId1", string.Empty, null)); 57Assert.Throws<ArgumentNullException>("callId", () => new McpServerToolCallContent(null!, "name", null)); 58Assert.Throws<ArgumentNullException>("toolName", () => new McpServerToolCallContent("callId1", null!, null));

Contents\McpServerToolResultContentTests.cs (2)

49Assert.Throws<ArgumentException>("callId", () => new McpServerToolResultContent(string.Empty)); 50Assert.Throws<ArgumentNullException>("callId", () => new McpServerToolResultContent(null!));

Contents\UriContentTests.cs (12)

Contents\UsageContentTests.cs (2)

15Assert.Throws<ArgumentNullException>("details", () => new UsageContent(null!)); 57Assert.Throws<ArgumentNullException>("value", () => c.Details = null!);

Contents\UserInputRequestContentTests.cs (3)

17Assert.Throws<ArgumentNullException>("id", () => new TestUserInputRequestContent(null!)); 18Assert.Throws<ArgumentException>("id", () => new TestUserInputRequestContent("")); 19Assert.Throws<ArgumentException>("id", () => new TestUserInputRequestContent("\r\t\n "));

Contents\UserInputResponseContentTests.cs (3)

15Assert.Throws<ArgumentNullException>("id", () => new TestUserInputResponseContent(null!)); 16Assert.Throws<ArgumentException>("id", () => new TestUserInputResponseContent("")); 17Assert.Throws<ArgumentException>("id", () => new TestUserInputResponseContent("\r\t\n "));

Embeddings\DelegatingEmbeddingGeneratorTests.cs (2)

17Assert.Throws<ArgumentNullException>("innerGenerator", () => new NoOpDelegatingEmbeddingGenerator(null!)); 56Assert.Throws<ArgumentNullException>("serviceType", () => delegating.GetService(null!));

Embeddings\EmbeddingGenerationOptionsTests.cs (2)

30Assert.Throws<ArgumentOutOfRangeException>("value", () => options.Dimensions = 0); 31Assert.Throws<ArgumentOutOfRangeException>("value", () => options.Dimensions = -1);

Embeddings\EmbeddingGeneratorExtensionsTests.cs (3)

16Assert.Throws<ArgumentNullException>("generator", () => EmbeddingGeneratorExtensions.GetService<object>(null!)); 22Assert.Throws<ArgumentNullException>("generator", () => EmbeddingGeneratorExtensions.GetRequiredService<object>(null!)); 25Assert.Throws<ArgumentNullException>("serviceType", () => generator.GetRequiredService(null!));

Embeddings\GeneratedEmbeddingsTests.cs (8)

20Assert.Throws<ArgumentNullException>("embeddings", () => new GeneratedEmbeddings<Embedding<float>>(null!)); 21Assert.Throws<ArgumentOutOfRangeException>("capacity", () => new GeneratedEmbeddings<Embedding<float>>(-1)); 50Assert.Throws<ArgumentOutOfRangeException>("index", () => instance[0]); 51Assert.Throws<ArgumentOutOfRangeException>("index", () => instance[-1]); 81Assert.Throws<ArgumentOutOfRangeException>("index", () => generatedEmbeddings[-1]); 82Assert.Throws<ArgumentOutOfRangeException>("index", () => generatedEmbeddings[2]); 244Assert.Throws<ArgumentOutOfRangeException>("index", () => embeddings[-1]); 245Assert.Throws<ArgumentOutOfRangeException>("index", () => embeddings[2]);

Functions\ApprovalRequiredAIFunctionTests.cs (1)

15Assert.Throws<ArgumentNullException>("innerFunction", () => new ApprovalRequiredAIFunction(null!));

Functions\DelegatingAIFunctionTests.cs (1)

17Assert.Throws<ArgumentNullException>("innerFunction", () => new DerivedFunction(null!));

Image\DelegatingImageGeneratorTests.cs (2)

16Assert.Throws<ArgumentNullException>("innerGenerator", () => new NoOpDelegatingImageGenerator(null!)); 56Assert.Throws<ArgumentNullException>("serviceType", () => delegating.GetService(null!));

SpeechToText\DelegatingSpeechToTextClientTests.cs (2)

18Assert.Throws<ArgumentNullException>("innerClient", () => new NoOpDelegatingSpeechToTextClient(null!)); 96Assert.Throws<ArgumentNullException>("serviceType", () => delegating.GetService(null!));

SpeechToText\SpeechToTextResponseTests.cs (2)

17Assert.Throws<ArgumentNullException>("contents", () => new SpeechToTextResponse((IList<AIContent>)null!)); 64Assert.Throws<ArgumentNullException>("contents", () => new SpeechToTextResponse((IList<AIContent>)null!));

SpeechToText\SpeechToTextResponseUpdateExtensionsTests.cs (1)

38Assert.Throws<ArgumentNullException>("updates", () => ((List<SpeechToTextResponseUpdate>)null!).ToSpeechToTextResponse());

SpeechToText\SpeechToTextResponseUpdateKindTests.cs (2)

21Assert.Throws<ArgumentNullException>("value", () => new SpeechToTextResponseUpdateKind(null!)); 22Assert.Throws<ArgumentException>("value", () => new SpeechToTextResponseUpdateKind(" "));

Tools\AIToolTests.cs (1)

26Assert.Throws<ArgumentNullException>("serviceType", () => tool.GetService(null!));

Tools\HostedMcpServerToolTests.cs (8)

Utilities\AIJsonSchemaTransformCacheTests.cs (4)

15Assert.Throws<ArgumentNullException>("transformOptions", () => new AIJsonSchemaTransformCache(transformOptions: null!)); 21Assert.Throws<ArgumentException>("transformOptions", () => new AIJsonSchemaTransformCache(transformOptions: new())); 36Assert.Throws<ArgumentNullException>("function", () => cache.GetOrCreateTransformedSchema(function: null!)); 43Assert.Throws<ArgumentNullException>("responseFormat", () => cache.GetOrCreateTransformedSchema(responseFormat: null!));

Utilities\AIJsonUtilitiesTests.cs (3)

1402Assert.Throws<ArgumentNullException>("transformOptions", () => AIJsonUtilities.TransformSchema(schema, transformOptions: null!)); 1403Assert.Throws<ArgumentException>("transformOptions", () => AIJsonUtilities.TransformSchema(schema, transformOptions: new())); 1416Assert.Throws<ArgumentException>("schema", () => AIJsonUtilities.TransformSchema(schema, transformOptions));

AzureAIInferenceChatClientTests.cs (2)

30Assert.Throws<ArgumentNullException>("chatCompletionsClient", () => ((ChatCompletionsClient)null!).AsIChatClient("model")); 33Assert.Throws<ArgumentException>("defaultModelId", () => client.AsIChatClient(" "));

AzureAIInferenceEmbeddingGeneratorTests.cs (2)

23Assert.Throws<ArgumentNullException>("embeddingsClient", () => ((EmbeddingsClient)null!).AsIEmbeddingGenerator()); 26Assert.Throws<ArgumentException>("defaultModelId", () => client.AsIEmbeddingGenerator(" "));

AzureAIInferenceImageEmbeddingGeneratorTests.cs (2)

23Assert.Throws<ArgumentNullException>("imageEmbeddingsClient", () => ((ImageEmbeddingsClient)null!).AsIEmbeddingGenerator()); 26Assert.Throws<ArgumentException>("defaultModelId", () => client.AsIEmbeddingGenerator(" "));

ToolReductionTests.cs (1)

19Assert.Throws<ArgumentOutOfRangeException>("toolLimit", () => new EmbeddingToolReductionStrategy(gen, toolLimit: 0));

OpenAIAssistantChatClientTests.cs (3)

21Assert.Throws<ArgumentNullException>("assistantClient", () => ((AssistantClient)null!).AsIChatClient("assistantId")); 22Assert.Throws<ArgumentNullException>("assistantId", () => new AssistantClient("ignored").AsIChatClient((string)null!)); 23Assert.Throws<ArgumentNullException>("assistant", () => new AssistantClient("ignored").AsIChatClient((Assistant)null!));

OpenAIChatClientTests.cs (1)

27Assert.Throws<ArgumentNullException>("chatClient", () => ((ChatClient)null!).AsIChatClient());

OpenAIConversionTests.cs (12)

OpenAIEmbeddingGeneratorTests.cs (1)

24Assert.Throws<ArgumentNullException>("embeddingClient", () => ((EmbeddingClient)null!).AsIEmbeddingGenerator());

OpenAIImageGeneratorTests.cs (1)

17Assert.Throws<ArgumentNullException>("imageClient", () => ((ImageClient)null!).AsIImageGenerator());

OpenAIResponseClientTests.cs (1)

31Assert.Throws<ArgumentNullException>("responseClient", () => ((OpenAIResponseClient)null!).AsIChatClient());

OpenAISpeechToTextClientTests.cs (1)

25Assert.Throws<ArgumentNullException>("audioClient", () => ((AudioClient)null!).AsISpeechToTextClient());

ChatCompletion\ChatClientBuilderTest.cs (3)

61Assert.Throws<ArgumentNullException>("innerClient", () => new ChatClientBuilder((IChatClient)null!)); 62Assert.Throws<ArgumentNullException>("innerClient", () => ((IChatClient)null!).AsBuilder()); 68Assert.Throws<ArgumentNullException>("innerClientFactory", () => new ChatClientBuilder((Func<IServiceProvider, IChatClient>)null!));

ChatCompletion\ConfigureOptionsChatClientTests.cs (3)

18Assert.Throws<ArgumentNullException>("innerClient", () => new ConfigureOptionsChatClient(null!, _ => { })); 19Assert.Throws<ArgumentNullException>("configure", () => new ConfigureOptionsChatClient(new TestChatClient(), null!)); 27Assert.Throws<ArgumentNullException>("configure", () => builder.ConfigureOptions(null!));

ChatCompletion\FunctionInvocationContextTests.cs (3)

37Assert.Throws<ArgumentNullException>("value", () => ctx.CallContent = null!); 38Assert.Throws<ArgumentNullException>("value", () => ctx.Messages = null!); 39Assert.Throws<ArgumentNullException>("value", () => ctx.Function = null!);

ChatCompletion\FunctionInvokingChatClientTests.cs (2)

26Assert.Throws<ArgumentNullException>("innerClient", () => new FunctionInvokingChatClient(null!)); 27Assert.Throws<ArgumentNullException>("builder", () => ((ChatClientBuilder)null!).UseFunctionInvocation());

ChatCompletion\ImageGeneratingChatClientTests.cs (3)

21Assert.Throws<ArgumentNullException>("innerClient", () => new ImageGeneratingChatClient(null!, imageGenerator)); 22Assert.Throws<ArgumentNullException>("imageGenerator", () => new ImageGeneratingChatClient(innerClient, null!)); 28Assert.Throws<ArgumentNullException>("builder", () => ((ChatClientBuilder)null!).UseImageGeneration());

ChatCompletion\LoggingChatClientTests.cs (2)

20Assert.Throws<ArgumentNullException>("innerClient", () => new LoggingChatClient(null!, NullLogger.Instance)); 21Assert.Throws<ArgumentNullException>("logger", () => new LoggingChatClient(new TestChatClient(), null!));

ChatCompletion\ReducingChatClientTests.cs (2)

19Assert.Throws<ArgumentNullException>("innerClient", () => new ReducingChatClient(null!, new TestReducer())); 27Assert.Throws<ArgumentNullException>("builder", () => ReducingChatClientBuilderExtensions.UseChatReducer(null!, new TestReducer()));

ChatCompletion\UseDelegateChatClientTests.cs (1)

22Assert.Throws<ArgumentNullException>("getResponseFunc", () => builder.Use(null!, null!));

ChatReduction\MessageCountingChatReducerTests.cs (1)

21Assert.Throws<ArgumentOutOfRangeException>(nameof(targetCount), () => new MessageCountingChatReducer(targetCount));

ChatReduction\SummarizingChatReducerTests.cs (3)

20Assert.Throws<ArgumentNullException>("chatClient", () => new SummarizingChatReducer(null!, targetCount: 5, threshold: 2)); 30Assert.Throws<ArgumentOutOfRangeException>(nameof(targetCount), () => new SummarizingChatReducer(chatClient, targetCount, threshold: 2)); 39Assert.Throws<ArgumentOutOfRangeException>("threshold", () => new SummarizingChatReducer(chatClient, targetCount: 5, thresholdCount));

Embeddings\ConfigureOptionsEmbeddingGeneratorTests.cs (3)

16Assert.Throws<ArgumentNullException>("innerGenerator", () => new ConfigureOptionsEmbeddingGenerator<string, Embedding<float>>(null!, _ => { })); 17Assert.Throws<ArgumentNullException>("configure", () => new ConfigureOptionsEmbeddingGenerator<string, Embedding<float>>(new TestEmbeddingGenerator(), null!)); 25Assert.Throws<ArgumentNullException>("configure", () => builder.ConfigureOptions(null!));

Embeddings\EmbeddingGeneratorBuilderTests.cs (3)

60Assert.Throws<ArgumentNullException>("innerGenerator", () => new EmbeddingGeneratorBuilder<string, Embedding<float>>((IEmbeddingGenerator<string, Embedding<float>>)null!)); 61Assert.Throws<ArgumentNullException>("innerGenerator", () => ((IEmbeddingGenerator<string, Embedding<float>>)null!).AsBuilder()); 67Assert.Throws<ArgumentNullException>("innerGeneratorFactory",

Embeddings\LoggingEmbeddingGeneratorTests.cs (2)

19Assert.Throws<ArgumentNullException>("innerGenerator", () => new LoggingEmbeddingGenerator<string, Embedding<float>>(null!, NullLogger.Instance)); 20Assert.Throws<ArgumentNullException>("logger", () => new LoggingEmbeddingGenerator<string, Embedding<float>>(new TestEmbeddingGenerator(), null!));

Embeddings\UseDelegateEmbeddingGeneratorTests.cs (1)

20Assert.Throws<ArgumentNullException>("generateFunc", () =>

Functions\AIFunctionFactoryTest.cs (8)

31Assert.Throws<ArgumentNullException>("method", () => AIFunctionFactory.Create(method: null!)); 32Assert.Throws<ArgumentNullException>("method", () => AIFunctionFactory.Create(method: null!, target: new object())); 33Assert.Throws<ArgumentNullException>("method", () => AIFunctionFactory.Create(method: null!, target: new object(), name: "myAiFunk")); 34Assert.Throws<ArgumentNullException>("target", () => AIFunctionFactory.Create(typeof(AIFunctionFactoryTest).GetMethod(nameof(InvalidArguments_Throw))!, (object?)null)); 35Assert.Throws<ArgumentNullException>("createInstanceFunc", () => 37Assert.Throws<ArgumentException>("method", () => AIFunctionFactory.Create(typeof(List<>).GetMethod("Add")!, new List<int>())); 523Assert.Throws<ArgumentException>("method", () => AIFunctionFactory.Create( 1087Assert.Throws<ArgumentNullException>("name", () => AIFunctionFactory.CreateDeclaration(null!, "description", default));

Image\ConfigureOptionsImageGeneratorTests.cs (3)

16Assert.Throws<ArgumentNullException>("innerGenerator", () => new ConfigureOptionsImageGenerator(null!, _ => { })); 17Assert.Throws<ArgumentNullException>("configure", () => new ConfigureOptionsImageGenerator(new TestImageGenerator(), null!)); 25Assert.Throws<ArgumentNullException>("configure", () => builder.ConfigureOptions(null!));

Image\ImageGeneratorBuilderTests.cs (3)

61Assert.Throws<ArgumentNullException>("innerGenerator", () => new ImageGeneratorBuilder((IImageGenerator)null!)); 62Assert.Throws<ArgumentNullException>("innerGenerator", () => ((IImageGenerator)null!).AsBuilder()); 68Assert.Throws<ArgumentNullException>("innerGeneratorFactory", () => new ImageGeneratorBuilder((Func<IServiceProvider, IImageGenerator>)null!));

Image\LoggingImageGeneratorTests.cs (2)

20Assert.Throws<ArgumentNullException>("innerGenerator", () => new LoggingImageGenerator(null!, NullLogger.Instance)); 21Assert.Throws<ArgumentNullException>("logger", () => new LoggingImageGenerator(new TestImageGenerator(), null!));

Image\OpenTelemetryImageGeneratorTests.cs (1)

20Assert.Throws<ArgumentNullException>("innerGenerator", () => new OpenTelemetryImageGenerator(null!));

SpeechToText\ConfigureOptionsSpeechToTextClientTests.cs (3)

19Assert.Throws<ArgumentNullException>("innerClient", () => new ConfigureOptionsSpeechToTextClient(null!, _ => { })); 20Assert.Throws<ArgumentNullException>("configure", () => new ConfigureOptionsSpeechToTextClient(new TestSpeechToTextClient(), null!)); 28Assert.Throws<ArgumentNullException>("configure", () => builder.ConfigureOptions(null!));

SpeechToText\LoggingSpeechToTextClientTests.cs (2)

22Assert.Throws<ArgumentNullException>("innerClient", () => new LoggingSpeechToTextClient(null!, NullLogger.Instance)); 23Assert.Throws<ArgumentNullException>("logger", () => new LoggingSpeechToTextClient(new TestSpeechToTextClient(), null!));

SpeechToText\OpenTelemetrySpeechToTextClientTests.cs (1)

23Assert.Throws<ArgumentNullException>("innerClient", () => new OpenTelemetrySpeechToTextClient(null!));

Chunkers\ChunkerOptionsTests.cs (8)

17Assert.Throws<ArgumentNullException>("tokenizer", () => new IngestionChunkerOptions(null!)); 43Assert.Throws<ArgumentOutOfRangeException>("value", () => options.MaxTokensPerChunk = 0); 44Assert.Throws<ArgumentOutOfRangeException>("value", () => options.MaxTokensPerChunk = -1); 47Assert.Throws<ArgumentOutOfRangeException>("value", () => options.OverlapTokens = -1); 66Assert.Throws<ArgumentOutOfRangeException>("value", () => options.OverlapTokens = 1000); 67Assert.Throws<ArgumentOutOfRangeException>("value", () => options.OverlapTokens = 1500); 75Assert.Throws<ArgumentOutOfRangeException>("value", () => options.MaxTokensPerChunk = 10); 76Assert.Throws<ArgumentOutOfRangeException>("value", () => options.MaxTokensPerChunk = 5);

IngestionDocumentTests.cs (2)

71=> Assert.Throws<ArgumentNullException>("markdown", () => new IngestionDocumentParagraph(input!)); 80Assert.Throws<ArgumentOutOfRangeException>("value", () => header.Level = level);

Processors\AlternativeTextEnricherTests.cs (1)

22Assert.Throws<ArgumentNullException>("options", () => new ImageAlternativeTextEnricher(null!));

Processors\ClassificationEnricherTests.cs (5)

23Assert.Throws<ArgumentNullException>("options", () => new ClassificationEnricher(null!, predefinedClasses: ["some"])); 29Assert.Throws<ArgumentException>("predefinedClasses", () => new ClassificationEnricher(new(new TestChatClient()), predefinedClasses: [])); 35Assert.Throws<ArgumentException>("predefinedClasses", () => new ClassificationEnricher(new(new TestChatClient()), predefinedClasses: ["same", "same"])); 41Assert.Throws<ArgumentException>("predefinedClasses", () => new ClassificationEnricher(new(new TestChatClient()), predefinedClasses: ["same", "Unknown"])); 47Assert.Throws<ArgumentException>("predefinedClasses", () => new ClassificationEnricher(new(new TestChatClient()), predefinedClasses: ["some"], fallbackClass: "some"));

Processors\KeywordEnricherTests.cs (4)

23Assert.Throws<ArgumentNullException>("options", () => new KeywordEnricher(null!, predefinedKeywords: null, confidenceThreshold: 0.5)); 31Assert.Throws<ArgumentOutOfRangeException>("confidenceThreshold", () => new KeywordEnricher(new(new TestChatClient()), predefinedKeywords: null, confidenceThreshold: threshold)); 39Assert.Throws<ArgumentOutOfRangeException>("maxKeywords", () => new KeywordEnricher(new(new TestChatClient()), predefinedKeywords: null, maxKeywords: keywordCount)); 45Assert.Throws<ArgumentException>("predefinedKeywords", () => new KeywordEnricher(new(new TestChatClient()), predefinedKeywords: ["same", "same"], confidenceThreshold: 0.5));

Processors\SentimentEnricherTests.cs (2)

23Assert.Throws<ArgumentNullException>("options", () => new SentimentEnricher(null!)); 31Assert.Throws<ArgumentOutOfRangeException>("confidenceThreshold", () => new SentimentEnricher(new(new TestChatClient()), confidenceThreshold: threshold));

Processors\SummaryEnricherTests.cs (2)

23Assert.Throws<ArgumentNullException>("options", () => new SummaryEnricher(null!)); 31Assert.Throws<ArgumentOutOfRangeException>("maxWordCount", () => new SummaryEnricher(new(new TestChatClient()), maxWordCount: wordCount));

Readers\MarkItDownMcpReaderTests.cs (1)

16Assert.Throws<ArgumentNullException>("mcpServerUri", () => new MarkItDownMcpReader(null!));

TimerTests.cs (8)