test: remove trivial, duplicate and content-value tests (#2721)

## Summary
Many tests proved a specific change when it landed but don't need to run on every CI build forever. This removes **202 test methods and 9 files: 313 test cases, 2,247 → 1,934**. UOContent.Tests drops from about 14s to about 5s locally.

Removed:
- **Tautologies.** Asserting a constant, a constructor readback or a trivial getter, or testing BCL behavior.
- **Exact duplicates** of a surviving test on the same code path.
- **Obsolete regressions** whose failure can no longer be expressed.
- **Game-content values** shard owners customize (era drop rates, loot and skill tables, single-creature tuning). Each customization would otherwise force a test fix.

## How it was decided
1. Every test was classified, with a reason, by a per-shard sweep over all 287 test files.
2. Each proposed deletion was then checked by a second, adversarial reviewer against the surviving tests and the production code.
3. Anything that was the only coverage of a separate code path was **kept**, even where it looked like a duplicate. Examples: the unsigned `SpanReader`/`SpanWriter` methods, the at-location versus bounds enumerators, null-map enumerables, the security filters, archive-journal state transitions. About 130 proposed deletions were rejected this way.

Whole files removed:
- `FishingTests`, apart from 3 tests: the map-edge scan, serpent cleanup, and SOS chest consumption. The SOS test now stops at the first chest instead of measuring a catch rate. The multi-million-cast rate simulations are gone.
- `LordOaksTests` and `MeerEnragedTests` (single-creature tests).
- `AutoArchiveHelperTests`, `JsonDiscoverableTypeAttributeTests`, `DecimalSerializationTests` and `EnumConversionTests` (tautologies, or tests of their own local helpers).
- `NetworkStatsTests`.
- `MigratedDataLoadTests` (a subset of `AllSpawnFilesLoadTests`).
- `SpawnerFixtureCapture`: a capture tool, not a test, and its `version == 12` assert can no longer pass. The `.bin` fixtures it produced stay.

## Tests
- Server.Tests: 811 pass.
- UOContent.Tests: 1,123 pass.

A follow-up PR, stacked on this one, fixes how the remaining tests behave: shared state, CI-vacuous tests, harness duplication.
This commit is contained in:
Kamron Batman 2026-10-18 20:08:19 -07:00 • committed by GitHub
parent 078be52777
commit 9a25054809
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
89 changed files with 11 additions and 4603 deletions

View file

@ -78,174 +78,4 @@ public class StepProbeTests
Assert.False(result.IsWalkable(Direction.South), "S should be off-map");
Assert.False(result.IsWalkable(Direction.Left), "SW should be off-map");
}
[Fact]
public void ComputeMaskAt_TrammelOpenPlain_HasFlatCellWithAllDirectionsWalkable()
{
// Invariant: somewhere in the open-plain region, there must be a fully-flat cell
// whose mask is 0xFF and all 8 destZ values equal sourceZ (no slope).
// This protects against a regression where the baker stops detecting flat cells.
var map = Map.Maps[1];
Assert.NotNull(map);
var found = false;
for (var x = 1500; x < 1532 && !found; x++)
{
for (var y = 1600; y < 1632 && !found; y++)
{
map.GetAverageZ(x, y, out _, out var avgZ, out _);
var sourceZ = (sbyte)avgZ;
var result = StepProbe.ComputeMaskAt(map, x, y, sourceZ);
if (result.WalkMask != 0xFF)
{
continue;
}
var allSameZ = true;
for (var d = 0; d < 8; d++)
{
if (result.GetWalkZ((Direction)d) != sourceZ)
{
allSameZ = false;
break;
}
}
if (allSameZ)
{
found = true;
_output.WriteLine($"Flat-open cell found at ({x}, {y}, {sourceZ})");
}
}
}
Assert.True(found, "Expected at least one fully-flat open cell in (1500..1532, 1600..1632)");
}
[SkippableFact]
public void ComputeMaskAt_BritainInnDense_HasCellWithBlockedDirections()
{
TileDataRequirement.SkipIfMissing();
// Invariant: inside the dense Britain inn region, at least one cell must have
// at least one direction blocked by a static. Protects against a regression
// where the baker reports everything as walkable (the original false-pass bug).
var map = Map.Maps[1];
Assert.NotNull(map);
var blockedCellCount = 0;
for (var x = 1480; x < 1512; x++)
{
for (var y = 1610; y < 1642; y++)
{
map.GetAverageZ(x, y, out _, out var avgZ, out _);
var sourceZ = (sbyte)avgZ;
var result = StepProbe.ComputeMaskAt(map, x, y, sourceZ);
if (result.WalkMask != 0xFF)
{
blockedCellCount++;
}
}
}
_output.WriteLine($"Cells with at least one blocked direction: {blockedCellCount} / 1024");
Assert.True(blockedCellCount > 0, "Expected at least one cell with a blocked direction in the dense region");
}
[Theory]
[InlineData(1500, 1600)]
[InlineData(1480, 1610)]
[InlineData(0, 0)]
public void ComputeMaskAt_IsDeterministic(int x, int y)
{
// Same inputs must always produce identical output. Catches accidental
// statefulness in the baker (e.g., a static cache that gets corrupted).
var map = Map.Maps[1];
Assert.NotNull(map);
map.GetAverageZ(x, y, out _, out var avgZ, out _);
var sourceZ = (sbyte)avgZ;
var first = StepProbe.ComputeMaskAt(map, x, y, sourceZ);
var second = StepProbe.ComputeMaskAt(map, x, y, sourceZ);
var third = StepProbe.ComputeMaskAt(map, x, y, sourceZ);
Assert.Equal(first.WalkMask, second.WalkMask);
Assert.Equal(first.WalkMask, third.WalkMask);
for (var d = 0; d < 8; d++)
{
Assert.Equal(first.GetWalkZ((Direction)d), second.GetWalkZ((Direction)d));
Assert.Equal(first.GetWalkZ((Direction)d), third.GetWalkZ((Direction)d));
}
}
[SkippableFact]
public void ComputeMaskAt_PinnedCell_TrammelOpenPlainOrigin()
{
TileDataRequirement.SkipIfMissing();
// PINNING test: locks specific output for Trammel (1500, 1600).
// Cell at z=10 with mask 0xC1 (N + W + NW only walkable). The other five
// directions are blocked by water (E/SE/S/SW are wet tiles, NE is shore).
// If this changes, either the baker logic changed or the underlying tile
// data changed; re-run the parity test to confirm before updating expected values.
var map = Map.Maps[1];
Assert.NotNull(map);
map.GetAverageZ(1500, 1600, out _, out var avgZ, out _);
var sourceZ = (sbyte)avgZ;
var result = StepProbe.ComputeMaskAt(map, 1500, 1600, sourceZ);
Assert.Equal((sbyte)10, sourceZ);
Assert.Equal((byte)0xC1, result.WalkMask);
Assert.True(result.IsWalkable(Direction.North));
Assert.False(result.IsWalkable(Direction.Right));
Assert.False(result.IsWalkable(Direction.East));
Assert.False(result.IsWalkable(Direction.Down));
Assert.False(result.IsWalkable(Direction.South));
Assert.False(result.IsWalkable(Direction.Left));
Assert.True(result.IsWalkable(Direction.West));
Assert.True(result.IsWalkable(Direction.Up));
Assert.Equal((sbyte)10, result.GetWalkZ(Direction.North));
Assert.Equal((sbyte)10, result.GetWalkZ(Direction.West));
Assert.Equal((sbyte)10, result.GetWalkZ(Direction.Up));
}
[SkippableFact]
public void ComputeMaskAt_PinnedCell_BritainInnDenseOrigin()
{
TileDataRequirement.SkipIfMissing();
// PINNING test: locks specific output for Trammel (1480, 1610).
// Cell at z=20 with mask 0x3F (N/NE/E/SE/S/SW walkable, W/NW blocked by
// a wall to the west). All walkable directions stay flat at z=20.
var map = Map.Maps[1];
Assert.NotNull(map);
map.GetAverageZ(1480, 1610, out _, out var avgZ, out _);
var sourceZ = (sbyte)avgZ;
var result = StepProbe.ComputeMaskAt(map, 1480, 1610, sourceZ);
Assert.Equal((sbyte)20, sourceZ);
Assert.Equal((byte)0x3F, result.WalkMask);
Assert.True(result.IsWalkable(Direction.North));
Assert.True(result.IsWalkable(Direction.Right));
Assert.True(result.IsWalkable(Direction.East));
Assert.True(result.IsWalkable(Direction.Down));
Assert.True(result.IsWalkable(Direction.South));
Assert.True(result.IsWalkable(Direction.Left));
Assert.False(result.IsWalkable(Direction.West));
Assert.False(result.IsWalkable(Direction.Up));
for (var d = 0; d < 6; d++)
{
Assert.Equal((sbyte)20, result.GetWalkZ((Direction)d));
}
}
}