test: redistribute edge-case tests, reach 100% line coverage, drop report Floor column

- Delete the catch-all EdgeCaseCoverageTests and move every test next to the
  type it exercises, matching the repo's mirror-the-source layout: indexer
  misses and Clear()-on-empty into each *Tests.cs; the non-generic
  IEnumerable/IEnumerator + Reset paths into each *EnumerationTests.cs; the
  wrap-around backward-shift case into CelerityMultiMapCollisionTests.

- Remove the dead table-sizing guard in FrozenCelerityDictionary
  (`if (size <= n) size <<= 1;`). NextPowerOfTwo(n + 1) already returns a power
  of two strictly greater than n for every constructible size (it caps at 2^30),
  so the guard was unreachable — and `size <<= 1` would overflow to a negative
  size if it ever ran. Dropping it takes the library to 100% line coverage.

- Drop the "Floor" column from the coverage report's PR summary table.

Full suite: 1881 tests pass; library coverage 100% line / ~99% branch.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: marius-bughiu

ROADMAP.md

@@ -61,7 +61,7 @@ The next release rounds out the `Celerity.Collections` package with missing coll
 - Comprehensive benchmark suite: uniform, clustered, and adversarial key distributions. Status: `done` — `DistributionBenchmark` sweeps uniform/sequential/clustered shapes and `AdversarialHasherBenchmark` shows the naive hasher degrading to O(n) while Murmur3 recovers. Tracked in [#60](https://github.com/marius-bughiu/Celerity/issues/60).
 - Benchmark suite expansion: realistic workloads, memory-allocation, concurrent-access, cache-locality, large-dataset (millions), and `FrozenDictionary<,>` comparison benchmarks. Status: `done` — added as an extended, on-demand suite kept out of the per-PR CI regression run; see [`docs/performance.md`](docs/performance.md#extended-benchmark-suite). Tracked in [#26](https://github.com/marius-bughiu/Celerity/issues/26).
 - Cross-platform testing (Windows, Linux, macOS). Status: `done`.
-- Improve code coverage. Status: `done` — coverage reporting is gated in CI (`coverage.yml`, ~99.9% line coverage on the library, published to the [coverage dashboard](https://marius-bughiu.github.io/Celerity/coverage/)), edge-case tests close the non-generic enumerator / throw / backward-shift corners, property-based parity tests (CsCheck) and a seedable differential fuzzer (`Celerity.Fuzz`, nightly soak) check every collection against its BCL oracle, and the approach is written up in [`docs/testing.md`](docs/testing.md). Tracked in [#29](https://github.com/marius-bughiu/Celerity/issues/29).
+- Improve code coverage. Status: `done` — coverage reporting is gated in CI (`coverage.yml`, 100% line coverage on the library, rendered by an in-repo generator and published to the [coverage dashboard](https://marius-bughiu.github.io/Celerity/coverage/)), edge-case tests close the non-generic enumerator / throw / backward-shift corners, property-based parity tests (CsCheck) and a seedable differential fuzzer (`Celerity.Fuzz`, nightly soak) check every collection against its BCL oracle, and the approach is written up in [`docs/testing.md`](docs/testing.md). Tracked in [#29](https://github.com/marius-bughiu/Celerity/issues/29).
 - Improve documentation. Status: `done` — added a performance tuning guide, a BCL migration guide, a troubleshooting guide, and a FAQ, alongside the existing README usage examples, "choosing a collection" table, and API reference. Tracked in [#15](https://github.com/marius-bughiu/Celerity/issues/15).
 - Bump XML doc coverage; treat missing docs as warning-as-error. Status: `done` — `Celerity.csproj` promotes CS1591 to error.
 

docs/testing.md

@@ -7,7 +7,7 @@ Celerity's first guiding principle is *correctness first* — "a fast collection
 | Layer | Project / file | What it proves | Run locally |
 |---|---|---|---|
 | Behavioural unit tests | `Celerity.Tests` | Each public method does the right thing on hand-picked inputs, including collisions, resizes, and the out-of-band default/zero/null key. | `dotnet test` |
-| Edge-case coverage tests | `Celerity.Tests/Collections/EdgeCaseCoverageTests.cs` | The corners example tests skip: non-generic `IEnumerable`/`IEnumerator` paths, `Reset()`, indexer misses, `Clear()` on empty, wrap-around backward-shift. | `dotnet test` |
+| Edge-case coverage | alongside each type's tests (`*Tests.cs`, `*EnumerationTests.cs`, `*CollisionTests.cs`) | The corners example tests skip: non-generic `IEnumerable`/`IEnumerator` paths, `Reset()`, indexer misses, `Clear()` on empty, wrap-around backward-shift. | `dotnet test` |
 | Property-based tests | `Celerity.Tests/Properties/` | Across thousands of randomized operation sequences, every collection stays observably equal to its BCL oracle. | `dotnet test` |
 | Differential fuzzer | `Celerity.Fuzz` | A long random walk finds no divergence from the BCL; failures replay deterministically from a seed. | `dotnet run -c Release` |
 | Native AOT smoke test | `Celerity.AotSmokeTest` | Every collection/hasher works in a trimmed, AOT-compiled native binary. | see [aot.md](aot.md) |
@@ -30,9 +30,9 @@ Both compare against a BCL oracle (`Dictionary<,>`, `HashSet<>`, or a `Dictionar
 The bulk of the suite lives in `Celerity.Tests`, mirroring the library's folder layout. Test names follow `Method_ShouldExpectedBehavior_WhenCondition`. Notable categories:
 
 - **Collision tests** (`*CollisionTests.cs`) — force every key down one probe chain with a constant hasher, then verify lookups, removals, and backward-shift deletion keep every entry findable.
-- **Enumeration tests** (`*EnumerationTests.cs`) — the struct enumerators, `Keys`/`Values` views, and mid-enumeration mutation detection.
+- **Enumeration tests** (`*EnumerationTests.cs`) — the struct enumerators, `Keys`/`Values` views, mid-enumeration mutation detection, and the non-generic interface surface (`IEnumerable.GetEnumerator()`, `object IEnumerator.Current`, `IEnumerator.Reset()`).
 - **Load-factor / constructor validation** — boundary resizes and argument checking.
-- **Edge-case coverage** (`EdgeCaseCoverageTests.cs`) — the non-generic interface surface (`IEnumerable.GetEnumerator()`, `object IEnumerator.Current`, `IEnumerator.Reset()`), indexer misses on the out-of-band key, `Clear()` on an empty collection, and a hand-built wrap-around cluster that exercises the `bypassesGap` branch of backward-shift deletion.
+- **Edge cases** live next to the type they exercise rather than in a catch-all file: indexer misses on the out-of-band key and `Clear()` on an empty collection sit in `*Tests.cs`; the wrap-around cluster that exercises the `bypassesGap` branch of backward-shift deletion sits in `*CollisionTests.cs`.
 
 Run them with:
 
@@ -134,14 +134,10 @@ The report is rendered by [`scripts/coverage_report.py`](../scripts/coverage_rep
 The `coverage` workflow (`.github/workflows/coverage.yml`) runs on every PR and on `main`:
 
 - Collects coverage, renders the report + badge with `scripts/coverage_report.py`, and uploads it as a build artifact.
-- **Fails the build** if line coverage drops below `MIN_LINE_COVERAGE` (95%) or branch coverage below `MIN_BRANCH_COVERAGE` (90%). The suite sits far above these (~99.9% line) — the floor guards against silent regressions; it is not the target.
+- **Fails the build** if line coverage drops below `MIN_LINE_COVERAGE` (95%) or branch coverage below `MIN_BRANCH_COVERAGE` (90%). The suite sits far above these (100% line, ~99% branch) — the floor guards against silent regressions; it is not the target.
 - Posts a coverage summary comment on the PR.
 - On `main`, publishes the HTML report to `gh-pages` under [`/coverage`](https://marius-bughiu.github.io/Celerity/coverage/) and refreshes the README badge.
 
-### What is deliberately not covered
-
-A single line — the integer-overflow guard in `FrozenCelerityDictionary`'s table sizing (`if (size <= n) size <<= 1;`) — is unreachable without ~2³⁰ keys, so it is left uncovered by design rather than tested with an impractically large input. It is defensive code, kept for safety.
-
 ## Continuous integration summary
 
 | Workflow | Trigger | What it does |

scripts/coverage_report.py

@@ -349,10 +349,10 @@ def render_summary(overall, files, min_line, min_branch, passed) -> str:
     lines = [
         "### Coverage",
         "",
-        "| Metric | Value | Floor |",
-        "|---|---:|---:|",
-        f'| Line | {pct(overall["line_rate"])} ({overall["lines_covered"]}/{overall["lines_valid"]}) | {min_line:.0f}% |',
-        f'| Branch | {pct(overall["branch_rate"])} ({overall["branches_covered"]}/{overall["branches_valid"]}) | {min_branch:.0f}% |',
+        "| Metric | Value |",
+        "|---|---:|",
+        f'| Line | {pct(overall["line_rate"])} ({overall["lines_covered"]}/{overall["lines_valid"]}) |',
+        f'| Branch | {pct(overall["branch_rate"])} ({overall["branches_covered"]}/{overall["branches_valid"]}) |',
         "",
     ]
     if not passed:

src/Celerity.Tests/Collections/CelerityDictionaryEnumerationTests.cs

@@ -1,3 +1,4 @@
+using System.Collections;
 using System.Collections.Generic;
 using Celerity.Collections;
 using Celerity.Hashing;
@@ -391,4 +392,47 @@ public void Enumerator_ShouldBeReusableViaReset()
         Assert.Equal(2, firstPass);
         Assert.Equal(firstPass, secondPass);
     }
+
+    [Fact]
+    public void KeyCollection_ShouldRoundTrip_ThroughNonGenericIEnumerable()
+    {
+        // The non-generic System.Collections.IEnumerable path (object Current,
+        // Reset) is distinct from the generic IEnumerable<TKey> path above.
+        var map = new CelerityDictionary<int, int, Int32WangNaiveHasher>();
+        for (int i = 1; i <= 4; i++) map[i] = i * 10;
+
+        var (first, second) = DrainNonGenericTwice<int>(map.Keys);
+
+        first.Sort();
+        second.Sort();
+        Assert.Equal(new[] { 1, 2, 3, 4 }, first);
+        Assert.Equal(first, second);
+    }
+
+    [Fact]
+    public void ValueCollection_ShouldRoundTrip_ThroughNonGenericIEnumerable()
+    {
+        var map = new CelerityDictionary<int, int, Int32WangNaiveHasher>();
+        for (int i = 1; i <= 4; i++) map[i] = i * 10;
+
+        var (first, second) = DrainNonGenericTwice<int>(map.Values);
+
+        first.Sort();
+        second.Sort();
+        Assert.Equal(new[] { 10, 20, 30, 40 }, first);
+        Assert.Equal(first, second);
+    }
+
+    // Drives a struct view through its boxed non-generic IEnumerable/IEnumerator
+    // surface (GetEnumerator -> object Current), then Reset()s and drains again.
+    private static (List<T> first, List<T> second) DrainNonGenericTwice<T>(IEnumerable view)
+    {
+        IEnumerator e = view.GetEnumerator();
+        var first = new List<T>();
+        while (e.MoveNext()) first.Add((T)e.Current!);
+        e.Reset();
+        var second = new List<T>();
+        while (e.MoveNext()) second.Add((T)e.Current!);
+        return (first, second);
+    }
 }

src/Celerity.Tests/Collections/CelerityDictionaryTests.cs

@@ -199,6 +199,26 @@ public void Indexer_ShouldHandleGuidEmptyKey()
         Assert.Equal(2, map.Count);
     }
 
+    [Fact]
+    public void Indexer_ShouldThrowKeyNotFound_ForAbsentDefaultKey()
+    {
+        // default(int) == 0 takes the out-of-band default-key path; with no
+        // default key stored the getter must throw, not return default(TValue).
+        var map = new CelerityDictionary<int, int, Int32WangNaiveHasher>();
+
+        Assert.Throws<KeyNotFoundException>(() => _ = map[0]);
+    }
+
+    [Fact]
+    public void Clear_ShouldBeNoOp_WhenAlreadyEmpty()
+    {
+        var map = new CelerityDictionary<int, int, Int32WangNaiveHasher>();
+
+        map.Clear(); // _count == 0 early-return path
+
+        Assert.Empty(map);
+    }
+
     // A test-only hasher used to exercise the Guid path. Not part of the
     // public library — lives next to the tests that need it. Uses the low
     // 32 bits of the GUID's hash code.

src/Celerity.Tests/Collections/CelerityMultiMapCollisionTests.cs

@@ -152,4 +152,24 @@ public void NullKeyGroup_ShouldCoexistWithCollidingStringKeys()
         for (int i = 1; i <= 5; i++)
             Assert.Equal(new[] { i }, map[$"k{i}"].ToArray());
     }
+
+    [Fact]
+    public void RemoveAll_OnWrapAroundCluster_ShouldKeepHomedKey()
+    {
+        // With an identity hasher and capacity 8, keys 1, 2, 9 form one probe
+        // cluster: 1->slot1, 2->slot2, 9(home 1)->slot3. Removing key 1 forces the
+        // backward shift to *skip* key 2 (already at its home slot — the bypassesGap
+        // branch) while relocating key 9 into the freed slot.
+        var map = new CelerityMultiMap<int, int, IdentityIntHasher>(8);
+        map.Add(1, 10);
+        map.Add(2, 20);
+        map.Add(9, 90);
+
+        Assert.True(map.RemoveAll(1));
+
+        Assert.False(map.ContainsKey(1));
+        Assert.Equal(new[] { 20 }, map[2].ToArray());
+        Assert.Equal(new[] { 90 }, map[9].ToArray());
+        Assert.Equal(2, map.Count);
+    }
 }

src/Celerity.Tests/Collections/CelerityMultiMapEnumerationTests.cs

@@ -208,4 +208,110 @@ public void ValueGroup_BoxedEnumeration_ShouldYieldValues()
 
         Assert.Equal(new[] { 1, 2 }, values.ToArray());
     }
+
+    [Fact]
+    public void Enumerator_ShouldRoundTrip_AfterReset()
+    {
+        var map = new CelerityMultiMap<int, int, Int32WangNaiveHasher>();
+        map.Add(0, 100); // default key exercises the BeforeDefaultKey state
+        map.Add(1, 10);
+        map.Add(2, 20);
+
+        IEnumerator e = ((IEnumerable)map).GetEnumerator();
+        var firstKeys = new List<int>();
+        while (e.MoveNext()) firstKeys.Add(((IGrouping<int, int>)e.Current!).Key);
+        e.Reset();
+        var secondKeys = new List<int>();
+        while (e.MoveNext()) secondKeys.Add(((IGrouping<int, int>)e.Current!).Key);
+
+        firstKeys.Sort();
+        secondKeys.Sort();
+        Assert.Equal(new[] { 0, 1, 2 }, firstKeys);
+        Assert.Equal(firstKeys, secondKeys);
+    }
+
+    [Fact]
+    public void EnumeratorReset_ShouldThrow_WhenMapMutated()
+    {
+        var map = new CelerityMultiMap<int, int, Int32WangNaiveHasher>();
+        map.Add(1, 10);
+
+        var e = map.GetEnumerator();
+        e.MoveNext();
+        map.Add(2, 20); // bumps the version
+
+        Assert.Throws<InvalidOperationException>(() => e.Reset());
+    }
+
+    [Fact]
+    public void ValueGroup_ShouldEnumerate_ViaPublicStructEnumerator()
+    {
+        var map = new CelerityMultiMap<int, int, Int32WangNaiveHasher>();
+        map.Add(1, 10);
+        map.Add(1, 11);
+
+        // foreach over the ValueGroup struct binds to its public GetEnumerator(),
+        // distinct from the boxed IEnumerable<TValue> path tested above.
+        int sum = 0;
+        foreach (int? v in map[1])
+            sum += v ?? 0;
+
+        Assert.Equal(21, sum);
+    }
+
+    [Fact]
+    public void ValueGroup_ShouldRoundTrip_ThroughNonGenericIEnumerable()
+    {
+        var map = new CelerityMultiMap<int, int, Int32WangNaiveHasher>();
+        map.Add(1, 10);
+        map.Add(1, 11);
+
+        var (first, second) = DrainNonGenericTwice<int>(map[1]);
+
+        Assert.Equal(new[] { 10, 11 }, first);
+        Assert.Equal(first, second);
+    }
+
+    [Fact]
+    public void Grouping_ShouldRoundTrip_ThroughNonGenericIEnumerable()
+    {
+        var map = new CelerityMultiMap<int, int, Int32WangNaiveHasher>();
+        map.Add(5, 50);
+        map.Add(5, 51);
+
+        foreach (var grouping in map)
+        {
+            var (first, second) = DrainNonGenericTwice<int>((IEnumerable)grouping);
+            Assert.Equal(new[] { 50, 51 }, first);
+            Assert.Equal(first, second);
+        }
+    }
+
+    [Fact]
+    public void Keys_ShouldRoundTrip_ThroughNonGenericIEnumerable()
+    {
+        var map = new CelerityMultiMap<int, int, Int32WangNaiveHasher>();
+        map.Add(1, 10);
+        map.Add(2, 20);
+
+        var (first, second) = DrainNonGenericTwice<int>(map.Keys);
+
+        first.Sort();
+        second.Sort();
+        Assert.Equal(new[] { 1, 2 }, first);
+        Assert.Equal(first, second);
+    }
+
+    // Drives a struct view through its boxed non-generic IEnumerable/IEnumerator
+    // surface (GetEnumerator -> object Current), then Reset()s and drains again.
+    private static (List<T> first, List<T> second) DrainNonGenericTwice<T>(IEnumerable view)
+    {
+        IEnumerator e = view.GetEnumerator();
+        var first = new List<T>();
+        while (e.MoveNext()) first.Add((T)e.Current!);
+        e.Reset();
+        var second = new List<T>();
+        while (e.MoveNext()) second.Add((T)e.Current!);
+        return (first, second);
+    }
 }

src/Celerity.Tests/Collections/CelerityMultiMapTests.cs

@@ -380,4 +380,48 @@ public void GrowthUnderManyKeys_ShouldPreserveAllGroups()
         for (int i = 0; i < 500; i++)
             Assert.Equal(new[] { i, i + 1000 }, map[i].ToArray());
     }
+
+    [Fact]
+    public void Remove_ShouldReturnFalse_ForAbsentDefaultKey()
+    {
+        var map = new CelerityMultiMap<int, int, Int32WangNaiveHasher>();
+
+        // default key (0) group was never created.
+        Assert.False(map.Remove(0, 123));
+        Assert.False(map.RemoveAll(0));
+    }
+
+    [Fact]
+    public void Remove_ShouldReturnFalse_ForAbsentValue_UnderDefaultKey()
+    {
+        var map = new CelerityMultiMap<int, int, Int32WangNaiveHasher>();
+        map.Add(0, 1);
+        map.Add(0, 2);
+
+        Assert.False(map.Remove(0, 999)); // value not in the default-key group
+        Assert.True(map.Remove(0, 1));
+        Assert.True(map.Remove(0, 2));    // empties the group -> drops the key
+        Assert.False(map.ContainsKey(0));
+    }
+
+    [Fact]
+    public void Remove_ShouldReturnFalse_ForAbsentValue_UnderPresentKey()
+    {
+        var map = new CelerityMultiMap<int, int, Int32WangNaiveHasher>();
+        map.Add(7, 1);
+
+        Assert.False(map.Remove(7, 999)); // key present, value absent
+        Assert.True(map.ContainsKey(7));
+    }
+
+    [Fact]
+    public void Clear_ShouldBeNoOp_WhenAlreadyEmpty()
+    {
+        var map = new CelerityMultiMap<int, int, Int32WangNaiveHasher>();
+
+        map.Clear(); // _count == 0 early-return path
+
+        Assert.Empty(map.Keys);
+        Assert.Equal(0, map.ValueCount);
+    }
 }