# Add a Regression Test for a Bug Fix in .NET with Atlas in 2026 > Atlas streamlines adding regression tests for .NET bug fixes, ensuring your xUnit tests fail before the fix and pass after, using `dotnet test`. Atlas helps .NET developers in 2026 add regression tests for bug fixes by guiding the creation of failing xUnit tests, applying precise code changes, and verifying the fix using `dotnet test`. This ensures that every bug fix is locked in with a test that fails before the change and passes after it, leveraging the familiar `dotnet` toolchain. ## Key takeaways - Atlas enforces a red-first, then green workflow for .NET bug fixes. - Atlas uses `xUnit via dotnet test` to validate regression tests. - Precise `edit` operations ensure targeted .NET code changes. - Every Atlas action on your .NET codebase is permission-gated and diff-reviewed. - Atlas integrates directly with your existing `dotnet` toolchain and `git` workflow. ## How Atlas automates .NET regression testing workflow Atlas streamlines adding regression tests for .NET bug fixes by enforcing a red-first, then green discipline. This ensures that a new xUnit test fails to reproduce the bug before any code changes are applied, providing a clear 1:1 validation of the fix. Atlas uses `bash` to run `dotnet test` and capture precise exit codes. Atlas guides the entire regression testing workflow for .NET applications, starting with reproducing the bug. It leverages its `bash` tool to execute `dotnet test` commands, capturing the exact output and process exit code. This unambiguous feedback is crucial for confirming a test fails before a fix and passes after. Atlas then assists in writing the regression test, applying the fix, and re-running the test, ensuring the bug is locked in. Atlas's ability to read `git` branches, status, and diffs also helps manage the changes throughout this process, providing a comprehensive solution for .NET developers. ## Writing failing xUnit tests for .NET with Atlas Atlas assists in writing specific xUnit regression tests that initially fail, proving the bug's existence before a fix is implemented. Using the `write` tool, Atlas generates test code directly into your .NET project, often in a file like `MyProject.Tests/BugFixTests.cs`, ensuring the test targets the exact faulty behavior. This process is a core part of the 2026 development cycle. To write a failing xUnit test, Atlas uses its `write` tool. You instruct Atlas to create a new test method or even an entire test class within your existing .NET test project, such as `MyProject.Tests/RegressionTests.cs`. Atlas understands the structure of your .NET solution, identified by `.sln` or `.csproj` files, and can correctly place the new test code. The goal is to assert on the observed wrong behavior, ensuring the test fails when the bug is present. After writing, Atlas can prompt you to run `dotnet build` to compile the new test code before executing it with `dotnet test` to confirm its initial failure state. ## Applying .NET bug fixes and verifying with `dotnet test` After a regression test is confirmed to fail, Atlas applies the bug fix using its `edit` tool, which requires an exact `oldString` for precise replacements within your .NET codebase. Atlas then re-runs the same `dotnet test` command to confirm the test now passes, typically within 1-2 seconds for a focused test suite. This ensures the fix is effective. Once the xUnit regression test is confirmed to fail, Atlas proceeds to apply the bug fix. It uses the `edit` tool, which is designed for precise code modifications. This tool requires an exact `oldString` to prevent ambiguous multi-match replacements, ensuring that only the intended code in your .NET project, such as a method in `MyProject/BuggyService.cs`, is altered. Atlas computes a unified diff for every proposed file edit and surfaces it for your approval, maintaining full transparency. After the fix is applied, Atlas re-runs the specific `dotnet test` command to verify the regression test now passes. Subsequently, Atlas can run the wider test suite with `dotnet test` to check for any collateral damage or unintended side effects across your ASP.NET Core application. ## Atlas safety and review for .NET code changes Atlas prioritizes safety and developer control when modifying .NET code, offering multiple layers of review before any changes are committed. Every Atlas tool call is permission-gated, and it drafts a plan in a read-only agent before switching to a build agent. This ensures you review 100% of proposed changes, including those to `csproj` files or C# source. Atlas is built with robust safety features to give .NET developers complete control over their codebase. Every tool call, whether it's `write`, `edit`, or `bash`, is permission-gated against allow, ask, and deny rules. Before making any modifications, Atlas drafts a plan in a read-only plan agent, allowing you to review the proposed actions without risk. Only after your approval does it switch to a build agent to execute the plan. For every file edit, Atlas computes and surfaces a unified diff, which you must approve before any changes are written to your .NET project. Atlas also reads `git` branches, status, and diffs, and can stage and create commits on your behalf, ensuring a secure and controlled workflow for your ASP.NET Core applications. ## Steps 1. Reproduce the .NET bug: Use `atlas bash` to run the exact `dotnet` command that exposes the bug, capturing its output and exit code. For example, `atlas bash "dotnet run --project MyBuggyApp -- SomeArgument"` or `atlas bash "dotnet test --filter 'MyProject.Tests.BuggyTest.Fails'"`. 2. Write the failing xUnit regression test: Instruct Atlas to `write` a new xUnit test method or class in your .NET test project (e.g., `MyProject.Tests/RegressionTests.cs`) that asserts on the observed wrong behavior. 3. Confirm the xUnit test fails: Execute the newly written xUnit test using `atlas bash "dotnet test --filter 'MyProject.Tests.RegressionTests.BugReproduces'"`. Verify that the `bash` tool records a non-zero exit code, confirming the test fails as expected. 4. Apply the .NET bug fix: Use `atlas edit` to apply the necessary code changes to your .NET application. For instance, `atlas edit --file MyProject/BuggyService.cs --oldString "return false;" --newString "return true;"`. Review the unified diff presented by Atlas. 5. Verify the fix and check for regressions: Re-run the specific xUnit regression test with `atlas bash "dotnet test --filter 'MyProject.Tests.RegressionTests.BugReproduces'"`. Confirm the test now passes (zero exit code). Then, run the full test suite with `atlas bash "dotnet test"` to check for any collateral damage across your .NET solution. 6. Format and commit .NET changes: Use `atlas bash "dotnet format"` to ensure code style consistency. Then, leverage Atlas's `git` capabilities to stage and create commits on your behalf, locking in the .NET bug fix and its regression test. ## FAQ ### How does Atlas ensure my .NET regression test actually reproduces the bug? Atlas uses the `bash` tool to run your `dotnet test` command and captures the exact process exit code. A non-zero exit code unambiguously confirms the xUnit test fails before the fix, proving the bug's reproduction. ### Can Atlas modify my .NET project files, like `.csproj`? Yes, Atlas can modify `.csproj` files or other project configuration as needed. All such changes are presented as a unified diff for your approval before Atlas writes them to disk, ensuring full transparency and control. ### What .NET testing frameworks does Atlas support? Atlas directly supports `xUnit via dotnet test` as the primary test runner for .NET projects. Its `bash` tool can execute any command, making it adaptable to other frameworks if they integrate with `dotnet test`. ### How does Atlas handle code formatting in .NET projects? Atlas integrates with `dotnet format`. After applying a fix, you can instruct Atlas to run `atlas bash "dotnet format"` to ensure all modified C# code adheres to your project's style guidelines. ### Is my .NET code sent to external servers when using Atlas for embeddings? No, Atlas can build its code index with local Ollama embeddings, keeping your sensitive .NET code entirely off third-party servers. This provides a secure environment for your proprietary codebase. ### How does Atlas prevent accidental changes to my .NET codebase? Atlas employs several safety mechanisms: every tool call is permission-gated, it drafts plans in a read-only agent, and it presents a unified diff for every file edit for your explicit approval before writing any changes to your .NET project. ### Can Atlas help me commit the .NET bug fix and test? Yes, Atlas reads `git` branches, status, and diffs. After verifying the fix, you can instruct Atlas to stage and create commits on your behalf, streamlining the process of locking in your .NET bug fix and its regression test. --- Canonical HTML: https://runatlas.sh/resources/stacks/add-a-regression-test-for-a-bug-fix-in-dotnet Source of truth: aeo_pages row `/resources/stacks/add-a-regression-test-for-a-bug-fix-in-dotnet` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.