[quality-improver] AssertSourceCompatibilityTests.SpanAndMemoryCalls tests only half of the Span/Memory × comparer overload combinations

Open test/IntegrationTests/MSTest.Acceptance.IntegrationTests/AssertSourceCompatibilityTests.cs and start with SpanAndMemoryCalls. Add the missing comparer and no-comparer combinations for Contains, DoesNotContain, ContainsAll, and DoesNotContainAll described in the issue. Run the acceptance integration tests and confirm every specified Span/Memory overload shape is represented.

🎯 Repository Quality Improvement Report — Assert Span/Memory Overload Coverage Gap

Analysis Date: 2026-09-24
Focus Area: Assert Span/Memory Overload Resolution Test Coverage
Strategy Type: Custom

Executive Summary

AssertSourceCompatibilityTests.cs exists specifically to "compile manually maintained consumer call shapes" and catch overload-resolution regressions across Span<T>, ReadOnlySpan<T>, arrays, and IEnumerable<T> implicit conversions — a documented concern in this repo because adding overloads can silently make previously-unambiguous calls ambiguous for consumers. Its own VerifyEveryPublicAssertMethodFamilyHasAConsumerCall guard explicitly warns: "It cannot detect a new overload in an existing family, so every overload change must also add representative implicit consumer call shapes."

However, the SpanAndMemoryCalls scenario in that file does not follow its own rule for four heavily-overloaded method families: Assert.Contains, Assert.DoesNotContain, Assert.ContainsAll, and Assert.DoesNotContainAll. Each of these has Span<T>, ReadOnlySpan<T>, Memory<T>, and ReadOnlyMemory<T> overloads in both a "no comparer" and an "IEqualityComparer<T>" shape (8 combinations per family for the value/collection forms), but the test only ever exercises 4 of those 8 combinations per family — and always the same 4, systematically skipping the Span<T>+comparer and Memory<T>+comparer shapes, plus predicate overloads over Span<T>/ReadOnlyMemory<T>. A future overload addition or refactor in this specific slice (e.g. a new Span<T> overload with a different comparer constraint) could introduce an ambiguity for consumers today's suite would not detect.

Assert.Contains(1, span);                              // Span, no comparer — tested
Assert.Contains(1, readOnlySpan, comparer);             // ReadOnlySpan, comparer — tested
Assert.Contains((int value) => value > 0, memory);      // Memory, predicate — tested
Assert.Contains(1, readOnlyMemory);                     // ReadOnlyMemory, no comparer — tested
// Never called: Contains(1, span, comparer), Contains(1, memory, comparer),
//               Contains(predicate, span/readOnlySpan/readOnlyMemory)

Assert.ContainsAll(span, span);                         // Span, no comparer — tested
Assert.ContainsAll(readOnlySpan, readOnlySpan, comparer); // ReadOnlySpan, comparer — tested
Assert.ContainsAll(memory, memory);                     // Memory, no comparer — tested
Assert.ContainsAll(readOnlyMemory, readOnlyMemory, comparer); // ReadOnlyMemory, comparer — tested
// Never called: ContainsAll(span, span, comparer), ContainsAll(readOnlySpan, readOnlySpan),
//               ContainsAll(memory, memory, comparer), ContainsAll(readOnlyMemory, readOnlyMemory)

🤖 Suggested Improvement Tasks

Task 1: Add missing Contains/DoesNotContain Span/Memory combinations

Priority: Medium
Estimated Effort: Small

In SpanAndMemoryCalls, add calls for Assert.Contains(1, span, comparer), Assert.Contains(1, memory, comparer), Assert.Contains(predicate, span) (or readOnlySpan), Assert.Contains(predicate, readOnlyMemory), and the equivalent DoesNotContain shapes, mirroring the existing pattern used for AreAllDistinct/ContainsSingle in the same method (all four collection types × both comparer/no-comparer × value/predicate exercised at least once).

Relevant file: test/IntegrationTests/MSTest.Acceptance.IntegrationTests/AssertSourceCompatibilityTests.cs

Task 2: Add missing ContainsAll/DoesNotContainAll Span/Memory combinations

Priority: Medium
Estimated Effort: Small

Add Assert.ContainsAll(span, span, comparer), Assert.ContainsAll(readOnlySpan, readOnlySpan) (no comparer), Assert.ContainsAll(memory, memory, comparer), Assert.ContainsAll(readOnlyMemory, readOnlyMemory) (no comparer), and the equivalent DoesNotContainAll calls, so all four collection types are exercised with and without a comparer.

Relevant file: test/IntegrationTests/MSTest.Acceptance.IntegrationTests/AssertSourceCompatibilityTests.cs

Task 3: Add a lightweight combinatorial coverage assertion

Priority: Low
Estimated Effort: Medium

Consider a small reflection-based helper (scoped to just Contains/DoesNotContain/ContainsAll/DoesNotContainAll, since these are the families with the most overload combinations) that asserts every distinct (collectionType, hasComparer, isPredicate) shape found in the public API surface has at least one matching call in ConsumerSource. This would make the gap self-detecting instead of relying on manual review, without expanding VerifyEveryPublicAssertMethodFamilyHasAConsumerCall's scope beyond family names.

Relevant file: test/IntegrationTests/MSTest.Acceptance.IntegrationTests/AssertSourceCompatibilityTests.cs

📊 Historical Context

🎯 Recommendations

Immediate Actions (This Week)

1. Add the missing Contains/DoesNotContain combinations to SpanAndMemoryCalls — Priority: Medium

Short-term Actions (This Month)

1. Add the missing ContainsAll/DoesNotContainAll combinations — Priority: Medium
2. Evaluate a reflection-based combinatorial coverage check for these four families — Priority: Low

Next analysis: 2026-09-25 — Focus area selected based on diversity algorithm

🤖 Automated content by GitHub Copilot. Generated by the Repository Quality Improver workflow. · copilot · auto · 211.8 AIC · ⌖ 8 AIC · ⊞ 17.2K · [◷]( · ◷)

gh aw add githubnext/agentics/workflows/repository-quality-improver.md@main

• expires on Sep 26, 2026, 10:36 PM UTC