Microsoft.Copilot.Testing.Core

Gets or sets the response format for the chat completion. Use ChatResponseFormat.Json to force JSON output for structured responses.

Sub-agent responsible for extracting code location information from user prompts. Uses tools to explore the codebase and determine what code to test.

Prompts for the Code Location Extractor sub-agent.

Sub-agent responsible for extracting configuration settings from user prompts. Focuses on advanced options and settings without exploring the codebase.

Prompts for the Configuration Extractor sub-agent.

Agent that analyzes free-form user prompts and converts them into structured HeuristicsTestAgentManager.Context. Uses two parallel LLM calls: one for configuration extraction and one for code location extraction.

Contains tool definitions for the FreeFormPromptAnalyzerAgent.

Schema for code location extraction response.

Schema for configuration extraction response.

Shared context accessible by tools during execution.

Analyzes a user prompt and returns a structured context for test generation, or an error if the prompt is too ambiguous or confidence is low. Uses two parallel LLM calls: one for configuration extraction and one for code location extraction.

Result of deserializing LLM outputs from parallel extraction tasks.

Nested agent for extracting configuration from user prompts.

Nested agent for extracting code location information from user prompts.

Resolves a file path extracted by the LLM and validates it exists on disk. If the direct concatenation doesn't exist, searches the working directory for a matching file by name, scoring candidates by how many trailing path segments match the LLM-extracted path. Returns null if the file cannot be found anywhere with sufficient confidence.

Scores how well a candidate file path matches the LLM-extracted path by counting matching trailing path segments. Higher is better.

Resolves a potentially relative path from LLM tool input to an absolute path using the tool context's default search path as the base directory.

Result of analyzing a user prompt.

Analysis succeeded and returned a structured context.

Analysis failed due to low confidence or ambiguity.

JSON serialization context for FreeFormPromptAnalyzer schemas.

Defines the source generated JSON serialization contract metadata for a given type.

The default associated with a default instance.

The source-generated options associated with this context.

Summarizes large text output using an LLM, extracting the most important information.

Summarizes the provided output text, extracting key information based on the specified purpose.

The text content to summarize. A description of what information to focus on when summarizing. For example: "Extract error messages and stack traces from test output" or "Identify the root cause of the crash from stderr output". Cancellation token. Optional additional context to help guide the summarization. A summarized version of the output, or a truncated fallback if summarization fails.

Handles the situation when the maximum number of retries for LLM calls is exceeded.

The name of the agent that encountered the retries exceeded situation. The maximum number of retries that were attempted. The list of exceptions encountered during the retries.

Agent that analyzes suspected production bugs during test generation. Called as a subagent from ToolBasedCSharpCodeGenAgent via AnalyzePotentialBugTool. Uses shared tools from parent agent to avoid lock conflicts.

Analyzes a bug report to determine if it represents a production bug or test bug.

The bug report submitted by CodeGenAgent. Cancellation token. One-sentence summary of the analysis result.

Interface for build fixer agents that can be spawned when deadlock is detected.

Result of a build fixer run.

True if the build was fixed (build now succeeds). Agent's final message (either "OK" or summary of what's broken).

Result of a build fixer run.

True if the build was fixed (build now succeeds). Agent's final message (either "OK" or summary of what's broken).

True if the build was fixed (build now succeeds).

Agent's final message (either "OK" or summary of what's broken).

Agent that attempts to fix build errors. Spawned when deadlock is detected (all code gen agents waiting for build to succeed).

Runs the build fixer agent to attempt fixing build errors.

Result indicating success/failure and the agent's final message.

Builds annotated source content for tool-based code generation prompts. Uses absolute line numbers from syntax nodes and coverage data directly, bypassing the transformation flow that causes line number drift.

Creates annotated source content for a single member. Pure function: source content + original syntax node + coverage -> annotated string. Line numbers in output match the actual source file positions.

Creates annotated content for multiple members in a file. Members are separated by blank lines.

Orchestrates the build and fix workflow for generated test projects. This agent applies an ordered chain of diagnostic fixers recursively until the build succeeds or all fixers are exhausted. It handles MSBuild compilation, diagnostic extraction, and iterative application of fixes with commit points for each fixer.

Key responsibilities: - Builds test projects using MSBuild via IBuildService - Extracts compilation diagnostics from build results - Applies diagnostic fixers in a predefined order - Tracks which fixers modified which files to avoid infinite loops - Commits changes after each fixer for Git history tracking - Collects telemetry on fixer effectiveness

Initializes a new instance of BuildAgent with the required services and configuration.

Bundled core services for agent creation. Service for prompting the user for input. Helper for committing changes to source control. Service for building projects via MSBuild. Service for applying Roslyn code fixes. Service for managing NuGet packages. Service for Roslyn workspace operations. Degree of parallelism for operations like LLM-based fixing. If true, removes unfixable code; if false, comments it out. If true, includes LlmDiagnosticFixer in the fixer chain (expensive but powerful). Optional factory for custom fixer chains (primarily for testing).

Performs a simple build operation without attempting to fix any errors. This is used for validation scenarios where we only need to know if the build succeeds or fails.

Unlike RunBuildAndFixBuildErrorsAsync, this method does NOT apply any fixers. It's typically used after all fixes have been applied to validate the final state.

Orchestrates the full build-and-fix workflow: builds the project, applies fixers iteratively, and returns the set of files that were modified during the fixing process.

Success with the set of touched files if the build eventually succeeds, or Failure with error message and touched files if all fixers are exhausted.

Core algorithm: builds the project, extracts diagnostics, and recursively applies fixers until success or exhaustion. This is the entry point for the iterative fix workflow.

The test project to build and fix. Set of generated test files that are candidates for fixing. Telemetry activity for tracking the operation. True if this is the first build after code generation; false if fixing test failures. True if NuGet restore has already been performed; affects whether we skip restore. Cancellation token for aborting the operation. Tuple of: error message (null if successful), remaining diagnostics, and set of files that were modified.

Creates the default ordered chain of diagnostic fixers. The order is CRITICAL: fixers are applied sequentially, and each fixer may retry if it makes progress.

Strategy: 1. Start with cheap, non-destructive, high-precision fixers (e.g., add using statements) 2. Progress to fixers that modify code structure (e.g., InternalsVisibleTo, package references) 3. Use expensive AI-powered fixers if enabled (LlmDiagnosticFixer) 4. Apply cleanup passes (remove duplicates/superfulous types, fix usings again) 5. As a last resort, use destructive fixers that comment out or delete problematic code 6. Interleave RoslynAnalyzerFixer to apply IDE suggestions after structural changes Some fixers appear multiple times in the chain because they can fix new issues introduced by previous fixers (e.g., SuperfluousTypesFixer, MissingUsingsFixer).

Recursively applies fixers until the build succeeds or all fixers have been tried. This is the heart of the fix workflow - it implements a recursive backtracking algorithm.

Algorithm: 1. Base case: If no fixers remain, return failure with remaining diagnostics 2. Pop the next fixer from the queue 3. Apply the fixer to current diagnostics 4. If no changes made and fixer doesn't require rebuild, skip to next fixer 5. Otherwise, commit changes and rebuild to get new diagnostics 6. If fixer can retry (made progress or added issues), re-queue it 7. Recursively call with updated diagnostics and remaining fixers 8. Handle three outcomes: build succeeded, fixable diagnostics, unfixable error The fixHistory parameter prevents fixers from repeatedly applying the same fix. The touchedFiles parameter tracks all modified files for reporting. Queue of fixers yet to be applied (order matters). Current diagnostics grouped by file. Tracks which fixes were applied to which files (prevents infinite loops). Accumulator of all files modified during the entire fix process. The test project being fixed. Set of generated test files. Telemetry activity for tracking the operation. Cancellation token for aborting the operation.

Applies a single fixer to the current diagnostics, validates the resulting syntax, and returns the changes.

This method: 1. Calls the fixer's AttemptFixAsync method with current diagnostics and fix history 2. Times the fixer execution for telemetry 3. Updates the fix history to prevent duplicate fixes 4. Validates that all fixed files have valid C# syntax 5. Writes valid fixes to disk and deletes files with empty content

Validates that all fixes have valid C# syntax, writes valid fixes to disk, and deletes empty files.

Invalid syntax is rejected to prevent introducing parse errors that would make subsequent analysis impossible. Empty content is treated as a signal to delete the file (used by destructive fixers).

Builds the project, extracts diagnostics, and categorizes them as fixable or unfixable.

This method: 1. Reloads the Roslyn project to pick up file changes 2. Runs MSBuild with binlog enabled (for diagnostic extraction) 3. Parses the binlog to extract compilation diagnostics 4. Groups diagnostics by file and validates that files exist in the project 5. Returns one of three states: build succeeded, fixable diagnostics, unfixable error Diagnostics are considered "fixable" if they have valid file paths that exist in the project. Diagnostics without valid files (e.g., project-level errors) are treated as unfixable.

Combines multiple batch results into a single result. For tool-based generation, tests accumulate in a single file, so the last batch contains the final state. Tests can be removed by later batches (e.g., mocking limitations), so we use the last result as authoritative for test methods. Packages are accumulated across all batches since they're additive.

Represents custom instructions provided by the user for test generation.

Gets the collection of file paths containing custom instruction content.

Gets optional free-form custom instructions provided as a string.

Gets an empty instance with no custom instructions.

Keywords that indicate a build file may contain target framework constraints. Used both by the LLM prompt (see ) and by the pre-filter in .

Extracts specific instruction preferences from custom instruction files using LLM analysis.

The type of preferences to extract (must be JSON-serializable). Example instance used to generate JSON schema for LLM response. Description of what to extract, included in LLM prompt. List of custom instruction files to analyze. Cancellation token. Extracted preferences of type T, or null if extraction fails or nothing found.

Defines the source generated JSON serialization contract metadata for a given type.

The default associated with a default instance.

The source-generated options associated with this context.

Agent responsible for fixing failing unit tests through iterative analysis and repair.

This agent serves as the entry point for the test fixing workflow. The actual iteration logic has been delegated to to maintain Single Responsibility Principle. Workflow: 1. Groups failing tests by file and processes one test per file per iteration 2. Uses TestFailureAnalysisAgent to analyze each failure and generate fixes 3. Applies fixes, validates with builds and test reruns 4. Comments out or removes tests that cannot be fixed 5. Identifies and marks tests that reveal production code bugs Supports skip mode for fast test commenting without LLM analysis.

Initializes a new instance of FailedTestsFixerAgent with the services facade.

Uses the facade pattern to reduce constructor over-injection. Previously had 12 constructor parameters, now bundled into a cohesive services object.

Creates the diagnostic fixer pipeline for test fixing scenarios. Fixers are applied in sequence to resolve build errors after test modifications. Order matters: simpler fixes first, LLM-based fixes later, most aggressive (commenting) last.

Main entry point for fixing failing tests in a test project. Orchestrates the iterative fix process, tracks results, and handles production bug identification.

Context containing test project, generated files, and test run results Cancellation token Operation result with set of modified file paths

Records test fix statistics and telemetry data after processing all tests. Deduplicates tests by name (keeping final state) before calculating statistics.

Reports the final result of the fix process and returns the appropriate operation result.

Fast-path mode: comments out all failing tests without LLM analysis. This method delegates to the IterativeTestFixOrchestrator.

Facade that bundles services required for test fixing operations. Reduces constructor over-injection in FailedTestsFixerAgent by consolidating related dependencies into a single cohesive unit.

This follows the Facade pattern to address constructor over-injection (>5-7 parameters) while maintaining explicit dependency declaration and testability.

Responsible for extracting and enriching information about failing tests. Maps test failures to source files, extracts method details via Roslyn, and gathers context about production code dependencies.

Groups failing tests by their source file path.

Extracts one test per file for processing, enriching each with Roslyn analysis.

Extracts all failing tests from all files, enriching each with Roslyn analysis.

Extracts class names from fully qualified method names. Format: Namespace.ClassName.MethodName -> Namespace.ClassName

Locates the source file for a failing test by matching against generated files.

Checks if a generated file matches the given test based on method or class name.

Checks if a file contains the specified test name. The name of the test can get changed by fixers (e.g. FormatFixer adding 'Async' suffix) so we check both: the original content (for quick result) and the current content (for fallback accuracy).

Enriches failing test info with Roslyn-based code analysis. Extracts: method body, source location spans, indentation, containing type FQN, and callee information. Callee info is used to provide context to LLM about what production code the test depends on.

Extracts information about production code symbols called by the failing test. This provides context to the LLM about what the test depends on, helping it understand: - What production code is being tested - Available APIs and their signatures - Potential sources of test failures (if production API changed) Only includes symbols from production code (excludes test project files).

Handles code coverage collection operations including initial and final coverage measurement.

Collects final coverage telemetry for the test project.

Collects initial coverage for the test project before test generation.

Runs tests and collects coverage data for the specified test project. This method is used by both the regular test generation workflow and the coverage-based cycling engine.

A task representing the test run output including coverage file path and test run results.

Normalizes and converts coverage file to Cobertura format if needed.

Gets the coverage calculation instance used for measuring coverage percentages. This is initialized by calling InitializeTestsGeneration.

Initializes the coverage calculation for test generation. It is safe to call this multiple times (e.g. for coverage cycling scenario). It will not fail if the scope cannot be determined - in that case CoverageCalculation will remain null.

The context containing scope information for coverage calculation.

Matches test failures to their corresponding test files by comparing the failure's class name (short form) against the test file name (without extension). Only includes files that exist on disk and have at least one matching failure.

Attempts to fix pre-existing failing tests. Returns true if the user accepted the prompt (regardless of whether fixing succeeded), false if the user declined.

Result of source project validation for test generation.

The source project is valid and ready for test generation.

The source project should be skipped (e.g., it's a test project or has no testable code).

Resources needed to execute test generation.

Determines the type of rejected action from the exception message when not explicitly specified.

Runs tests and collects coverage data for the specified test project. This method is used by both the regular test generation workflow and the coverage-based cycling engine.

A task representing the test run output including coverage file path and test run results.

Specifies a desired coverage to achieve in iterative mode. The value is expected to be in percentages - so e.g. for target coverage of 82.5%, this value should be 82.5

Specifies an optional maximum duration (defaults to 5 hours) for which the agent is allowed to cycle during attempt to keep improving code coverage (last cycle cannot start after this limit, but it can finish after the limit - as tests fixing cannot be stopped mid-way without impact on builability).

Specifies an optional maximum number of cycles (defaults to 10) that agent can repeat during attempt to keep improving code coverage.

The scope for test generation (file, directory, project, solution, etc.).

The working directory root where test projects and other artifacts should be created. This is computed from user-provided repo root, git repository root, or solution detection.

Optional path to a test project. When provided, the agent will use this test project for test generation if the scope is file, directory, or project. This helps the agent resolve references and generate tests in the correct location.

Optional path to a solution file. When provided, the agent will use this solution to help resolve project references and context for test generation, especially for file, directory, or project scopes.

Gets the file path to the baseline code coverage report used for comparison.

Gets the file path to the final code coverage report after test generation.

Gets a value indicating whether files are processed sequentially instead of in parallel.

Set this property to to ensure that files are processed one at a time, which may be necessary for certain workflows or to avoid concurrency issues. When set to , files may be processed in parallel to improve performance.

Gets a value indicating whether the current environment is a continuous integration (CI) environment.

Gets the maximum duration allowed for test fixing iterations (RunTestsAndFixAsync). If the timeout is reached, all remaining unfixed code will be either commented out or removed based on deleteFailedCode flag. If null, no timeout is applied.

Gets a value indicating whether the operation is executed immediately after code generation completed. This tells to the agnt that there were no user changes that happened after the code generation and that failing tests probably never passed. If 'false' is passed - it means that there were likely changes in user code that caused the existing tests to start failing.

Gets a value indicating whether the test project is owned by the Code Testing agent.

Gets or sets a value indicating whether code coverage telemetry is disabled.

Gets a value indicating whether agent-specific attributes are included in the operation. This can be used to help distinguish the agent generated tests from the user authored tests.

Gets the custom instructions to be used during processing.

Gets a value indicating whether the initial code coverage analysis should be skipped.

Gets a value indicating whether tests identified as production code bugs should be commented out with TODO notes referencing the bug report, allowing the test suite to pass.

Gets a value indicating whether the repository must be kept in a clean state by creating commits after successful project generation and rolling back when projects fail.

Gets a value indicating whether LLM-based test failure analysis should be skipped, immediately removing or commenting out failing tests instead.

Gets a value indicating whether LLM-based test failure analysis should be skipped, and failing tests should be left untouched.

Gets a value indicating whether only test fixing should be performed without generating new tests. When true, the agent will only analyze and fix existing failing tests.

If specified - indicates that agent should run iteratively until specified coverage is achieved, or untill it hits plateau or an error.

Gets a value indicating whether the classic test generation agent should be used. When false (default), the modern agent writes tests directly to files via tool calls. When true, the classic agent generates tests via markdown responses.

Gets the number of members to process per LLM call in tool-based generation. Lower values increase reliability, higher values increase speed. Range: 1-50. Default: 5.

Gets the value indicating whether working tree changes should be included when calculating git diff - i.e. "git diff (git merge-base HEAD [default_branch])"

Gets a value indicating whether any pre-existing tests were failing before test generation started.

Orchestrates test fixing operations including building, running tests, and fixing failures.

Fixes tests in a single test project.

Builds and runs tests for a project, fixing any failures.

Counts tests in generated files after fixing iterations.

Context for test fixing iterations to reduce parameter count.

Handles test project discovery and creation operations.

Enumerates test projects based on the test scenario.

Finds or creates a test project for the given source project.

Gets or resolves a test project from a source project.

Handles reporting and finalizing test generation results. Responsible for logging test execution summaries and displaying appropriate user messages based on the outcome of test generation operations.

Finalizes a test scenario result by logging the execution summary and reporting the appropriate status (success, failure, partial success, etc.) to the user.

The test scenario result to finalize. Optional activity for telemetry tracking. Cancellation token. The finalized result with an appropriate exit code.

Handles different test scenario types (git diff, solutions, projects, directories, files) and collects files per project for test generation.

Creates tests for git diff changes.

Creates tests for solutions.

Creates tests for projects.

Creates tests for directories.

Creates tests for files.

Collects files per project from a set of file paths.

Orchestrates the iterative test fixing process, handling the recursive loop of: extract failing tests -> analyze with LLM -> apply fixes -> validate -> repeat.

Extracted from FailedTestsFixerAgent to adhere to Single Responsibility Principle. This class focuses solely on the iteration logic while FailedTestsFixerAgent handles agent lifecycle and entry point coordination.

Calculates the maximum number of iterations for the fix process. Uses the maximum tests in any single file as base, then triples it to handle test flakiness, dependencies, and cascading failures.

Iteratively fix failing tests taking one failing test from each file at a time. Strategy: Process one test per file per iteration to minimize conflicts and allow progressive validation. Each iteration: extract tests -> analyze with LLM -> apply fixes -> build -> rerun tests -> recurse if needed.

Fast-path mode: comments out all failing tests without LLM analysis.

What test categories should not be executed Applies filtering by category per https://learn.microsoft.com/dotnet/core/testing/selective-unit-tests.

Delegate for calling the code generation agent for a single member.

Handles member-by-member test generation strategy. Extracted from TestGenerationAgent to adhere to Single Responsibility Principle.

Generates tests for each testable member in a file individually, then merges the results.

Merges individual member test results into a single test file.

Consolidates prompt components by intelligently merging custom instructions from files with overridable content on first call (cached thereafter), while preserving call-specific unchangeable parts.

Description of what the target prompt is for, used as context for the consolidation agent. Call-specific content that is always preserved and prepended to the final result. Can vary between calls. Static base instructions that can be overridden or augmented by custom instructions. Cached after first consolidation. Custom instructions provided by the user that override or augment the overridable prompt. Any parts contradicting the unchangeable prompt will be removed. Token to cancel the operation. The final consolidated prompt with unchangeable content prepended to the merged instructions.

Handles test file finalization operations including saving, merging, and updating test files. Extracted from TestGenerationAgent to adhere to Single Responsibility Principle.

Finalizes a test file after generation, handling new files, existing files, and tool-based generation.

Finalizes a file that was written by tool-based generation.

Adds tests to an existing test file.

Creates a new test file.

Saves generated content to a test file, merging with existing content if present.

Handles application and validation of test fixes. Validates fix syntax, applies fixes to files, and marks tests appropriately.

Processes a single test fix result from the LLM analysis. Handles three cases: 1. Production bug suspected (high/medium confidence) -> mark with category, add to report 2. No fix available or fix is empty -> mark for commenting out 3. Valid fix provided -> apply and validate syntax

Applies a fix to a failing test after validating it meets requirements. Validation steps: 1. Must be exactly one standalone method 2. Must have test attribute 3. Must have valid C# syntax after replacement 4. Must not create duplicate method in the class If all validations pass, writes the fixed code to disk and updates test info.

Ensures the fixed method has required attributes (owner and category) and adds them if missing.

Validates that the fixed method doesn't create a duplicate method declaration. Checks that after applying the fix, the method appears exactly once in the file. Prevents LLM from accidentally creating duplicate methods when fixing tests. Returns true if the method appears exactly once (valid), false otherwise.

Adds production bug category attribute to a test method.

Encapsulates all file-level data needed for test generation, reducing parameter count across methods.

Represents the result of test file generation for a single source file.

Context for test generation operations, encapsulating workspace, project, and coverage information.

If empty, assume all files in the project.

Handles removal and commenting out of failing tests. Provides user notifications and file I/O operations for test modifications.

Removes or comments out a single failing test.

Comments out production bug suspect tests with appropriate TODO messages.

Formats a user-facing message for test removal or commenting.

The base class for exceptions that occur during LLM (Large Language Model) calls. This abstract class provides a foundation for specific LLM-related exception types.

Initializes a new instance of the class.

Initializes a new instance of the class with a specified error message.

The message that describes the error.

Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception.

The error message that explains the reason for the exception. The exception that is the cause of the current exception, or a null reference if no inner exception is specified.

Exception thrown when LLM calls fail after exhausting all retry attempts. Contains information about all failed attempts and the retry configuration.

Gets the maximum number of retry attempts that were configured.

Gets the collection of exceptions that occurred during each retry attempt.

Gets the name of the agent that failed the LLM call.

Initializes a new instance of the class.

The name of the agent that failed the LLM call. The maximum number of retry attempts that were configured. The collection of exceptions that occurred during each retry attempt.

Initializes a new instance of the class with a custom message.

The error message that explains the reason for the exception. The name of the agent that failed the LLM call. The maximum number of retry attempts that were configured. The collection of exceptions that occurred during each retry attempt.

Initializes a new instance of the class with a custom message and inner exception.

The error message that explains the reason for the exception. The exception that is the cause of the current exception. The name of the agent that failed the LLM call. The maximum number of retry attempts that were configured. The collection of exceptions that occurred during each retry attempt.

Exception representing unretriable errors in LLM calls

Describes the type of action that was rejected by the user.

Unknown or unspecified action.

Running tests (dotnet test) was rejected.

Installing NuGet packages was rejected.

Fixing tests was rejected.

Exception thrown when the user explicitly rejects an action requested by the agent (e.g. running tests, installing packages). This is different from an actual cancellation (CTRL+C / cancellation token) and should be handled gracefully without treating it as an error or crash.

Gets the type of action that was rejected by the user.

Gets the files that were in scope when the action was rejected.

Gets the project path that was being processed when the action was rejected.

Generates memorable, unique names for agents (e.g., "SwiftBlueOtter"). Names are composed of Adjective + Color + Animal for easy identification in logs.

Collects requests into batches and processes them serially through an . Requests submitted while a batch is processing are queued for the next batch.

Thread-safe. Multiple agents can call concurrently. Uses a Channel to queue requests and a background processor to handle batches. The type of request to batch.

Filters build/test diagnostics to show agents their own errors first, plus a limited set of others. Prevents information overload when multiple agents cause errors in the same batch.

Coordinates exclusive operations (build, test, restore) from multiple concurrent agents. Agents submit requests which are batched and executed in phases. After project-affecting operations complete, the Roslyn project is reloaded and returned to all waiting agents.

Typical flow: 1. Agent calls with an operation request 2. Request is queued in the channel 3. When processing begins, all pending edits are flushed to disk 4. Operations are grouped by type and executed in phase order (AddIvt, Restore, Build, Test) 5. After the last project-affecting operation, the Roslyn project is reloaded 6. The reloaded project is returned to all agents that submitted requests in this batch

Thrown when an agent attempts to write to a file that is locked by another agent. Used by to prevent concurrent edits to the same file.

The path of the locked file.

The agent ID that currently holds the lock, if known.

Implemented by operations that need access to batch-level context during execution. The context provides file-to-agent attribution and change tracking callbacks.

The batch context, set by before execution. Contains file ownership mappings and change recording callbacks.

Processes a batch of requests that were collected by . Implementations define how requests are executed (e.g., phased execution, parallel execution).

The type of request to process.

Processes all requests in the batch. Called by the coordinator after draining queued requests.

Represents an operation that requires exclusive access to shared resources (build, test, restore). Operations are batched together and executed in phases to maximize throughput while preventing conflicts. Implements for deduplication during batching.

The type representing operation failure details.

Executes the operation. Returns an outcome indicating whether processing should continue or stop (with failure details for remaining operations in the batch).

Completes awaiters with a failure result. Called when an earlier operation fails, or during cancellation. Safe to call on already-completed operations (idempotent).

Merges this operation with another of the same type. Used to combine duplicate operations in a batch (e.g., multiple build requests become one build with multiple awaiters).

Discriminated union representing the type of reload to perform.

Only .cs files changed - update syntax trees, preserve Compilation cache.

Project structure changed - full MSBuildWorkspace reload required.

Represents a diagnostic (error/warning) from a build or test operation.

The file where the diagnostic occurred. The line number of the diagnostic. The diagnostic message.

Represents a diagnostic (error/warning) from a build or test operation.

The file where the diagnostic occurred. The line number of the diagnostic. The diagnostic message.

The file where the diagnostic occurred.

The line number of the diagnostic.

The diagnostic message.

Details about why an exclusive operation failed.

Human-readable description of the failure. Build/test diagnostics associated with the failure. Test run output if this was a test failure; null otherwise. The batch context at the time of failure; null if unavailable.

Details about why an exclusive operation failed.

Human-readable description of the failure.

Build/test diagnostics associated with the failure.

Test run output if this was a test failure; null otherwise.

The batch context at the time of failure; null if unavailable.

Context shared across all operations in a batch.

Maps file paths to the agent that last edited them (global ownership). Warnings accumulated during batch processing. Classifies the reload as full or incremental based on what changed in this batch. Callback to record a global change (IVT added, package added, etc.). Gets changes made by other agents since this agent's last query.

Context shared across all operations in a batch.

Maps file paths to the agent that last edited them (global ownership).

Warnings accumulated during batch processing.

Classifies the reload as full or incremental based on what changed in this batch.

Callback to record a global change (IVT added, package added, etc.).

Gets changes made by other agents since this agent's last query.

Set by FormatOperation after formatting; read by ReloadProjectOperation. When non-null, ReloadProjectOperation does incremental reload of just these paths.

Types of global changes that affect all agents (tracked for cross-agent awareness).

An InternalsVisibleTo attribute was added to a source project.

A NuGet package was added to a project.

A record of a global change made by an agent.

Monotonically increasing index for cursor-based querying. The agent that made this change. Human-readable description of the change. The type of change. When the change was recorded.

A record of a global change made by an agent.

Monotonically increasing index for cursor-based querying. The agent that made this change. Human-readable description of the change. The type of change. When the change was recorded.

Monotonically increasing index for cursor-based querying.

The agent that made this change.

Human-readable description of the change.

The type of change.

When the change was recorded.

Result of waiting for the build to be fixed.

True if build was fixed successfully; false if fixer failed or gave up. Error message when Success is false; null otherwise. The reloaded project after a successful build; null on failure.

Result of waiting for the build to be fixed.

True if build was fixed successfully; false if fixer failed or gave up. Error message when Success is false; null otherwise. The reloaded project after a successful build; null on failure.

True if build was fixed successfully; false if fixer failed or gave up.

Error message when Success is false; null otherwise.

The reloaded project after a successful build; null on failure.

The result of executing an .

The type representing failure details. If true, batch processing continues to the next operation. If false, all remaining operations receive . Failure details when is false; null otherwise.

The result of executing an .

The type representing failure details. If true, batch processing continues to the next operation. If false, all remaining operations receive . Failure details when is false; null otherwise.

If true, batch processing continues to the next operation. If false, all remaining operations receive .

Failure details when is false; null otherwise.

A request submitted to for batched execution.

Unique identifier for the agent submitting this request. The operation to execute (build, test, restore, etc.). Callback to flush the agent's pending file edits before the operation executes. Returns the list of file paths that were written.

A request submitted to for batched execution.

Unique identifier for the agent submitting this request.

The operation to execute (build, test, restore, etc.).

Callback to flush the agent's pending file edits before the operation executes. Returns the list of file paths that were written.

Adds an InternalsVisibleTo attribute to a source project, enabling the test assembly to access internal types. Affects project state (modifies the source project file). Operations targeting the same source project are merged.

Builds the test project. Does not affect project state (build artifacts are not tracked in Roslyn). Multiple build requests in a batch are merged into a single build with multiple awaiters.

Base class for exclusive operations that handles awaiter merging logic. Operations inherit from this to get type-safe Merge() with automatic awaiter concatenation.

The concrete operation type (CRTP pattern). The awaiter type (typically TaskCompletionSource{T} or a custom record).

Override to add additional compatibility checks beyond type matching. Default returns true (any two operations of the same type can merge).

Override to provide a custom error message for merge failures.

Creates a merged operation with the combined awaiters. Implementations should copy their state and use the provided merged awaiters.

No-op operation submitted by WaitForBuildFixAsync to participate in batch ordering. Ensures the agent's pending edits are flushed (via callback) and tracked before build runs. All instances are equal for deduplication (one flush per batch).

Formats source files using Roslyn analyzers/fixers. Does not affect project state (only file contents). Multiple format requests in a batch are merged into a single format with accumulated files.

Reloads the Roslyn project from disk and completes the batch TCS. Runs after project-affecting operations (AddIvt, Restore) so agents get fresh compilation before Build/Test execute. Even when earlier operations fail, agents need fresh state.

Restores NuGet packages for the project. Affects project state (new packages become available). All restore requests in a batch are merged into a single restore operation.

Specialized base class for operations that use TaskCompletionSource{TResult} as their awaiter type. Provides helper to reduce boilerplate in ExecuteAsync implementations.

The concrete operation type (CRTP pattern). The result type that awaiters receive.

Completes all awaiters with the given result.

Runs tests for the test project. Multiple test requests are merged - their test method filters are unioned (or if any request has an empty filter, all tests run). Each awaiter receives results filtered to their original scope, with awareness of whether scope was expanded.

An that buffers writes in memory until explicitly flushed. Enables agents to work concurrently on different files without conflicts - writes are collected locally and only committed to disk when the batch processor flushes them.

Writes all buffered changes to the underlying file system and releases file locks. Returns the list of file paths that were written.

Gets the paths of files with pending (unflushed) writes.

Creates an overlay file system for a specific agent.

The real file system to delegate reads and flushes to. Manager for coordinating file locks across agents. The agent using this overlay (used for lock ownership).

Executes operations in a defined phase order, deduplicating and merging operations of the same type. Phases are executed sequentially; if any operation fails, remaining operations receive the failure.

Key behaviors: - Operations are grouped by type and executed in the order specified at construction - Duplicate operations (by IEquatable equality) are merged via their Merge method - If an operation returns Continue=false, all remaining operations are failed The type representing operation failure details.

Determines the working directory root from multiple sources in priority order: 1. User-provided repository root 2. Git repository root (adjusted if needed) 3. Solution-based detection from code path

The file system to use for path operations. Optional user-provided repository root. Git service to get repository information. The code path provided by the user (file or directory). The determined working directory root. Thrown when the working directory root cannot be determined.

Prefixes each line of the codeblock with the coverage indication char.

Block to be enriched with coverage info. A 1-based line coverage info that is relative to the start of the block (start of the block has number '1'). The start of the member for which we want to see coverage info (might be start of the file, if we want to see for all). The last of the member for which we want to see coverage info (might be end of the file, if we want to see for all).

Returns continuous enumeration of line numbers with coverage statuses.

The start of the member for which we want to see coverage info (might be start of the file, if we want to see for all). The last of the member for which we want to see coverage info (might be end of the file, if we want to see for all). The start of continuous block to be returned (e.g. first line in file - 1). The end of continuous block to be returned (e.g. last line in file - the file length).

Diagnostic fixer that comments out lines with compilation errors.

Diagnostic fixer that comments out entire files containing errors as a last resort.

Base class for diagnostic fixers that provides common functionality.

Implements the actual fix logic. This method will only be called with diagnostics that this fixer can handle.

Dictionary mapping file paths to their diagnostic information that this fixer can handle. Refreshed project to be fixed. Set of file paths that can be modified (typically generated files). Dictionary mapping file paths to potential history of fixes attempted previously. Optional activity for telemetry. Optional logger. Cancellation token. List of fixed files with their new content.

Diagnostic fixer that disables nullable checking in C# files to resolve nullable-related diagnostics.

Fixes CS0579 "Duplicate 'TestClass' attribute" errors on partial types by removing the duplicate attribute from the file where the diagnostic is reported (typically the generated file).

This fixer specifically targets the scenario where a partial class has [TestClass] attribute defined in multiple files. When generating tests for a partial test class that already has the attribute, the generated file may add a duplicate attribute causing CS0579.

Finds a TestClass attribute at or near the specified line.

Checks if a type declaration has the 'partial' modifier.

Removes the specified attributes from the syntax tree.

Parses a CS0579 error message to extract the attribute name.

The CS0579 error message (e.g., "Duplicate 'TestClass' attribute"). The attribute name if parsing succeeds, null otherwise.

Fixes CS0101 "The namespace 'X' already contains a definition for 'Y'" and CS0436 "The type 'X' conflicts with the imported type 'X'" errors by removing duplicate/conflicting type definitions from generated files. This fixer handles cross-file scenarios where the diagnostic is reported on the original file but the fix needs to be applied to generated files.

Searches the entire project for occurrences of the specified duplicate types. Returns a mapping of file paths to the duplicate types with their syntax nodes found in each file.

Searches a specific file for occurrences of the specified duplicate types. Returns both the duplicate type info and the corresponding SyntaxNodes.

Parses a CS0101 error message to extract the namespace and type name.

The CS0101 error message. A tuple of (namespaceName, typeName) if parsing succeeds, null otherwise.

Parses a CS0436 error message to extract the type name and file path.

The CS0436 error message. A tuple of (typeName, FilePath) if parsing succeeds, null otherwise.

Parses a CS0104 error message to extract the ambiguous type references.

The CS0104 error message. A list of (namespaceName, typeName) pairs if parsing succeeds, null otherwise.

Parses a fully qualified type name to extract namespace and type name. Handles nested types by treating the last component as the type name.

The fully qualified type name. A tuple of (namespaceName, typeName) if parsing succeeds, null otherwise.

Extracts the namespace for a specific type from a file. Errors out if multiple types with the same name exist in different namespaces within the same file.

Path to the file to analyze. Names of the types to find. Logger instance. Cancellation token. A tuple of (namespaceName, typeName) if found and unique, null otherwise.

Extracts the namespace name from a type declaration syntax node.

The type declaration syntax node. The namespace name, or null if not found.

Processes a specific file by removing all occurrences of the specified duplicate types.

Removes empty namespaces from a syntax tree.

The root node of the syntax tree. The updated syntax tree with empty namespaces removed.

Finds all type declarations (class, interface, struct, enum, record, delegate) with the specified name in the specified namespace.

Finds all type declarations with the specified name within a given syntax node.

Fixer that runs Roslyn analyzers and formatters on the project to fix formatting and style issues.

Always returns true as this fixer can be applied regardless of specific diagnostics.

Runs Roslyn formatting and analysis on specific files that have diagnostics.

Fixes cases where generated files contain types that clash with existing types in the project. This is often due to hallucinated types in the generated code. The fixer distinguish that by presence of multiple namespaces in generated files, while the halucinated types are in namespaces without tests.

Fixes CS0854: An expression tree may not contain a call or invocation that uses optional arguments. It adds the default values for optional parameters explicitly to the invocation. This is usually needed for Moq Setup and Verification calls which use expression trees.

Fixes CS0854 errors in a given document by adding default values for optional parameters in expression trees.

The document to fix. The CS0854 diagnostics in the document. Cancellation token. A FixedFile if changes were made, null otherwise.

Tries to get the symbolic default value from the parameter declaration.

Represents a file that has been fixed by a diagnostic fixer.

Path to the file that was fixed. New content for the file. Summary of the fix applied.

Represents a file that has been fixed by a diagnostic fixer.

Path to the file that was fixed. New content for the file. Summary of the fix applied.

Path to the file that was fixed.

New content for the file.

Summary of the fix applied.

Represents diagnostic information for a single file.

The code file instance. List of diagnostics for this file.

Represents diagnostic information for a single file.

The code file instance. List of diagnostics for this file.

The code file instance.

List of diagnostics for this file.

Interface for diagnostic fixers that can attempt to fix compilation errors.

Checks if this fixer can attempt to fix the given diagnostic.

The diagnostic to check. The code file containing the diagnostic. True if this fixer can attempt to fix the diagnostic.

Indication from the fixer whether it is capable to have additional run with likely productive outcomes.

True if another attempt to fix is likely to be productive.

Indicates whether we should always run build after this fixer even if no fixes were returned.

Indicates whether this fixer deletes or comments out tests rather than fixing the problems.

Helper method to filter diagnostics to only include those that this fixer can handle.

Full set of file diagnostics. Filtered set of file diagnostics that this fixer can handle.

Attempts to fix the given diagnostics.

Dictionary mapping file paths to their diagnostic information. Refreshed project to be fixed. Set of file paths that can be modified (typically generated files). Dictionary mapping file paths to potential history of fixes attempted previously. Optional activity for telemetry. Optional logger. Cancellation token. List of fixed files with their new content.

A diagnostic fixer that adds InternalsVisibleTo attributes to source projects when test code tries to access internal members (CS0122 errors).

CS0122: 'X' is inaccessible due to its protection level

A diagnostic fixer that uses LLM to fix any compilation diagnostics in C# code files.

Diagnostic fixer that adds missing using directives to fix compilation errors.

Represents a symbol from diagnostics that could not be found in the symbol dictionary.

Adds using directives to the compilation unit while respecting style preferences.

The compilation unit to modify. The using directives to add. The path (file or directory) to use for .editorconfig detection. The file system abstraction to use for .editorconfig detection. The modified compilation unit with using directives placed appropriately.

Adds using directives inside namespace declarations.

The compilation unit to modify. The using directives to add. True if this is an explicit .editorconfig override, false if detected from existing patterns.

Processes a regular namespace declaration to add using directives.

Processes a file-scoped namespace declaration to add using directives.

Creates a context object containing all the using directives to add to a namespace.

Updates a regular namespace declaration with new using directives.

Updates a file-scoped namespace declaration with new using directives.

Clears top-level using directives if an explicit override is specified.

Extracts the name from a using directive as a string.

Adds using directives at the top of the file (outside namespaces).

Contains context information for adding using directives to a namespace.

Defines the placement preference for using directives.

Place using directives outside namespace declarations (at the top of the file).

Place using directives inside namespace declarations.

Analyzes C# source code to detect existing using directive placement patterns.

Detects the using directive placement pattern in the given compilation unit.

The compilation unit to analyze. The detected placement pattern. Returns OutsideNamespace as fallback when no existing usings are found.

Determines if the compilation unit uses file-scoped namespaces.

The compilation unit to analyze. True if file-scoped namespaces are used, false otherwise.

Determines if the compilation unit uses traditional namespace declarations.

The compilation unit to analyze. True if traditional namespaces are used, false otherwise.

Provides functionality to generate a report of test failure analysis results.

Gets the file path where the analysis report will be saved.

Creates a new instance of the AnalysisReport.

Logger to use for reporting. Optional file system for writing reports to disk. Optional repository root path for saving reports.

Represents a single test failure analysis entry.

Full name of the test that failed.

Path to the file containing the test.

Type of failure detected.

Confidence level of the analysis.

Detailed explanation of the analysis.

Suggested fix for production code, if applicable.

Location of the suggested fix.

Adds a production bug entry to the report. Entries with Low confidence are ignored.

Generates and logs the test failure analysis report.

Creates a backup of the specified file.

The path to the file to back up. The file system. The path to the backup file.

Generates a backup file path by appending a '.codetesting.bak' extension to the provided file path.

The original file path to which the backup extension will be added. A string representing the new backup file path.

Helper class to extract compilation diagnostics from MSBuild binary logs.

Extracts compilation diagnostics from a binlog file.

A readonly collection of CompilationDiagnostic objects.

Retrieves a collection of coverable lines with their line numbers adjusted relative to a specified method start offset.

One-based line position index. Specifies the starting point for calculating the relative position of coverable lines. An enumerable collection of tuples containing line numbers (one-based indexing) and coverage status.

One based start offset of the method in the file.

Helper for committing changes at each step when the --commit-steps command line argument is enabled.

Specifies the type of coverage being collected.

Initial coverage collected before test generation.

Final coverage collected after test generation.

Provides helper methods for calculating coverage percentages from coverage reports.

Initializes a new instance of the CoverageCalculation class using the specified test generation context, list of Git-touched files, coverage service, file system, and logger.

The scope of coverage calculation is determined by the GenerationScope property of the provided context. Depending on the scope type, the relevant file, directory, project, or solution paths are extracted and used for coverage analysis. When the scope is GitDiffScope, the gitTouchedFiles parameter is used to define the set of files under consideration. The test generation context that defines the scope and parameters for coverage calculation. Cannot be null. An array of file paths representing files changed in the current Git diff. Used when the generation scope is set to GitDiffScope. Can be empty if no files are changed. The coverage service used to retrieve and process code coverage data. Cannot be null. The file system abstraction used for file and directory operations. Cannot be null. The logger used to record diagnostic and operational messages. Cannot be null. Thrown if context, coverageService, fileSystem, or logger is null. Thrown if the context does not specify a valid source path for test generation.

Gets the appropriate coverage cache based on the coverage type.

The type of coverage cache to retrieve. The dictionary containing the coverage cache for the specified type.

Adds coverage data to the appropriate cache based on the specified coverage type.

This method updates the cache for the specified coverage type by associating the given project path with the provided coverage data. If the project path already exists in the cache, its value will be overwritten. The type of coverage data to add. Must be either or . The path to the project associated with the coverage data. Cannot be or empty. The coverage data to store in the cache. Required when status is OK.

Marks a test project as newly created, so it can be excluded from baseline coverage calculations.

The path to the test project that was newly created.

Swaps the final coverage cache to become the initial coverage cache. This efficiently reuses final coverage from one cycle as the baseline for the next cycle, avoiding unnecessary coverage collection.

Gets the paths defining the scope for coverage measurement.

Gets the type of scope to measure coverage for.

Calculates coverage data for the specified scope using coverage cache data.

Cancellation token for the operation. Coverage percentage for the specified scope, or null if coverage cannot be calculated.

Gets a single coverage file path, merging multiple files if necessary.

Cancellation token for the operation. Path to a single coverage file.

Measures coverage from the generated coverage XML file.

Path to the coverage XML file. Coverage percentage for the specified scope.

Provides functionality for measuring code coverage across different scopes and units.

Calculates the overall coverage percentage for a given coverage information and scope.

The coverage information to analyze. The paths defining the scope (file, project, solution, or directory). The type of scope to measure coverage for. Coverage percentage as a value between 0.0 and 100.0.

Measures coverage for a specific scope by loading coverage data from a Cobertura XML file.

Path to the Cobertura XML coverage file. The paths defining the scope to measure. The type of scope to measure coverage for. Logger for diagnostics. File system abstraction. Coverage percentage as a value between 0.0 and 100.0.

Gets all files within the specified scope from the coverage information.

Determines if a file path matches the specified file scope.

Determines if a file path is within the specified project scope.

Determines if a file path is within the specified solution scope.

Determines if a file path is within the specified directory scope.

Defines the different types of scopes for coverage measurement.

Coverage measurement scoped to a single file.

Coverage measurement scoped to a project.

Coverage measurement scoped to a solution.

Coverage measurement scoped to a directory.

Coverage measurement scoped to a current diff. Currently unsupported.

Helper class for validating C# syntax.

Analyzes the provided C# source code and returns all syntax diagnostics with .

The Roslyn syntax tree that represents the parsed code. The cancellation token. A collection of syntax diagnostics with severity, or empty if the source is valid.

Analyzes the provided C# source code and returns all syntax diagnostics with .

The C# source code to analyze. The Roslyn syntax tree that represents the parsed code. The cancellation token. A collection of syntax diagnostics with severity, or empty if the source is valid.

Validates C# syntax and logs any errors found.

The C# source code to validate. The logger to use for error reporting. The operation context for logging (e.g., "applying LlmDiagnosticFixer"). The parsed syntax tree. The cancellation token. True if the syntax is valid, otherwise false.

Validates C# syntax and logs any errors found.

The logger to use for error reporting. The operation context for logging (e.g., "applying LlmDiagnosticFixer"). The parsed syntax tree. The cancellation token. True if the syntax is valid, otherwise false.

Validates C# syntax and returns formatted error messages.

The C# source code to validate. The cancellation token. A formatted string containing syntax errors, or null if the syntax is valid.

Tracks coverage progress across multiple cycles and determines when to stop based on various criteria.

Initializes a new instance of the CycleCoverageTracker class.

Gets the number of completed cycles. The first result is for baseline - so not counted.

Gets the total elapsed time since tracking started.

Gets the latest coverage percentage, or null if no cycles have been recorded.

Gets all recorded cycle results.

Records the result of a completed cycle. ///

The coverage percentage achieved after this cycle. The time taken for this cycle.

Gets the reason why cycling should stop based on current state.

The target coverage percentage, or null for auto mode. The stopping reason, or null if cycling should continue.

Gets the stopping decision with full details about whether cycling should stop.

The target coverage percentage, or null for auto mode. A StoppingDecision with the should-stop decision and optional reason.

Represents the result of a completed cycle.

The cycle number (1-based). The coverage percentage achieved after this cycle. The time taken for this cycle. When this cycle was completed.

Represents the result of a completed cycle.

The cycle number (1-based). The coverage percentage achieved after this cycle. The time taken for this cycle. When this cycle was completed.

The cycle number (1-based).

The coverage percentage achieved after this cycle.

The time taken for this cycle.

When this cycle was completed.

Defines the reasons why cycling might stop.

The target coverage percentage has been reached.

No improvement in coverage for the last 3 cycles.

Less than 1% improvement over the last 5 cycles.

The 5-hour time limit has been reached.

User requested cancellation.

Maximum number of cycles reached (safety limit).

Coverage file was missing, or other errors during getting the coverage.

Agent was not able to make the generated tests buildable or passing - so we cannot continue cycling.

An error occurred during cycling.

Represents a decision about whether cycling should stop.

Whether cycling should stop. The reason for stopping, if applicable.

Represents a decision about whether cycling should stop.

Whether cycling should stop. The reason for stopping, if applicable.

Whether cycling should stop.

The reason for stopping, if applicable.

Parses .editorconfig files to extract C# formatting preferences.

Parses the using directive placement setting from .editorconfig files. Searches up the directory tree starting from the specified path.

The path to start searching from. Can be either: - A file path: searches starting from the file's containing directory - A directory path: searches starting from that directory. The file system abstraction to use for file operations. The configured placement, or null if no setting is found.

Parses using directive placement from .editorconfig content.

The .editorconfig file content. The parsed placement, or null if no valid setting is found.

Check the first 3 bytes of a stream to determine if it matches the UTF8 preamble.

Steam to check. True when the first 3 bytes of the Stream are equal to the UTF8 preamble (BOM).

Check the first 3 bytes of a stream to determine if it matches the given preamble.

Steam to check. Preamble to look for. True when the first 3 bytes of the Stream are equal to the preamble.

Captures a sanitized stack trace of the current call site (no exception required). Useful for non-exception failure telemetry where we still want to report the code path that detected the failure. Frames from non-safe namespaces are redacted.

Inspects the provided XDocument and returns the indentation string based on the first XText node found that contains a newline and trailing spaces/tabs. Returns null if no indentation is detected.

Converts an absolute path to a relative path from repo root with forward slashes.

Converts a relative or absolute path to an absolute path.

Discovers MSBuild and SDK configuration files that may contain target framework constraints. Searches for Directory.Build.targets, Directory.Build.props, and global.json files from the start path up to the repository root directory.

The path to start searching from (typically a project or solution path). The repository root directory (search stops here, inclusive). The file system abstraction to use for file operations. A read-only list of discovered file paths, ordered from nearest to farthest from the start path.

Filters build files to only include those that contain target framework-related content. This prevents unnecessary LLM calls for build files that only contain generic settings (e.g., TreatWarningsAsErrors, ImplicitUsings) with no TFM constraints.

Checks whether file content contains target framework-related keywords. Uses for standard MSBuild properties and for validation target names.

Attempts to match a custom attribute as an InternalsVisibleTo attribute for the target assembly.

true if the attribute matches the target assembly (with matching public key if provided); false if the attribute matches the target assembly name but has no public key when one is expected; null if the attribute doesn't match or should be skipped (continue checking other attributes).

Checks if the assembly name from the attribute matches the target assembly with the expected public key.

true if matches (including public key match if provided); false if assembly name matches but public key is expected and not present; null if assembly name doesn't match or public key doesn't match (continue checking).

Provides formatting functionality for symbol metadata in a consistent way across the codebase.

Formats a collection of symbol metadata as a markdown table.

The symbols to format. Optional spans to filter symbols by their usage. A markdown table representation of the symbols.

Formats a single symbol metadata as a row in a markdown table.

The symbol metadata to format. A markdown table row representation of the symbol.

Gets the kind of a symbol as a display string.

The symbol to get the kind for. A string representation of the symbol kind.

Gets the return type of a symbol as a display string.

The symbol to get the return type for. A string representation of the return type, or null if not applicable.

Gets the display string for a type symbol.

The type symbol to format. A string representation of the type.

Gets the target type string for an alias symbol.

The alias symbol to get the target for. A string representation of the alias target, or null if not applicable.

Determines if a symbol is used within any of the provided member spans.

The symbol metadata to check. The spans to check against. True if the symbol is used in any of the member spans, false otherwise.

Converts a boolean value to "Yes" or "No" string representation.

The boolean value to convert. "Yes" if true, "No" if false.

Generates the remarks entry for a symbol metadata.

The symbol metadata to generate remarks for. A string containing the remarks for the symbol.

Determines if a symbol is read-only.

The symbol to check. True if the symbol is read-only, false otherwise, or null if not applicable.

Determines if a symbol can be mocked.

The symbol to check. True if the symbol can be mocked, false otherwise.

Provides methods to analyze whether source files contain testable code types (classes, structs, records) before test project creation.

Checks if any of the specified source files contain testable code types. This method can be called early in the test generation flow to avoid creating test projects when there's nothing to test.

The source project containing the files to analyze. The files to check for testable types. Authorization service to check if files can be processed. Logger for diagnostic messages. Cancellation token. True if at least one file contains testable types; false otherwise.

Checks if a single source file contains testable code types.

The code file to analyze. The source file information including line/member filters. Authorization service to check if the file can be processed. Logger for diagnostic messages. Cancellation token. A tuple containing: - HasTestableTypes: True if the file contains testable types; false otherwise. - RootNode: The syntax root node if HasTestableTypes is true; null otherwise. - FileContent: The file content if HasTestableTypes is true; null otherwise.

Checks if the source file contains testable types (struct, class, or record). The behavior varies based on the type of SourceFileToTest: - LinesSourceFileToTest: checks only the specified line ranges - MembersSourceFileToTest: checks the types containing the specified members - Default (FullSourceFileToTest): checks the entire file content

Checks if the specified line ranges contain testable types.

Checks if any of the specified members are contained within testable types.

Quick check if the file content contains struct, class, or record keywords.

Helper class for resolving test artifact files such as test results and coverage files.

Gets the test results file path from the test run output.

The path to the test project. The output from the test run. The test results folder. The expected file name. The file system service. The logger. The path to the test results file, or null if not found.

Gets the coverage file path from the test run output.

The path to the test project. The output from the test run. The test results folder. The expected file name. The file system service. The logger. The path to the coverage file, or null if not found.

Extracts the coverage file path from test run output by searching for paths in "Attachments:" sections. Handles multi-TFM scenarios where multiple test runs produce multiple coverage files.

The output from the test run. The expected coverage file name to match. The logger. The coverage file path if found, otherwise null.

Gets the path to a test artifact file (test results, coverage, etc.).

The name of the artifact type for logging. The path to the test project. The candidate location from the test output. The test results folder. The expected file name. The file system service. The logger. The path to the artifact file, or null if not found.

Represents the semantic type of a test attribute, independent of framework.

Defines how duplicate attributes should be handled.

Replace existing attribute with this value (e.g., Owner).

Add if not present with a specific value (e.g., Category).

Checks if there's an exact attribute match (same type and values).

Checks if an xUnit Trait attribute exists with the specified trait type.

Checks if an xUnit Trait attribute exists with the specified trait type and value.

Checks if an attribute with the specified name and values exists.

Gets the first argument value from an attribute.

Gets the second argument value from an attribute.

Checks if attribute values match the expected values.

Gets the attribute name based on framework and attribute type.

Gets the attribute values array based on framework, attribute type, and value.

Updates method attributes by adding or modifying attributes based on the provided descriptors, preserving trivia and handling proper ordering and formatting.

The current attribute lists on the method. The attribute descriptors specifying what attributes to add or update. Optional method leading trivia for trivia preservation. Updated attribute lists with all specified attributes added or updated.

Applies an attribute operation to a list of attribute lists, preserving trivia and handling ordering correctly.

The current attribute lists. The attribute descriptor to apply. Optional method leading trivia for trivia preservation. Updated attribute lists with the operation applied.

Adds or updates an attribute in the attribute lists, preserving trivia and order.

Adds an attribute only if it's not already present, preserving trivia and order.

Extracts trivia from the target location where attributes should be placed.

Extracts documentation comments and line comments from method trivia, excluding the final whitespace (method indentation).

Extracts only the method indentation (final whitespace) from method trivia.

Applies trivia to an attribute list, ensuring proper formatting and XML doc preservation.

Checks if an attribute matches the given descriptor based on name and value.

Checks if an XUnit Trait attribute matches the descriptor's key and value.

Extracts the string value from an attribute argument.

Adds a new attribute to the attribute lists, preserving trivia and order.

Extracts the indentation pattern from existing attributes.

Creates an AttributeSyntax from an AttributeDescriptor.

Helper class for recording test-related telemetry events.

Normalizes a file path for test tracking consistency. Uses absolute path with forward slashes for cross-platform consistency.

The file path to normalize. Normalized filename for tracking.

Records a test generation event for telemetry tracking.

The path of the test file where the test was generated. The generated test method.

Records a test removal event for telemetry tracking.

The path of the test file where the test was removed. The removed test method.

Gets mapping for provided source files to test files in the test project. If good enough test files already exist, they will be returned. If they don't exist or mapping is ambiguous, new test file paths will be returned based on the source file paths.

Analyzes a collection of test projects and returns the most frequently used test dependencies. Uses scoring for tie-breaking when frequencies are equal.

Shared helpers for diagnosing test run issues (crashes, timeouts, etc.).

Checks if stderr contains patterns indicating a test host crash.

Formats stdout and stderr into a combined output string. Format: stdout first, then stderr with [stderr] label if present.

Converts symbol to FullyQualifiedName while preserving original line numbers.

If the source code is: System.Threading .Tasks.Task then simply calling the full name would result in: global::System.Threading.Tasks.Task which is breaking the original line count so instead we will transform it into: global::System .Threading.Tasks.Task.

Tracks code diagnostic statistics during the build and fix process.

Represents an activity for telemetry tracking.

Adds a tag to the activity.

The tag key. The tag value. The activity instance for method chaining.

Sets a tag on the activity.

The tag key. The tag value. The activity instance for method chaining.

Sets the status of the activity

The status. An optional description. The activity instance for method chaining.

Adds an event to the activity.

The event to add. The activity instance for method chaining.

OpenTelemetry implementation of IActivity.

Runs analyzers on a compilation with proper options that respect editorconfig settings. This is the canonical way to invoke analyzers - use this instead of calling WithAnalyzers directly.

Checks if the given file content contains any test methods.

The file content. True if the file contains tests.

Helper method to find test method references to a specific method within a single project.

Gets the string representation of , decorated with coverage info for the if coverage info available. The two given syntax nodes - and - can be identical - then the whole code block is decorated. Or the latter can be a child of former - then only that part of code block is decorated with coverage info.

The coverage info to be used. The node to get the string representation. The node to decorate with coverage within the string representation. Indication whether the coverage was added.

E.g. 'DotUtils.StreamUtils.ChunkedBufferStream.ChunkedBufferStream(System.IO.Stream, int)'.

E.g. 'ChunkedBufferStream'.

Gets the string representation of the expression used to call the symbol.

Gets the list of called symbols definitions for this symbol declaration. Uses the SemanticModel provided at construction.

Checks if an invocation expression represents a call to the specified method.

The invocation expression to check. The target method to compare against. The semantic model for the invocation's syntax tree. Optional cancellation token. True if the invocation is a call to the target method.

Does the method have any recognized test method attribute?.

Does the method have any recognized test category attribute ([Test]Category[Attribute]), that has argument with specified value?.

Ensures that the given method has proper metadata marking (Skip property in Fact/Theory attribute for xUnit; Ignore attribute for other tests frameworks). If the method is already skipped, the attribute should not be duplicated, only the reason should be updated.

Method to be inspected and altered. Test framework to decide what to apply. Text to apply.

Adds or updates the Skip property in xUnit Fact/Theory attributes.

Updates or adds the Skip property to an xUnit Fact or Theory attribute.

Adds or updates the Ignore attribute for MSTest and NUnit.

Gets the reason from an existing Ignore attribute.

Updates an existing Ignore attribute with a new reason.

Adds a new Ignore attribute to the method.

Gets the source code text for a method declaration.

The method declaration syntax node. The source code of the method.

Gets the source code text for a method declaration with its containing context (class, namespace).

The method declaration syntax node. The source location information including file path and position.

Finds existing test methods that can serve as examples, using a tiered approach that progressively widens the search scope. Returns examples in order of relevance (from most to least relevant).

Collection of symbols to find test examples for (can be empty). The test project to search in. Cancellation token. An async enumerable of test method source code examples, with most relevant examples first.

Verifies that the input string is a single C# method declaration with no additional type or method declarations.

The code string to check. True if the string is a single method declaration and nothing else; otherwise, false.

Checks if a member or any of its containing types has the ExcludeFromCodeCoverageAttribute.

The member to check. True if the member or any containing type has ExcludeFromCodeCoverageAttribute.

Checks if a syntax node has the ExcludeFromCodeCoverageAttribute.

The syntax node to check. True if the node has ExcludeFromCodeCoverageAttribute.

Determines if an attribute name represents ExcludeFromCodeCoverageAttribute.

The attribute name to check. True if the attribute name represents ExcludeFromCodeCoverageAttribute.

Extracts the test method name from a method declaration if it's a test method.

The method declaration to check. The method name if it's a test method, null otherwise.

Extracts test methods from generated code string.

The generated code to parse. Cancellation token. Collection of test method declarations.

Formats a number with thousand separators and abbreviations for large values. Uses space as thousand separator and abbreviates values >= 1M.

The number to format. Formatted string representation.

Creates a formatted table of fixer statistics.

Dictionary containing statistics for each fixer. The logger. A formatted string containing the fixer statistics table.

Gets the final test state containing only tests in Generated state, grouped by filename.

Dictionary mapping file names to lists of test method names that are in Generated state.

Creates a markdown summary of the final test state.

Returns a dictionary of symbols to their fully qualified names and containing namespaces for project. (But not its references.)

Returns a dictionary of symbols to their fully qualified names and containing namespaces for project and all its references.

Roslyn solution used to look up projects. If not given will be taken from project. Roslyn Project. Include only symbols with public visibility. Otherwise internal visibility is also included.

Inspect the given code - for all classes and methods that are identified as test classes/methods - it ensures that those are public and not static.

Code file content.

Ensures the namespaces in the test file match the source file namespaces with ".UnitTests" suffix. For each test type, finds the matching source type and updates the namespace accordingly.

The test file content. The syntax root of the source file. The test file content with the correct namespaces.

Merges multiple C# class definitions into a single class definition asynchronously. The merged class will contain all members and usings from the provided classes.

A collection of class definitions in string format to be merged into one. Used to signal cancellation of the asynchronous operation. A string representation of the merged class definition. Thrown when parsing fails or a class declaration is missing in any of the provided class files, or if there are member conflicts.

Gets a value indicating whether telemetry is opted out based on the official .NET CLI environment variable. Checks the DOTNET_CLI_TELEMETRY_OPTOUT environment variable for values "1" or "true" (case-insensitive).

Gets or sets the telemetry session.

Shows the telemetry banner on first use and respects banner suppression settings. Similar to Microsoft Testing Platform implementation.

The telemetry notice message to display. The user display service for showing messages. The file system service for file operations. The environment service. The logger for logging operations. Whether the --no-banner option was specified. Task representing the async operation.

Gets the dictionary of PII properties indicating which properties contain PII and their kind.

Indicates whether the user is an external user (external release). A dictionary where the key is the property name and the value indicates the kind of PII property.

Posts a fault event that produces a red diamond (◆) in Prism. Use for unrecoverable errors (crashes, unexpected exceptions) to distinguish them from normal operation failures in the telemetry pipeline.

Output tokens.

Input tokens.

The property contains a file system path

Any other property

Result of attempting to retrieve diagnostics from a build. Forces callers to explicitly handle the case when diagnostics are unavailable.

Diagnostics were successfully retrieved from the build. The collection may be empty if the build succeeded with no diagnostics.

Diagnostics could not be retrieved (e.g., binlog missing or unreadable).

Represents a location in the source code. All coordinates are 1-based.

Initializes a new instance of the struct.

The start line (1-based, must be positive). The start column (1-based, must be positive). The end line (1-based, must be positive and >= StartLine). The end column (1-based, must be positive).

Gets the start line (1-based).

Gets the start column (1-based).

Gets the end line (1-based).

Gets the end column (1-based).

Gets the number of lines spanned by this code fragment (inclusive). For example, if StartLine is 1 and EndLine is 1, LinesCount is 1. If StartLine is 1 and EndLine is 3, LinesCount is 3.

Describes how severe a diagnostic is.

Something that is an issue, as determined by some authority, but is not surfaced through normal means. There may be different mechanisms that act on these issues.

Information that does not indicate a problem (i.e. not prescriptive).

Something suspicious but allowed.

Something not allowed by the rules of the language or other authority.

Orchestrates coverage-based cycling workflow for test generation and fixing. Manages the generate→measure→fix cycles until stopping criteria are met.

Initializes a new instance of the CoverageBasedCyclingEngine class.

The test agent manager for test generation and coverage collection. Logger for diagnostic information. User display for showing information to the user. Service for coverage operations.

Executes the coverage-based cycling workflow.

The test agent context with scope and settings information. Cancellation token for the operation. The final cycling result with coverage information and stopping reason.

Represents the final result of a coverage-based cycling session.

The final coverage percentage achieved. The total number of cycles executed. The total time spent on cycling. The reason why cycling stopped. History of all cycle results. The target coverage percentage, if specified.

Represents the final result of a coverage-based cycling session.

The final coverage percentage achieved.

The total number of cycles executed.

The total time spent on cycling.

The reason why cycling stopped.

History of all cycle results.

The target coverage percentage, if specified.

Constructor to be used by unit test override type.

Constructor to be used by unit test override type with a specific file path.

The first test project found referencing the source project.

The test projects when no single test project referencing the source project is found.

This ctor should be called only via !.

Determines whether an XML element is conditioned on a specific TFM or other MSBuild property. Returns if the element itself or any ancestor has a Condition attribute, or if any ancestor is a When or Otherwise block inside a Choose element. Conditioned elements should be skipped during heuristic parsing because their conditions cannot be evaluated without MSBuild.

Computes the build configuration to use for the project. Returns null if "Debug" is available (default) or no Configurations property is specified. Returns the first available configuration if "Debug" is not available.

The path to the project file or null if there is no project file.

Gets the build configuration to use when building the project. Returns null if "Debug" is available or no Configurations property is specified, otherwise returns the first available configuration.

Classifies the project as a product, test, or non-testable project. Null before is called. When the value is , is guaranteed to be non-null.

Indicates whether the project should be forcibly treated as a test project, regardless of other heuristics or conditions that determine test project status. This property does not affect the `TestDependenciesInfo` contract associated with .

Ensures that the project is treated as a test project and guarantees that `TestDependenciesInfo` is not null. Throws an exception if it cannot ensure the non-null state of `TestDependenciesInfo`.

Classifies the role of a project in the solution.

A regular product/library project that is eligible for test generation.

A test project (detected via MSBuild properties, project capabilities, or naming heuristics).

A non-testable project (e.g., benchmarks) that should be excluded from test generation without being treated as a test project candidate.

Represents a snapshot of a source file's path and content at a point in time. Use this type when you need to pass both a file path and its content together, especially when the content may have been pre-read or modified in memory.

The absolute path to the source file. The content of the file at the time of the snapshot.

The absolute path to the source file.

The content of the file at the time of the snapshot.

Version agnostic query about dependency being a known test dependency.

Represents a test filter configuration for running tests.

Gets or initializes a collection of fully qualified test names to filter by.

Gets or initializes the category to exclude from the test run.

Gets the fully qualified method names without signatures (parameter lists), deduplicated.

A collection of method names with signatures stripped.

A result of generating tests for a project.

Paths and contents of generated/updated files. Packages to install together with a list of files that depend on given package. Errors encountered during generation.

A result of generating tests for a project.

Paths and contents of generated/updated files. Packages to install together with a list of files that depend on given package. Errors encountered during generation.

Paths and contents of generated/updated files.

Packages to install together with a list of files that depend on given package.

Errors encountered during generation.

Identifies a test or group of tests to run. Used as a strongly-typed parameter for LLM tool calls and throughout the test execution pipeline.

Gets the fully qualified type name (e.g., "MyApp.Tests.CalculatorTests").

Gets the test method name (optional). If null or empty, targets all tests in the type. If provided, targets the specific test method.

Gets whether this identifier targets a specific test method (true) or all tests in a type (false).

Gets the fully qualified name for this filter. For type filters: "Namespace.TypeName" For method filters: "Namespace.TypeName.MethodName"

Represents the test runner type for a test project.

Traditional VSTest runner.

.NET 10+ Microsoft Testing Platform (MTP) runner configured via global.json.

Microsoft Testing Platform (MTP) with VSTest support (dotnet test compatibility).

Gets the reason the operation was cancelled by user choice (not by error). Null if the operation was not cancelled.

Gets the type of action the user rejected that caused cancellation.

Gets the files that were in scope when the user cancelled the operation.

Gets the project path that was being processed when the user cancelled the operation.

Gets a value indicating whether this result represents a user-initiated cancellation.

Creates a result for when the user rejects an action (cancellation by user choice, not by error).

The reason the operation was cancelled (user-rejected action description). The type of action that was rejected. Files that were in scope when the action was rejected. Project being processed when the action was rejected. A TestScenarioResult representing user-initiated cancellation with context.

Represents a user's prompt for test generation, which can be either structured (mentions only) or free-form (natural language text with optional mentions).

The free-form natural language text from the user. When null or empty, the prompt is purely structured (mentions only). When present, the entire prompt should be interpreted as free-form.

Base class for different types of structured mentions that can be part of a user prompt. Mention of a specific source file with optional line range.

Mention of a specific source file with optional line range.

Converts this file mention to a human-readable string representation that can be included in the LLM prompt.

Mention of a solution file.

Converts this solution mention to a human-readable string representation.

Mention of a solution file.

Converts this solution mention to a human-readable string representation.

Mention of a solution file.

Converts this solution mention to a human-readable string representation.

Represents a type with a single value. This type is often used to denote the successful completion of a void-returning method (C#) or a Sub procedure (Visual Basic).

Ideally we would use the class from System.Reactive but we want to avoid a deps for only this type.

Determines whether the specified value is equal to the current . Because has a single value, this always returns .

An object to compare to the current value. Because has a single value, this always returns .

Determines whether the specified System.Object is equal to the current .

The System.Object to compare with the current . if the specified System.Object is a value; otherwise, .

Returns the hash code for the current value.

A hash code for the current value.

Returns a string representation of the current value.

String representation of the current value.

Determines whether the two specified values are equal. Because has a single value, this always returns .

The first value to compare. The second value to compare. Because has a single value, this always returns .

Determines whether the two specified values are not equal. Because has a single value, this always returns .

The first value to compare. The second value to compare. Because has a single value, this always returns .

Gets the single value.

Defines the source generated JSON serialization contract metadata for a given type.

The default associated with a default instance.

The source-generated options associated with this context.

Default implementation of that bundles the core services required by all agents: chat client factory, logger, user display, and file system.

Logs chat messages to the file system. Shared by both CAPI's FileSystemMessageInspector and VS UI's VsCopilotMessageLogger.

Represents the outcome of clean state processing for a single project.

Service for managing repository clean state when the --ensure-clean-state command line argument is enabled. Commits successful changes and rolls back unsuccessful ones.

Sets the initial coverage percentage for telemetry.

Coverage rate (0.0-1.0) which will be converted to percentage (0.0-100.0) before storing.

Sets the final coverage percentage for telemetry.

Coverage rate (0.0-1.0) which will be converted to percentage (0.0-100.0) before storing.

Locator that relies on the analyzers already referenced by the (Project.AnalyzerReferences). It does NOT load Roslyn feature assemblies explicitly; instead it surfaces only the analyzers that the project itself references. This is useful when the project already brings analyzer packages (NuGet) and we want to use exactly that set for formatting/fixing (Style/Analyzers modes).

Implementation of IChangeApplier that applies changes directly to the file system.

Applies solution changes directly to the CLI workspace.

The old solution before changes. The new solution with changes to apply. Token to cancel the operation. An operation result indicating success or failure.

Allowed unrestricted even in read-only mode.

Aggregates the core services required by all agents: chat client factory, logger, user display, and file system. This reduces constructor parameter count across all agents by bundling these frequently-used dependencies.

Factory for creating LLM chat clients used by agents for AI interactions.

Logger for diagnostic and informational messages.

Service for displaying messages to the user.

File system abstraction for file operations.

Builds a project or solution target.

The project or solution file path to build. Token to cancel the build operation. Additional command-line arguments for the build. If true, skips the restore operation during build. If true, creates a binary log file for the build. The build configuration to use (e.g., "Release"). If null, uses the default configuration. A task that represents the asynchronous build operation, containing the build result.

Restores NuGet packages for a project or solution.

The project or solution file path to restore. Token to cancel the restore operation. Additional command-line arguments for the restore. A task that represents the asynchronous restore operation, containing the operation result.

Provides an abstraction for applying solution changes in different environments.

Applies the specified solution changes asynchronously.

The old solution before changes. The new solution with changes to apply. Token to cancel the operation. An operation result indicating success or failure.

Merges multiple coverage files into a single output file.

The collection of coverage file paths to merge. The path where the merged coverage file will be created. Token to cancel the operation. The working directory for the merge operation. An operation result containing the path to the merged coverage file on success, or error information on failure.

Validates that the dotnet coverage tool is available and can be used for the specified scope.

The file or directory paths defining the coverage scope. The type of scope (File, Project, or Solution). Token to cancel the operation. An operation result indicating success if the coverage tool is available and valid for the scope, or error information on failure.

Collects information about the .NET runtime and SDK environment.

The working directory to run the info command from. Token to cancel the operation.

Provides the path to the git executable. Implementations can provide custom paths such as VS-bundled git.

Gets the path to the git executable. Returns "git" if git is expected to be in PATH, or a full path to git.exe.

Default implementation that returns "git" to use PATH resolution.

Defines a contract for authorizing files to be processed by an LLM (Large Language Model).

Determines whether the specified file is authorized for processing by the LLM.

The full path of the file to check. The cancellation token. if the file is authorized for LLM processing; otherwise, .

Adds a NuGet package reference to a project.

The path to the project file. The name of the NuGet package to add. The version of the package to add. Token to cancel the operation. If true, allows installation of prerelease packages. An operation result indicating success if the package was added successfully, or error information on failure.

Removes a NuGet package reference from a project.

The path to the project file. The name of the NuGet package to remove. Token to cancel the operation. An operation result indicating success if the package was removed successfully, or error information on failure.

Gets package information for a specific target framework, returning structured package data.

The path to the project file. The target framework to list packages for. Token to cancel the operation. An operation result containing package dictionary (package name -> resolved version) on success, or error information on failure.

Lists all NuGet packages (direct and transitive) referenced by a project for dependency analysis.

The path to the project file. Token to cancel the operation. An operation result containing all packages including transitive dependencies, or error information on failure.

Extracts project metadata including MSBuild properties and items.

The path to the project file. If specified, extracts metadata for this specific target framework. Token to cancel the operation.

Adds a project-to-project reference.

The path to the project file that will reference another project. The path to the project file to be referenced. Token to cancel the operation. An operation result indicating success if the project reference was added successfully, or error information on failure.

Formats code files according to the specified formatting mode.

The project to format. The type of formatting to apply (Everything, Whitespace, Style, or Analyzers). Optional list of file paths to scope formatting to. When null, formats all files in the project. Token to cancel the format operation.

Represents a telemetry session that can start activities.

Gets or sets the unique Run GUID for this telemetry session, used to correlate all telemetry from a single user-initiated run.

Starts a new activity with the specified name.

The name of the activity (without event prefix). An activity instance, or null if the activity should not be tracked.

Posts a point-in-time telemetry event with the specified name and tags.

The name of the event (without event prefix). The tags to attach to the event as key-value pairs.

Posts a fault event that will appear as a red diamond in Prism. No-op for implementations that do not support fault telemetry (e.g. OpenTelemetry).

The name of the fault event (without event prefix). A short description of the fault. The exception associated with the fault, if any.

OpenTelemetry implementation of ITelemetrySession.

No-op for OpenTelemetry — fault events are a VS Telemetry concept.

Checks if a specified path is part of the current workspace.

The file or directory path to be verified. Indication whether path not part of the current workspace should be logged. Returns true if the path is within the workspace; otherwise, false.

Lightweight wrapper enabling calls to MSBuild props/items and .net cli. Doesn't require nor support Roslyn capabilities. When is false, the return value is guaranteed to be non-null.

Gets the test project name that is suggested for the given source project.

Tool for analyzing potential production bugs. Called as a blocking tool from CodeGenAgent when it suspects a production bug. Creates a BugAnalysisAgent subagent with shared tools to avoid lock conflicts.

Core services for creating the subagent. Parent agent's tool instances (TextEditorTool, GrepTool, CodeAnalysisTool). Analysis report for recording production bug findings. Name of the test project file with extension. Cancellation token for the session.

Appends parameter details only when they provide useful namespace information. Skips System namespace types and types from the same namespace as the containing type.

Represents a single edit operation for undo history tracking. OriginalContent is null for Create (file didn't exist), otherwise full file content before edit.

// https://www.anthropic.com/engineering/claude-think-tool.

A strongly-typed resource class, for looking up localized strings, etc.

Returns the cached ResourceManager instance used by this class.

Overrides the current thread's CurrentUICulture property for all resource lookups using this strongly typed resource class.

Environment variable '{0}' is not set.

Failed to retrieve access token

Timeout of '{0}' while waiting for the semaphore

This API is not supported. Use the specific log methods instead.

Binlog is not available. Did you call 'InvokeDotnetBuildAsync' with 'createBinlog' set to true?

MSBuild.exe is only supported on Windows platforms.

The directory {0} does not exist.

No response from the LLM provider.

The LLM provider returned a too many tokens error.

Got an incomplete response from LLM.

Running

Building

Logs folder:

Running tests for '{0}'

Fixing diagnostics for {0} file(s) in project '{1}': {2}

Building project '{0}'

Generating unit tests for solution '{0}'

Generating unit tests for solutions {0}

Generating unit tests for project '{0}'

Generating unit tests for projects {0}

Generating unit tests for directory '{0}'

Generating unit tests for directories {0}

Generating unit tests for file '{0}'

Generating unit tests for files {0}

Fixing unit tests

Fixing unit tests in project '{0}'

Attempting to fix diagnostics for file '{0}'

Fixing failing tests in '{0}', {1} remaining

Trying to find test project for project '{0}'...

Attempting to fix errors for file '{0}'...

Analyzing {0} unit test '{1}'

Analyzing project '{0}' to find files to test...

Scanning file '{0}' from project '{1}' for testable code...

Fixed failing tests for project '{0}'

Failed to fix failing tests for project '{0}'

Failed to build test project '{0}'

Failed to build and to fix build errors for test project '{0}'

Failed to create a test project for the source project '{0}' at path '{1}'

Initial project restore failed for project '{0}'

Failed to list packages of project '{0}'

Failed to add package '{0}' version '{1}' to project '{2}'

Failed to restore after installing package '{0}' version '{1}' to project '{2}'

Test run completed for project '{0}'

No tests were executed for project '{0}'

Cannot determine test dependencies for the test project '{0}'

Failed to get semantic model for file '{0}'

No tests were generated for file '{0}'

No tests were generated for member '{0}.{1}' of file '{2}'

Unable to load project '{0}'. Please check that the project file is valid and accessible.

Project file not found for '{0}'. Please ensure the file is in a valid project directory.

Git command is not available on the system path. Please install Git or ensure it's properly configured.

Git repository not found for path '{0}'. Please ensure this is a valid Git repository.

Failed to restore packages for project '{0}'. Please check your package sources and network connectivity.

Failed to build test project '{0}'. Please check the build output for compilation errors.

Failed to automatically fix build errors for test project '{0}'. Manual intervention may be required.

Cannot determine work directory root from the provided parameters

Azure Foundry environment variables (AZFOUNDRY_URL, AZFOUNDRY_MODEL, AZFOUNDRY_APIKEY) must be set.

Invalid project '{0}'. ProjectPath XML root is null.

Cannot merge type '{0}' because it has no skeleton and multiple members: {1}

Unsupported instance of a 'BaseTypeDeclarationSyntax': {0}

There was a problem processing a node for file '{0}' Node: {1}

MethodStartOffset is not set for method '{0}' - cannot get relative position coverage info.

Member type '{0}' is not supported.

DiagnosticsResult is in an invalid state: Kind={0}, FileDiagnostics={1}, RoslynProject={2}, ErrorMessage={3}

Updated test file '{0}'

Created test file '{0}'

Finished processing project '{0}'

Prompt cannot be null or empty.

Workspace directory cannot be null or does not exist.

MCP server file '{0}' not found.

Workspace cannot be null or empty.

Failed to get syntax tree for file '{0}'

Failed to collect metadata for file '{0}': {1}

Failed to update test file '{0}': {1}

Failed to create test file '{0}': {1}

Error processing member '{0}': {1}

No tests were generated for any member in file '{0}'

Failed to merge test files for '{0}'

Member not found in stripped out class. Coverage and symbol info cannot be considered.

Found test project '{0}'

Could not find any existing test project for '{0}' scanning all projects in directory '{1}'

GitHub Copilot testing requests permission to run 'dotnet test' on project '{0}'. Do you want to allow this operation?

Yes

NuGet packages to be installed: {1} GitHub Copilot testing requests permission to install these packages, then restore and build the project '{0}'. Do you want to allow this operation?

User didn't give consent to agent action ('{0}'). Cancelling generation...

Test generation finished.

Took: {0}

Command line: {0}

GitHub Copilot testing crashed :-(

Crash Message: {0}

{0} {1}

Fixer Statistics:

-----------------------------------------------------------------------------------------------------

| {0} | {1,11} | {2,17} | {3,17} | {4} |

Errors encountered:

- {0}{1}

Generating tests for file '{0}' (processing member {1}/{2})

Retrying LLM request in '{0}'...

Failed to create chat client for agent '{0}' with integration ID '{1}' and model '{2}'.

CAPI_HMAC_SECRET environment variable is required for serverToServer authentication type.

Token provider is required for userToServer authentication type.

Initial coverage before first cycle: {0}%

Cycle {0} completed: {1}% coverage in {2}

Model used: {0}

The dotnet-coverage tool is required for coverage-based cycling with multiple projects. Please install it from https://learn.microsoft.com/dotnet/core/additional-tools/dotnet-coverage

Coverage increase (scope: {0}): {1}

Failed to build the project '{0}' before any actions has been taken by the agent. Please ensure buildability via 'dotnet build' (or 'msbuild.exe' - if you are using '--use-msbuild') command. If you are trying to fix broken code generated by incomplete run ...

LLM call failed for agent '{0}' after {1} attempts. See RetryExceptions for details of each failed attempt.

Failed to build the test project '{0}' (newly created by agent: {1}) before any tests has been generated by the agent. Please ensure buildability via 'dotnet build' (or 'msbuild.exe' - if you are using '--use-msbuild') command. If you are trying to fix bro ...

End line ({1}) cannot be less than start line ({0}).

Start line ({1}) cannot be less than the original member start line ({0}).

End line ({1}) cannot be greater than the original member end line ({0}).

Invalid project '{0}'. ProjectPath XML root is null.

Cannot determine project directory for '{0}'.

No errors

Test Agent run completed. {0}

All unit tests created successfully!

Some unit tests created successfully, but there were errors: {0}

Unit tests were created successfully, but {0} tests failed during execution. Errors from the generation process: {1}

Failed to create unit tests!

No unit tests were generated. This likely means there was nothing testable.

Pre-existing tests are failing, please fix them first.

Pre-existing tests are failing ({0} test(s) failed). Would you like to fix them before generating new tests?

Initial tests failed ({0} test(s)). Fixing them first before generating new tests.

User declined to fix failing pre-existing tests. Please fix the tests manually and try again.

Verifying test fixes

Failed to create any unit tests. Errors: {0}

User didn't give consent to agent to install NuGet packages. Cancelling generation...

Source file '{0}' not found in test files mapping

In CI environment you must specify '--require-untrusted-actions-consent false' explicitly.

Do you want to store your choice for future runs? You can later clear your preference using '--clear-preferences'. You can also override your stored choice for a single run using '--require-untrusted-actions-consent'.

GitHub Copilot testing can read, write, build, and run code in your solution, including creating new test projects, tests, and files. Learn more: [aka.ms/githubcopilot-testing](https://aka.ms/githubcopilot-testing). If you select Confirm: Copilot will run ...

User prompting in CI environment is unsupported. You must specify '--require-untrusted-actions-consent false'.

Generating tests for member '{0}'

Generated tests for '{0}.{1}'.

Generated tests for '{0}'.

Failed to generate tests for '{0}.{1}'.

The document to format was not found in the Roslyn workspace.

Unable to retrieve the compilation from the project.

Failed to apply solution changes to workspace.

Do you want to store your choice for future runs? You can later clear your preference using '@test /clear-preferences'.

Locating or creating a test project for '{0}'

Measuring coverage improvements

Used existing test project '{1}' for source project '{0}'

Created a new test project '{1}' for source project '{0}'

Created commit for successful test generation in project '{0}': {1}

Rolling back changes for project '{0}' due to unsuccessful test generation

Rolling back to last known good state due to unexpected termination

Clean State Summary:

The project '{0}' provided as input was detected to be a unit test project - so skipping tests generation for this project. Please specify a source code project instead.

The project '{0}' provided as input was detected to be a non-testable project (e.g., benchmark) - so skipping tests generation for this project. Please specify a source code project instead.

Built project '{0}'

Failed to build project '{0}'

Skipping file '{0}' - no testable members found

Skipping project '{0}' - no testable types (classes, structs, or records) found in specified source files

Skipping auto-generated file '{0}'

Removing test '{0}' from file '{1}' as it could not be fixed.

Commenting out test '{0}' in file '{1}' as it could not be fixed

Removing failing test '{0}' from file '{1}' (skip mode)

Commenting out failing test '{0}' in file '{1}' (skip mode)

Collecting initial coverage for test project '{0}'

Collected initial coverage for test project '{0}'

Attempt to get value of MSBuild property '{0}', while this was not in set of properties to query ({1})

Attempt to resolve nonconflicting version for '{0}' '{1}' (prerelease: {2}).

Cannot resolve nonconflicting version for '{0}' '{1}' - close version not found in the feed.

Cannot resolve nonconflicting version for '{0}' '{1}' via a simplified faster search (Reason: {2}). Hence falling back to comprehensive deep search.

InitializeAsync wasn't called

ProjectPath path must be fully qualified.

Unsupported dependency match: {0}

Unsupported TargetFrameworkVersion '{0}' in project '{1}', using fallback version net481

Initial run of tests before agent changes hasn't succeeded - the build failed.

Initial run of tests before agent changes hasn't produced any results.

Initial run of tests before agent changes had failing/skipped tests ({0} failing and {1} skipped out of {2} total tests). This is not problem for the agent, but it shows possible problems in preexisting tests - from which agent is taking inspirations.

Could not collect initial coverage. Error code: '{0}'.

Failed to compute git diff changes. Ensure the repository is accessible and has a valid git history.

No code changes detected in the git diff. There are no methods or types to generate tests for.

No code files changed in the git diff. Only non-code files were modified.

Processing changes from Git history

Coverage providing service is not available - cannot proceed with targeting specific coverage value.

Free prompt analysis failed:

I'm not confident enough to understand the test {0} (confidence: {1:F2}). Reason: {2}. Please be more specific about your requirements.

An internal error occurred while analyzing your prompt: {0}

Prompt is too long ({0} characters). Maximum allowed is {1} characters.

It appears you're asking for help or your request is unrelated to test generation. Reason: {0}. Please provide a specific testing task, such as: 'Generate tests for Calculator.cs', 'Test my uncommitted changes', or 'Fix failing tests in MyProject.Tests'.

Analyzing free-form prompt.

Analyzed free-form prompt.

Build succeeded.

Build failed.

Coverage file '{0}' is empty.

Coverage file '{0}' does not appear to be a valid Cobertura XML format.

Test fixing timeout reached. Deleted {0} failing test(s).

Test fixing timeout reached. Commented out {0} failing test(s).

Defines the source generated JSON serialization contract metadata for a given type.

The default associated with a default instance.

The source-generated options associated with this context.

WP9lnio3A1Slhu9SlZX+hnknJysxD2CU+b1AKZLwYl0=JRooBi2RnRAAovoqSRrVkih4Ic6DTHDHPE5ZhLYPiIB3sheBmD3C2BJRRJ7fjCN6xBUTFljRfDtIkXX60UIWnuYiR2kVZZBjJaKX7HvenFLgCiyu5AE03r01G3H0ebnH5zzQ4hEl5v9d+jiRSHCW8DvNaQZ1eZcoNRQX92R1M1gtUSLl+x0CbRJmPFkosAoFnCs5UQlG3zxVXrymEspNxW2qos/e3QgtevDkthcFraBeye1VX2Q+i9HOGRehewGhFYcYmoZJJSDJiIiv78NOuR8yl5uE6V0eXur7otlERrQZkF475qG2AJcczdpwjX60y2K8zh2zkHMMhTGvFmSAhQ==wEpIdXKb7lKn26sXpXuywkhxGplTQXxROLmNRZBrAHVBf7546RNXZwA/bzDqsuWTuPSC4T+I4j/z9j5/WqPuUw7SpnEPqWXc2xu7eN8kVyQt5170xkK6KHT4vVEkIvayPtIMLl0SgSCOy/pN5DJCi5ha7FlI84F1Qi2GumR+wQgCwHCVmU8Fj6Ik+B6akISXGCwe6X3rQFQngRFWQ/IrSkOkAOfy0EfvV+nZUo+FcbWuCZ6cb4Eq5I1ws/rZSeuwAWeedZcNt0VlNbsn4AnxBYQX4sj0dlko7JD5fWqeqq3/HzUNbBmLp9qeCXV8XlACn9YVWv900F47z04kVwpyTw==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