SteveGilham/altcover

AltCover is a .NET code coverage tool that instruments assemblies to record execution data and generates reports in standard formats like Cobertura, OpenCover, and Lcov. It provides a comprehensive ecosystem including a CLI, a data collector for test platforms, and integration APIs for build systems such as Cake and FAKE. The system also features a desktop visualizer for inspecting coverage metrics and a toolkit for converting and processing coverage data across various XML schemas.

22 changes.

The project underwent a significant architectural overhaul, migrating to the .slnx solution format and establishing a centralized, type-safe build infrastructure with strong-naming and reproducible build standards. This period saw the introduction of a new dual-language recorder component, a type-safe CLI, and extensive integration support for Cake and FAKE build systems. Additionally, the codebase expanded with multiple visualization tools (GTK\#, Avalonia), PowerShell cmdlets, and comprehensive demo projects to validate coverage across diverse environments like Windows Services and multi-test solutions.

48 changes.

This period focused on refactoring the AltCover engine to expose a structured, C\#-friendly API for instrumentation control and integrating coverage tools directly into Fake build scripts. The team significantly expanded the toolkit with new libraries for report conversion, visualization, and real-time monitoring, while adding extensive sample projects to demonstrate modern C\# and F\# language features.

7 changes.

This period focused on enhancing the tool's integration capabilities by introducing database pipeline steps and centralizing MSBuild targets to streamline code coverage workflows. Development also involved restructuring internal assembly visibility and consolidating test data to support robust validation across multiple .NET versions.

Introduces a new \AltCover.Fake.DotNet.Testing.AltCover\ module that enables running AltCover code coverage tools within Fake build scripts. This includes functions to compose command lines for \dotnet test\ and other test runners, allowing users to configure and execute AltCover collect and prepare operations directly from their build definitions.

AltCover.Fake.DotNet.Testing.AltCover · high confidence

This location introduces a forked Roslyn Source Generators sample (Samples/Sample28) containing both the generator implementations and a demo application. The \SourceGeneratorSamples\ directory provides several custom source generators, including \AutoNotifyGenerator\ (generating INotifyPropertyChanged properties), \CsvGenerator\ (creating strongly-typed classes from CSV files), \HelloWorldGenerator\, \MathsGenerator\ (parsing a custom math language), \MustacheGenerator\ (pre-compiling Mustache templates), and \SettingsXmlGenerator\ (generating settings classes from XML). The \GeneratedDemo\ directory provides a console application that exercises these generators, utilizing generated code for features like auto-notify view models, CSV data loading, and math formula evaluation.

Samples/Sample28 · high confidence

New sample projects have been added to the repository. Sample14 demonstrates a console application that instantiates internal classes and calls methods from Sample5, accompanied by an AltCover code coverage report. Sample16 provides a library with a string-switching utility and a corresponding xUnit test suite to verify its behavior, along with solution files for building and testing.

Samples/Sample14, Samples/Sample16 · high confidence

A new sample project (Sample22) has been added to demonstrate AltCover instrumentation and testing workflows. The sample includes a test suite that validates OpenCover-style XML coverage reports through a recursive validation function, ensuring structural integrity and attribute correctness of the generated coverage data. It integrates NUnit for test execution and Unquote for assertion syntax, while providing common test utilities for handling file operations and conditional compilation across .NET Framework and .NET Core targets.

Samples/Sample22 · high confidence

A new sample assembly (Samples/Sample3/Class1.cs) is introduced to exercise AltCover's instrumentation capabilities. It includes classes demonstrating both standard mutable properties and C\# 9+ init-only properties (guarded by \#if !MONO), alongside a nested class containing a generic method with exception handling and a static method that analyzes Mono.Cecil IL instructions. The file also defines the AltCover.Recorder.InstrumentationAttribute, configuring the assembly for unit testing instrumentation.

Samples/Sample3 · high confidence

A new sample project (Sample31) has been added to demonstrate working with Mono.Cecil, specifically illustrating how to inspect IL instructions and categorize operands (such as arguments, locals, fields, and calls) using the Cecil API. The sample includes helper classes and logic to log and report on these IL operations, serving as a reference for Cecil 0.11.4 compatibility.

Samples/Sample31 · high confidence

A new demo project has been added to demonstrate gathering code coverage from a Windows service running with reduced privileges (NETWORK SERVICE). This includes the service implementation, a solution file, and a PowerShell script to grant the necessary execute permissions to the Network Service account, along with documentation on how to build, install, and instrument the service for coverage analysis.

Demo/Service · high confidence

Introduces a new AltCover.FontSupport library that provides font selection capabilities on both Windows and non-Windows platforms. On Windows, it implements a wrapper around the native Win32 ChooseFont dialog via P/Invoke to allow users to pick fonts. On non-Windows systems, it integrates with the Tcl/Tk 'wish' interpreter to drive a font selector if available, ensuring consistent font picking functionality across different operating systems.

AltCover.FontSupport · high confidence

Introduced two new pipeline steps: SaveContextToDatabaseStep, which executes SQL statements to modify data and records the number of affected rows, and SupplementContextWithDatabaseRecordStep, which queries the database to add or update fields in the pipeline context before passing control downstream and restoring original values afterward. Both steps support configurable SQL statements, parameter binding from context items, and connection string retrieval via async delegates, with corresponding unit tests validating construction, error handling for null connections or missing records, and successful data supplementation.

RegressionTesting/issue143 · high confidence

A new sample project (Samples/Sample0) has been added to demonstrate a minimal implementation targeting .NET 2.0. This sample serves as a proof of concept, outputting a simple "Hello, World!" message to the console, providing a baseline for compatibility or legacy framework testing.

Samples/Sample0 · high confidence

A new C\# source file (Say.cs) has been added to the Sample25 directory, providing a static class with a Hello method that prints a greeting to the console. This serves as a code sample demonstrating basic C\# usage within the sample project.

Samples/Sample25 · high confidence

A new C\# sample program has been added to the Samples/Sample1 directory. This test program demonstrates report generation logic by printing a message to the console based on the current year, specifically checking if the year is greater than 2000.

Samples/Sample1 · high confidence

A new C++ sample (SimpleMix) has been added to demonstrate mixed-mode compilation, allowing native C++ code to be called from managed C++/CLI code. This example specifically illustrates how to use pin pointers to pass strings between the native and managed worlds, providing a concrete reference for developers needing to interoperate between unmanaged and managed code on Windows.

Samples/Sample29 · high confidence

Added the NCover 1.5.8 profiler files to the ThirdParty/ncover directory, including the console executable configuration targeting .NET Framework 2.0, the Visual C++ 8.0 CRT manifest, the XML coverage output schema, the XSL report stylesheet, and the FAQ documentation. This enables code coverage analysis for .NET Framework 2.0 applications using the NCover tool.

ThirdParty/ncover · high confidence

A new sample project (Sample11) has been introduced to address coverage tooling issues with \ref struct\ types. The sample defines a \Token\ ref struct and two obsolete variants (\OldToken\ and \AncientToken\) marked with \\[Obsolete\]\ attributes to verify that coverage tools correctly handle these types, specifically ensuring they are not incorrectly flagged as obsolete or excluded from coverage inappropriately.

Samples/Sample11 · high confidence

A new sample project (Sample17) has been added to the repository, containing a library that defines message types (AsyncItem, Item, Finish) and a processing function that applies different multipliers based on the message content and close state.

Samples/Sample17 · high confidence

A new sample project (Sample2.fs) has been added to demonstrate F\# patterns, including a record type with a byte-conversion method, a discriminated union with conversion logic, and unit tests using the Unquote library. The sample includes conditional compilation for .NET Framework 4.7.2 and exposes internals to AltCover for testing.

Sample2 · high confidence

A new sample file (Sample26.fs) has been added to demonstrate integration between AltCover and the Unquote testing library. The sample includes unit tests that verify basic F\# types (records, discriminated unions) while simultaneously calling AltCover's Monitor.TryGetVisitTotals to assert specific code and branch coverage metrics, ensuring that the instrumentation correctly tracks execution paths during test runs.

Sample26 · high confidence

A new sample project (Sample27) has been added, containing a basic entry point and a unit test module. The tests demonstrate an asynchronous pattern using F\# async workflows, specifically verifying that an async addition function correctly returns the sum of two integers.

Samples/Sample27 · high confidence

A new sample project (Sample6) has been added to the repository, containing assembly metadata and a library module. The library demonstrates modern F\# patterns, including the use of the \use!\ keyword for asynchronous resource management within async workflows and the use of \List.map\ combined with \Async.Parallel\ for concurrent URL fetching.

Samples/Sample6 · high confidence

A new sample project (Sample7) has been introduced, containing a library module that demonstrates unit testing in F\# using NUnit and FsUnit. The sample includes tests for basic arithmetic operations, exception handling within try/finally blocks, and object-oriented interactions involving custom structs and classes, providing a reference implementation for users looking to set up similar testing patterns.

Samples/Sample7 · high confidence

New XSD files have been added to the AltCover.Toolkit/xsd directory to define the structure for Cobertura, NCover, NCoverEmbedded, OpenCover, and OpenCoverStrict coverage report formats. These schemas validate the XML output generated by the toolkit, ensuring compatibility with standard coverage tools and enforcing strict structure for OpenCover reports (including branch points and tracked method references).

AltCover.Toolkit/xsd · high confidence

New F\# source files were added to the Demo/MultiTest directory for System1 and System2. System1 defines a record type with a method to convert its string property to bytes, while System2 defines a discriminated union with conversion logic, a simple class, and helper functions. These files serve as sample code for the multi-test demonstration environment.

Demo/MultiTest/System2 · high confidence

The Sample4 directory now includes placeholder data files (Bar.txt and Foo.txt in the root and Deeper subdirectories) and ResX resource files for string localization. The default resource file (Strings.resx) contains an English greeting ('Hello!'), while the Esperanto resource file (Strings.eo.resx) provides the corresponding translation ('Saluton!'), enabling the sample to demonstrate multi-language support.

Samples/Sample4 · high confidence

A new sample (Sample30) has been added that includes a unit test verifying the behavior of F\# \task { ... }\ computation expressions. The test confirms that asynchronous tasks correctly return the expected sum of inputs, providing a reference implementation for using async tasks within this codebase.

Samples/Sample30 · high confidence

A new unit test file (UnitTest1.cs) has been added to the Sample24 project. It includes a test case verifying that an asynchronous addition method returns the same result as its synchronous counterpart, serving as a demonstration of async/await usage within the NUnit framework.

Samples/Sample24 · high confidence

A new xUnit demonstration has been added to the project, featuring a test class that includes both a passing assertion (verifying that 2+2 equals 4) and a failing assertion (expecting 2+2 to equal 5). This serves as a practical example of xUnit usage in .NET, illustrating how test outcomes are reported when assertions succeed or fail.

Demo/xunit-dotnet · high confidence

The AltCover command-line interface now includes a dedicated entry point configuration via a new DotnetToolSettings.xml file, which registers the 'altcover' command to execute AltCover.dll. The corresponding Program.fs file implements the main entry point, forwarding execution to the core AltCover.Main.main module while handling platform-specific logic (distinguishing between .NET Core and .NET Framework 4.7.2) to ensure cross-platform consistency.

AltCover · high confidence

The AltCover.Cake project now includes an AssemblyInfo.cs file that defines core assembly metadata, including the title, CLS compliance, and COM visibility settings. This configuration explicitly suppresses a strong-naming rule violation, acknowledging that the Cake build system itself does not require strong-named assemblies.

AltCover.Cake/Properties · high confidence

A new in-process data collector component has been added to the AltCover suite. This component integrates with the Microsoft Visual Studio Test Platform to monitor test execution, specifically handling session start/end and test case start/end events. Its primary function is to locate the AltCover.Recorder assembly and activate its supervision mode during test runs, ensuring that code coverage data is properly flushed when the test session concludes. The implementation includes localized error messages for scenarios where the recorder or its API components are not found.

AltCover.DataCollector · high confidence

The AltCover.Recorder component is now implemented in both C\# and F\# variants, providing the core infrastructure for coverage data collection. This includes the \Instance\ module for managing global state (such as report file paths, sampling strategies, and supervision mode), the \Tracer\ for serializing visit data to compressed \.acv\ files, and shared base types like \ReportFormat\ and \Track\ for handling coverage metadata. The recorder also introduces the \InstrumentationAttribute\ to label instrumented assemblies with provenance hashes and adds localized resource strings for user-facing messages.

AltCover.Recorder · high confidence

The AltCover.Avalonia project now provides a new desktop application for viewing coverage data, built on the Avalonia UI framework. This includes the main window layout with a file tree, source code viewer, and branch coverage indicators, an About dialog, and configuration persistence for window geometry and font settings. The application supports both Avalonia 10 and 11 via conditional compilation, allowing users to inspect coverage results in a cross-platform desktop environment.

AltCover.Avalonia · high confidence

The AltCover Visualizer is now available as a GTK\# desktop application, providing a graphical interface for viewing coverage and static analysis reports. This release adds a complete UI implementation using Glade XML layouts and GTK\# widgets, including a main window with a class structure tree, source code viewer, and toolbar for file operations. The visualizer supports persistent configuration storage (window geometry, font settings, and recently opened files) via platform-specific mechanisms (Registry on .NET Framework, Configuration API on .NET Core/5+). It also includes cross-platform browser launching for documentation links and handles resource loading for both GTK\#2 and GTK\#3 runtimes.

AltCover.Visualizer · high confidence

Added the AltCover.Monitor component, which provides real-time insights into the code coverage recording process. This new library exposes a static Monitor class with a TryGetPointTotals method, allowing users to retrieve current sequence and branch point counts from the underlying AltCover recorder during execution. The implementation handles assembly discovery and XML report parsing to surface these metrics, with specific namespace scoping (AltCover.Local) in debug builds to support unit testing.

AltCover.Monitor · high confidence

The AltCover.DotNet library now exposes a structured API (CLIOptions, Prepare, Collect) that allows users to programmatically configure and control the output directory, report formats, and other instrumentation parameters when running \dotnet test\. This change enables managed control over the coverage generation process, replacing previous workarounds with a dedicated interface for setting up the test environment.

AltCover.DotNet · high confidence

The AltCover.Toolkit library has been introduced to provide a modular API for coverage report manipulation. It includes modules for converting between coverage formats (OpenCover, NCover, Lcov, Cobertura, and JSON), post-processing OpenCover reports to fix dialect-specific gaps (such as those from Coverlet), and generating HTML-based reports (including bar charts and source-code views). This toolkit exposes the core logic previously embedded in the main application, allowing for more flexible integration and reuse of coverage data transformation capabilities.

AltCover.Toolkit · high confidence

The AltCover.UICommon library has been introduced to provide shared code for the coverage and static analysis visualizer. This component adds support for reading and displaying coverage reports from multiple formats, including NCover, OpenCover, Cobertura, and LCov, by normalizing them into a common internal structure. It also introduces configuration management for user settings (such as font and folder preferences), a generic tree-based UI model for displaying coverage data, and a comprehensive set of icons for the visualizer interface.

AltCover.UICommon · high confidence

Adds a new C\#-based API to the AltCover.Cake package, providing Cake method aliases for instrumentation (\Prepare\), collection (\Collect\), and a seamless integration with \dotnet test\ via \DotNetTest\. This allows users to drive AltCover's coverage operations directly from Cake build scripts with configurable logging and argument customization.

AltCover.Cake · high confidence

This change introduces a new 'Echo' demo application that listens on TCP port 18000 and echoes back any text received from a client. It includes a unit test that launches the application as a detached process and verifies the echo behavior. The demo is supported by a FAKE build script (build.fsx) that manages dependencies (Fake 5.16.1), builds the project, runs tests with AltCover for code coverage, and generates HTML reports, all accessible via a provided demo.bat script.

Demo/Echo · high confidence

Introduces a new \AltCover.Fake\ module that provides extension methods for \Fake.DotNet.DotNet.TestOptions\, allowing users to easily integrate AltCover code coverage into FAKE build scripts. The API exposes \WithAltCoverOptions\ to pass prepare and collect configurations, \WithAltCoverImportModule\ to enable module importing, and \WithAltCoverGetVersion\ to retrieve version information, all by extending the standard .NET test command options.

AltCover.Fake · high confidence

The AltCover.PowerShell module now includes a suite of new cmdlets to manage and transform coverage data directly within PowerShell. Users can now create custom type accelerators (e.g., \\[xdoc\]\) using \Add-Accelerator\ and \Get-Accelerator\. The module provides conversion tools such as \ConvertTo-XmlDocument\, \ConvertTo-XDocument\, \ConvertTo-Lcov\, \ConvertTo-CoverageJson\, and \ConvertTo-BarChart\ to transform coverage reports between formats like OpenCover, NCover, Lcov, JSON, and HTML. Additionally, \Compress-Branching\ allows for refining OpenCover data by removing compiler-generated noise, and \Merge-OpenCover\ enables combining multiple report files into a single composite report.

AltCover.PowerShell · high confidence

A new demo project has been added to demonstrate a Windows Service running under the NETWORK\_SERVICE account. This proof-of-concept service is designed to test code coverage scenarios, featuring an installer that configures the service to start automatically and run with limited privileges. The implementation uses asynchronous workflows for its internal logic and logs activity via Debug.WriteLine for easy monitoring with tools like DebugView, though it is not currently integrated into the main build due to the elevated permissions required for service installation.

Demo/Service/Service · high confidence

The AltCover toolkit now includes new XSLT stylesheets that enable conversion of coverage data from Cobertura and OpenCover formats into the extended NCover XML format, and further into HTML bar-chart reports. Specifically, CoberturaToNCoverEx.xsl and OpenCoverToNCoverEx.xsl map source coverage and branch data into NCover's module/method structure, while NCoverToBarChart.xsl generates a styled HTML report with expandable module and method details.

AltCover.Toolkit/xsl · high confidence

Added a new demo application in the \Demo/inspector\ directory that uses Mono.Cecil to analyze .NET assemblies. The tool scans assemblies for specific instrumentation patterns (calls to \AltCover.Recorder.Instance.Visit\) and reports suspicious code structures, such as incorrect visit numbers, missing module IDs, or unexpected control-flow jumps, to help users verify the integrity of instrumented code.

Demo/inspector · high confidence

Added Sample10, Sample12, and Sample20 to the repository. Sample10 includes a unit test verifying file existence. Sample12 provides a .NET Framework 4.6.2 console application that prints command-line arguments and returns an exit code. Sample20 is a comprehensive test suite demonstrating abstract classes, async handlers, code contracts, partial classes, generics, and coverage exclusion attributes, accompanied by Cobertura and DynamicCodeCoverage XML reports.

(repo-wide) · high confidence

The AltCover.Engine assembly has been refactored to expose a new, C\#-friendly API for command-line options. This change introduces the \Abstract.fs\ module, which defines \ICollectOptions\ and \IPrepareOptions\ interfaces that map directly to the tool's command-line arguments (such as \--recorderDirectory\, \--inputDirectory\, and \--cobertura\). The existing \CollectOptions\ and \PrepareOptions\ types now wrap these interfaces alongside their original primitive and type-safe variants, allowing external consumers to interact with the engine using standard .NET interfaces rather than F\#-specific types.

AltCover.Engine · high confidence

The project has migrated from the legacy .sln format to the new .slnx solution format, restructuring the repository into distinct solution files for the main build, the visualizer, and the build infrastructure itself. This change introduces centralized package version management via Directory.Packages.props and standardizes build outputs through new Directory.Build.props and Directory.Build.targets files, which enforce reproducible builds, centralize strong-naming, and configure flat output directories for all compiled artifacts.

(repo-wide) · high confidence

A change to existing behaviour in ThirdParty/ziplib.net20 — 1 commit, 2 files.

ThirdParty/ziplib.net20 · medium confidence · unverified

The Sample32 sample now includes a Class1 implementation that extends IServiceCollection with AddSingleton overloads supporting multiple generic type constraints (e.g., T : class, T1, T2). This sample provides the source code and associated coverage reports (Coverlet and OpenCover) used to reproduce and analyze the behavior of these generic registrations.

Samples/Sample32 · high confidence

New AssemblyInfo.fs files have been added to the Sample2 and Sample26 directories. These files explicitly set the assembly to be CLS-compliant and mark it as non-visible to COM, ensuring consistent metadata configuration for these sample projects.

Samples/Sample2, Samples/Sample26 · high confidence

A new 'Making.txt' file has been added to the ThirdParty/gtk-sharp2 directory, documenting the manual process for decoupling the build from the Global Assembly Cache (GAC). The instructions detail how to copy assemblies, decompile them, and configure project properties (such as Deterministic and ProduceOnlyReferenceAssembly) to generate reference assemblies, supporting the shift away from GAC-dependent builds.

ThirdParty/gtk-sharp2 · high confidence

The AltCover.Base library now includes explicit assembly metadata defining it as CLS-compliant, non-visible to COM, and neutral-resource-language set to en-GB. Additionally, it grants internal visibility to the core AltCover components (AltCover.Engine, AltCover.PowerShell, AltCover.Toolkit, and the main AltCover assembly) using a specific public key for production builds, while switching to a self-test signing key for DEBUG builds to facilitate internal testing.

AltCover.Base · high confidence

The AltCover.Async module now provides the core infrastructure for tracking asynchronous execution contexts within the recorder. This change introduces the \Instance\ class (in C\#) and corresponding F\# module, which utilize \AsyncLocal\<Stack\<int\>\>\ to maintain per-async-context call stacks. This mechanism replaces previous approaches that relied on \Option\<int list\>\ and separate update methods, thereby eliminating dangling metadata-id references and simplifying the recorder's async process by storing and writing only deltas.

AltCover.Async · high confidence

The \AltCover.TestData\ project has been established as a central bucket for test fixtures, consolidating resources previously scattered in \AltCover.Tests\. This location now provides the core test project configuration (\AltCover.Tests.xml\) targeting .NET 10.0 and .NET Framework 4.7.2, along with essential usage documentation (\AltCover.Usage.txt\, \AltCover.Runner.Usage.txt\) and a comprehensive suite of sample coverage reports (XML, JSON, Cobertura, Lcov) and F\# type analysis data required for validating the tool's instrumentation and reporting capabilities.

AltCover.TestData · high confidence

The MCS component has been refactored to use Mono.CSharp for C\# compilation instead of the previous method. This change includes a new entry point (Program.fs) that invokes the Mono.CSharp driver and, upon successful compilation, applies a fix to the generated symbol file (.mdb) to ensure the Module Version ID (MVId) matches the assembly metadata, resolving previous symbol file mismatch issues.

MCS · high confidence

Samples 15 and 19 have been migrated from the traditional .sln format to the new .slnx solution format. This change updates the solution files (Sample15.slnx and ConsoleApp2.slnx) to use the new XML-based structure, ensuring compatibility with the updated tooling while preserving the existing project configurations and source code.

Samples/Sample15, Samples/Sample19 · high confidence

The RegressionTesting project has migrated its solution file to the new .slnx format (SoakTest1.slnx) and introduced a Directory.Build.props file to centralize build settings. This configuration disables implicit F\# Core and System.ValueTuple references, ensures .NET Framework reference assemblies are not automatically provided, and enables centrally managed package versions for the regression tests.

RegressionTesting · high confidence

The build system has been restructured to introduce a new type-safe API for configuring AltCover, replacing the previous weakly-typed options with strongly-typed F\# modules (\Primitive\, \TypeSafe\) in the \AltCover.Engine\. This change includes new build scripts (\AddStrongName.fsx\, \Program.fs\) and documentation (\Fake-and-Cake-integration.md\) to support the updated API, while also updating the target framework to \net10.0\ in \Directory.Build.props\ and adding PowerShell integration tests (\Pester.Tests.ps1\) to verify the new command-line interface and conversion utilities.

Build · high confidence

The build process for third-party dependencies has been updated to ensure compatibility with newer F\# Core versions. Specifically, the \BlackFox.CommandLine\ and \Unquote\ assemblies are now rebuilt using ILASM to target F\# Core versions 4.7.0.0 and 5.0.0.0 respectively, replacing previous static linking or version mismatches. Additionally, patches for \Microsoft.PowerShell.CodeAnalysis\ have been updated to reflect version bumps in FxCopSdk and Microsoft.Cci (from 10/15 to 16) and to adjust method signatures for \get\_AnalysisAssemblies\ to return \ReadOnlyCollection\ instead of \AssemblyNodeCollection\.

ThirdParty · high confidence

The AltCover NuGet package now uses a consolidated set of MSBuild files (AltCover.proj, .props, and .targets) to manage code coverage, replacing the previous per-TFM folder structure. This change centralizes configuration and simplifies usage by automatically hooking into the \dotnet test\ workflow for projects marked as test projects, while also introducing managed control over the output directory and improved cleanup of temporary runsettings files.

nupkg · high confidence

Add SoakTest1 to verify thread-local state handling in parallel execution; Add validation tests for Gendarme cyclomatic complexity emulation; Added .NET SDK 2.1.500 solution-level test demo; Added Sample5 demonstrating edge cases in instrumentation; Added comprehensive API tests for coverage format conversions; Added initial unit test structure for Sample9; Added regression test for Issue \#20 targeting .NET 10; Added regression test for issue \#37 ternary operator behavior; Added regression test for issue 156; Added unit tests for AltCover Monitor coverage counting; Added unit tests for AltCover Visualizer components; Added unit tests for AltCover.Recorder; Added unit tests for Sample18; Added unit tests for Sample4 types; Added unit tests for discriminated union operations; Sample21 adds unit tests and code coverage configuration.

Added a new \AltCover.Api.Tests\ project targeting \net10.0\ and \net472\ to provide API-level test coverage, alongside various updates to existing project files (such as \AltCover.Avalonia\, \AltCover.Engine\, and \AltCover.Fake\) to align dependencies and build configurations.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 58 → 53 (-4.9)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 50 → 41 (-9.3)
• Architecture 95 → 94 (-0.8)
• Maturity 51 → 52 (+1.2)
• Readiness 88 → 88 (+0.0)
• Security 69 → 64 (-5.0)

• BarePragmaDisable (AltCover.Cake/DotNet.cs)
• BarePragmaDisable (AltCover.Cake/Options.cs)
• BarePragmaDisable (AltCover.Monitor/Monitor.cs)
• BarePragmaDisable (AltCover.Monitor/Monitor.cs)
• BarePragmaDisable (AltCover.Monitor/Monitor.cs)
• BarePragmaDisable (AltCover.Monitor/Monitor.cs)
• BarePragmaDisable (AltCover.Monitor/Monitor.cs)
• BarePragmaDisable (AltCover.Monitor/Monitor.cs)
• Bounded contexts not declared
• Dependency hygiene not measured — no packages were read
• Duplicated block (10 lines × 2) (AltCover.Engine/Json.fs)
• Duplicated block (10 lines × 2) (AltCover.Visualizer/Visualizer.fs)
• Duplicated block (11 lines × 2) (AltCover.DotNet/Options.fs)
• Duplicated block (11 lines × 2) (AltCover.Engine/Instrument.fs)
• Duplicated block (11 lines × 2) (Samples/Sample2/Sample2.fs)
• Duplicated block (12 lines × 2) (AltCover.Engine/LCov.fs)
• Duplicated block (12 lines × 2) (AltCover.Engine/Tasks.fs)
• Duplicated block (12 lines × 2) (AltCover.Engine/Tasks.fs)
• Duplicated block (12 lines × 2) (AltCover.Engine/Tasks.fs)
• Duplicated block (12 lines × 2) (AltCover.FontSupport/ChooseFont.cs)
• …and 48 more

• Confusingly similar names for potentially related operations: 'TraceVisit' and 'VisitImpl' are semantically close but structurally different (one is a public/internal API call, the other an implementation detail). This can cause confusion for maintainers.
• CoverageExclusion (AltCover.Recorder/Base.cs)
• CoverageExclusion (Samples/Sample11/Class1.cs)
• CoverageExclusion (Samples/Sample11/Class1.cs)
• CoverageExclusion (Samples/Sample11/Class1.cs)
• CoverageExclusion (Samples/Sample11/Class1.cs)
• CoverageExclusion (Samples/Sample5/Class1.cs)
• CoverageExclusion (Samples/Sample5/Class1a.cs)
• CoverageExclusion (Samples/Sample5/Class1a.cs)
• CoverageExclusion (Samples/Sample5/Class1a.cs)
• CoverageExclusion (Samples/Sample5/Class1a.cs)
• CoverageExclusion (Samples/Sample5/Class1a.cs)
• CoverageExclusion (Samples/Sample5/Class1a.cs)
• CoverageExclusion (Samples/Sample5/Class1a.cs)
• CoverageExclusion (Samples/Sample5/Class1a.cs)
• CoverageExclusion (Samples/Sample5/Class1a.cs)
• CoverageExclusion (Samples/Sample5/Class1a.cs)
• CoverageExclusion (Samples/Sample5/Class1a.cs)
• Documentation: no installation or build instructions (README.md)
• Duplicated block (10 lines × 2) (AltCover.PowerShell/OpenCover.fs)
• …and 84 more

• 18 commits — 17 feature/other, 1 fixes

• (root) — 7 commits
• AltCover.Recorder/Recorder.cs — 4 commits
• (repo) — 3 commits
• Build/DriveApi.fsproj — 2 commits
• .config/dotnet-tools.json — 1 commit
• AltCover.Engine.Tests/AltCover.Engine.Tests.fsproj — 1 commit

• fix: Take suggested fix
• change: Extend fallback strategy
• change: Fantomas 8 beta 2 and ramifications, polish release notes
• change: Follow up after code review
• change: Incremental adaptation to 10.0.400 ,which is close fo net 11 pv 6
• change: It writes the latest, anyway
• change: It writes the latest, but needs a valid version
• change: Merge branch 'master' into develop/maintenance
• change: Merge pull request #268 from SteveGilham/develop/maintenance
• change: Merge pull request #269 from SteveGilham/develop/maintenance
• change: On consideration, re-order it thus.
• change: Paranoia check, inspired by issue #266
• change: Pick up new SDK; No further changes at fantomas 8.0.1
• change: Rationalize order and document in release notes
• change: The latest 10.0.400 SDK pulls a lot of net 11 pv6 changes, so pull the corresponding updates from the pv branch
• change: Tool updates
• change: [skip ci] Remove old working note that should not have been committed.
• change: [skip ci] Version update for release notes

• Containers 0 added · 0 removed · contexts 8 added · 0 removed · edges 0 added · 0 removed

• AltCover.Engine
• AltCover.Fake.DotNet.Testing.AltCover
• AltCover.Visualizer
• Build
• Sample18
• Sample2
• Sample26
• Sample4

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

SteveGilham/altcover was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.