warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source 
## 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
Download patch file Download diff file Expand all files Collapse all files

33
Projects/Server.Tests/Tests/Maps/CanFitItemTests.cs
View file

@ -220,39 +220,6 @@ public class CanFitItemTests
}
}
[SkippableFact]
public void CanFitItem_CanPlaceOnTopOfImpassable()
{
SkipIfNoTileData();
Skip.If(ServerFixture.SurfaceImpassableTileId == 0, "No Surface+Impassable tile found in TileData");
var map = Map.Felucca;
const int x = 1950;
const int y = 1950;
TestMulti multi = null;
try
{
// Get the actual tile height from TileData
var tileData = TileData.ItemTable[ServerFixture.SurfaceImpassableTileId];
var tileHeight = tileData.CalcHeight;
const int tileZ = 10;
// Create a Surface+Impassable tile at Z=10
multi = CreateSurfaceImpassableMulti(map, new Point3D(x, y, 0), surfaceZ: tileZ);
// Place item on top should work
var surfaceTop = tileZ + tileHeight;
var result = map.CanFitItem(x, y, surfaceTop, 1);
Assert.True(result, $"Should be able to place item on top of Surface+Impassable tile at Z={surfaceTop}");
}
finally
{
multi?.Delete();
}
}
private TestMulti CreateSurfaceImpassableMulti(Map map, Point3D location, int surfaceZ)
{
// Use SurfaceImpassableTileId - a tile that has both Surface and Impassable flags

71
Projects/Server.Tests/Tests/Maps/CanSpawnMobileTileDataTests.cs
View file

@ -23,32 +23,6 @@ public class CanSpawnMobileTileDataTests
Skip.If(!ServerFixture.TileDataLoaded, "TileData not loaded - client files required");
}
[SkippableFact]
public void CanSpawnMobile_FindsSurfaceOnMulti()
{
SkipIfNoTileData();
var map = Map.Felucca;
const int x = 1100;
const int y = 1100;
TestMulti multi = null;
try
{
// Create a multi with a floor at Z=20 using a real surface tile
multi = CreateFloorMulti(map, new Point3D(x, y, 0), floorZ: 20);
var result = map.CanSpawnMobile(x, y, 15, 30, false, false, out var spawnZ);
Assert.True(result);
Assert.True(spawnZ >= 15 && spawnZ <= 30);
}
finally
{
multi?.Delete();
}
}
[SkippableFact]
public void CanSpawnMobile_FindsLowestValidSurface()
{
@ -239,51 +213,6 @@ public class CanSpawnMobileTileDataTests
}
}
[SkippableFact]
public void CanSpawnMobile_MalasBuilding_FindsGroundFloor()
{
SkipIfNoTileData();
var map = Map.Malas;
const int x = 991;
const int y = 519;
var result = map.CanSpawnMobile(x, y, -60, -40, false, false, out var spawnZ);
Assert.True(result);
Assert.True(spawnZ >= -60 && spawnZ <= -40, $"Expected ground floor around -50, got {spawnZ}");
}
[SkippableFact]
public void CanSpawnMobile_MalasBuilding_FindsSecondFloor()
{
SkipIfNoTileData();
var map = Map.Malas;
const int x = 991;
const int y = 519;
var result = map.CanSpawnMobile(x, y, -30, 0, false, false, out var spawnZ);
Assert.True(result);
Assert.True(spawnZ >= -30 && spawnZ <= 0, $"Expected second floor, got {spawnZ}");
}
[SkippableFact]
public void CanSpawnMobile_MalasBuilding_LowestFloorPreferred()
{
SkipIfNoTileData();
var map = Map.Malas;
const int x = 991;
const int y = 519;
var result = map.CanSpawnMobile(x, y, -60, 0, false, false, out var spawnZ);
Assert.True(result);
Assert.True(spawnZ <= -40, $"Expected lowest floor around -50, got {spawnZ}");
}
private TestMulti CreateFloorMulti(Map map, Point3D location, int floorZ)
{
var multi = new TestMulti(CreateFloorComponents(floorZ));

76
Projects/Server.Tests/Tests/Maps/ClientEnumeratorTests.cs
View file

@ -308,49 +308,6 @@ public class ClientEnumeratorTests
}
}
[Fact]
public void ClientAtEnumerator_UsesDifferentPoint3DOverloads()
{
var map = Map.Felucca;
var location = new Point3D(800, 800, 5);
var clients = new (NetState, Mobile)[1];
try
{
clients[0] = CreateClientWithMobile(map, location);
// Test Point3D overload
var found1 = new List<NetState>();
foreach (var ns in map.GetClientsAt(location))
{
found1.Add(ns);
}
// Test (int, int) overload - should find the same client (Z is ignored)
var found2 = new List<NetState>();
foreach (var ns in map.GetClientsAt(location.X, location.Y))
{
found2.Add(ns);
}
// Test Point2D overload
var found3 = new List<NetState>();
foreach (var ns in map.GetClientsAt(new Point2D(location.X, location.Y)))
{
found3.Add(ns);
}
Assert.Single(found1);
Assert.Equal(clients[0].Item1, found1[0]);
Assert.Equal(found1, found2);
Assert.Equal(found1, found3);
}
finally
{
DeleteAll(clients);
}
}
[Fact]
public void ClientEnumerator_GetClientsInRange()
{
@ -383,39 +340,6 @@ public class ClientEnumeratorTests
}
}
[Fact]
public void ClientEnumerator_DeletedMobilesAreSkipped()
{
var map = Map.Felucca;
var rect = new Rectangle2D(1000, 1000, 16, 16);
var clients = new (NetState, Mobile)[3];
try
{
clients[0] = CreateClientWithMobile(map, new Point3D(1005, 1005, 0));
clients[1] = CreateClientWithMobile(map, new Point3D(1006, 1005, 0));
clients[2] = CreateClientWithMobile(map, new Point3D(1007, 1005, 0));
// Delete the mobile (but not the NetState)
clients[1].Item2.Delete();
var found = new List<NetState>();
foreach (var ns in map.GetClientsInBounds(rect))
{
found.Add(ns);
}
// Should skip the client whose mobile was deleted
Assert.Equal(2, found.Count);
Assert.Contains(clients[0].Item1, found);
Assert.Contains(clients[2].Item1, found);
}
finally
{
DeleteAll(clients);
}
}
private static (NetState, Mobile) CreateClientWithMobile(Map map, Point3D location)
{
// Create test NetState with real socket and buffers

217
Projects/Server.Tests/Tests/Maps/ItemByDistanceEnumeratorTests.cs
View file

@ -38,100 +38,6 @@ public class ItemByDistanceEnumeratorTests
}
}
[Fact]
public void ItemByDistanceEnumerator_DeletedItemsAreSkipped()
{
var map = Map.Felucca;
var center = new Point3D(200, 200, 0);
const int range = 5;
var Items = new TestItem[3];
try
{
Items[0] = CreateItem(map, new Point3D(202, 202, 0));
Items[1] = CreateItem(map, new Point3D(203, 202, 0));
Items[2] = CreateItem(map, new Point3D(204, 202, 0));
Items[1].Delete();
var found = new List<Item>();
foreach (var (Item, _) in map.GetItemsInRangeByDistance(center, range))
{
found.Add(Item);
}
Assert.Equal(2, found.Count);
Assert.Contains(Items[0], found);
Assert.Contains(Items[2], found);
Assert.DoesNotContain(Items[1], found);
}
finally
{
DeleteAll(Items);
}
}
[Fact]
public void ItemByDistanceEnumerator_ReturnsMinDistance()
{
var map = Map.Felucca;
var center = new Point3D(300, 300, 0);
const int range = 10;
var Items = new TestItem[2];
try
{
Items[0] = CreateItem(map, new Point3D(305, 305, 0));
Items[1] = CreateItem(map, new Point3D(302, 302, 0));
var foundWithDistance = new List<(Item, int)>();
foreach (var result in map.GetItemsInRangeByDistance(center, range))
{
foundWithDistance.Add(result);
}
Assert.Equal(2, foundWithDistance.Count);
// Each Item should have a non-negative min distance
Assert.All(foundWithDistance, item => Assert.True(item.Item2 >= 0));
}
finally
{
DeleteAll(Items);
}
}
[Fact]
public void ItemByDistanceEnumerator_OrderedBySector()
{
var map = Map.Felucca;
var center = new Point3D(400, 400, 0);
const int range = Map.SectorSize * 2;
var Items = new TestItem[3];
try
{
// Place Items in different sectors
Items[0] = CreateItem(map, new Point3D(center.X + 2, center.Y + 2, 0));
Items[1] = CreateItem(map, new Point3D(center.X + Map.SectorSize + 2, center.Y + 2, 0));
Items[2] = CreateItem(map, new Point3D(center.X + 2, center.Y + Map.SectorSize + 2, 0));
var found = new List<Item>();
foreach (var (Item, _) in map.GetItemsInRangeByDistance(center, range))
{
found.Add(Item);
}
Assert.Equal(3, found.Count);
Assert.Contains(Items[0], found);
Assert.Contains(Items[1], found);
Assert.Contains(Items[2], found);
}
finally
{
DeleteAll(Items);
}
}
[Fact]
public void ItemByDistanceEnumerator_MapNullYieldsEmpty()
{
@ -239,50 +145,6 @@ public class ItemByDistanceEnumeratorTests
}
}
[Fact]
public void ItemByDistanceEnumerator_UsesDifferentPointOverloads()
{
var map = Map.Felucca;
var center = new Point3D(800, 800, 5);
const int range = 5;
var Items = new TestItem[1];
try
{
Items[0] = CreateItem(map, new Point3D(802, 802, 0));
// Test Point3D overload
var found1 = new List<Item>();
foreach (var (Item, _) in map.GetItemsInRangeByDistance(center, range))
{
found1.Add(Item);
}
// Test (int, int) overload
var found2 = new List<Item>();
foreach (var (Item, _) in map.GetItemsInRangeByDistance<Item>(center.X, center.Y, range))
{
found2.Add(Item);
}
// Test Point2D overload
var found3 = new List<Item>();
foreach (var (Item, _) in map.GetItemsInRangeByDistance(new Point2D(center.X, center.Y), range))
{
found3.Add(Item);
}
Assert.Single(found1);
Assert.Equal(Items[0], found1[0]);
Assert.Equal(found1, found2);
Assert.Equal(found1, found3);
}
finally
{
DeleteAll(Items);
}
}
[Fact]
public void ItemByDistanceEnumerator_RingTraversal()
{
@ -384,58 +246,6 @@ public class ItemByDistanceEnumeratorTests
}
}
[Fact]
public void ItemByDistanceEnumerator_MultipleRings()
{
var map = Map.Felucca;
var center = new Point3D(1100, 1100, 0);
const int range = Map.SectorSize * 3;
var Items = new List<TestItem>();
try
{
// Create a grid of Items across multiple sectors
for (var ringOffset = 0; ringOffset <= 2; ringOffset++)
{
for (var side = 0; side < 4; side++)
{
var offset = ringOffset * Map.SectorSize;
var pos = side switch
{
0 => new Point3D(center.X + offset, center.Y, 0),
1 => new Point3D(center.X, center.Y + offset, 0),
2 => new Point3D(center.X - offset, center.Y, 0),
_ => new Point3D(center.X, center.Y - offset, 0)
};
Items.Add(CreateItem(map, pos));
}
}
var found = new List<Item>();
foreach (var (Item, _) in map.GetItemsInRangeByDistance(center, range))
{
found.Add(Item);
}
// Should find all Items within range
Assert.True(found.Count > 0);
Assert.All(found, Item =>
{
var dx = Item.X - center.X;
var dy = Item.Y - center.Y;
var distSq = dx * dx + dy * dy;
Assert.True(distSq <= range * range);
});
}
finally
{
foreach (var Item in Items)
{
Item?.Delete();
}
}
}
[Fact]
public void ItemByDistanceEnumerator_MatchesBoundsEnumeratorAtMapEdge()
{
@ -556,33 +366,6 @@ public class ItemByDistanceEnumeratorTests
}
}
[Fact]
public void ItemByDistanceEnumerator_Bounds_ReturnsMinDistance()
{
var map = Map.Felucca;
var bounds = new Rectangle2D(300, 300, 20, 20);
var Items = new TestItem[2];
try
{
Items[0] = CreateItem(map, new Point3D(305, 305, 0));
Items[1] = CreateItem(map, new Point3D(315, 315, 0));
var foundWithDistance = new List<(Item, int)>();
foreach (var result in map.GetItemsInBoundsByDistance<Item>(bounds))
{
foundWithDistance.Add(result);
}
Assert.Equal(2, foundWithDistance.Count);
Assert.All(foundWithDistance, item => Assert.True(item.Item2 >= 0));
}
finally
{
DeleteAll(Items);
}
}
[Fact]
public void ItemByDistanceEnumerator_Bounds_OrdersByProximityToCenter()
{

72
Projects/Server.Tests/Tests/Maps/ItemEnumeratorTests.cs
View file

@ -256,35 +256,6 @@ public class ItemEnumeratorTests
}
}
[Fact]
public void ItemAtEnumerator_DeletedItemsAreSkipped()
{
var map = Map.Felucca;
var location = new Point3D(650, 650, 0);
var items = new Item[3];
try
{
items[0] = CreateItem(map, location);
items[1] = CreateItem(map, location);
items[2] = CreateItem(map, location);
items[1].Delete();
var found = new List<Item>();
foreach (var item in map.GetItemsAt<Item>(location))
{
found.Add(item);
}
Assert.Equal(new[] { items[0], items[2] }, found);
}
finally
{
DeleteAll(items);
}
}
[Fact]
public void ItemAtEnumerator_ItemsWithParentAreSkipped()
{
@ -365,49 +336,6 @@ public class ItemEnumeratorTests
}
}
[Fact]
public void ItemAtEnumerator_UsesDifferentPoint3DOverloads()
{
var map = Map.Felucca;
var location = new Point3D(800, 800, 5);
var items = new Item[1];
try
{
items[0] = CreateItem(map, location);
// Test Point3D overload
var found1 = new List<Item>();
foreach (var item in map.GetItemsAt(location))
{
found1.Add(item);
}
// Test (int, int) overload - should find the same item (Z is ignored)
var found2 = new List<Item>();
foreach (var item in map.GetItemsAt(location.X, location.Y))
{
found2.Add(item);
}
// Test Point2D overload
var found3 = new List<Item>();
foreach (var item in map.GetItemsAt(new Point2D(location.X, location.Y)))
{
found3.Add(item);
}
Assert.Single(found1);
Assert.Equal(items[0], found1[0]);
Assert.Equal(found1, found2);
Assert.Equal(found1, found3);
}
finally
{
DeleteAll(items);
}
}
[Fact]
public void ItemEnumerator_ZeroRangeReturnsOnlyCenter()
{

9
Projects/Server.Tests/Tests/Maps/MapSelectionTests.cs
View file

@ -16,15 +16,6 @@ namespace Server.Tests.Maps
Assert.Equal(expected, flags.ToCommaDelimitedString());
}
[Fact]
public void TestFormatFeluccaOnlyMapSelection()
{
const MapSelectionFlags flags = MapSelectionFlags.Felucca;
// When, Then
Assert.Equal("Felucca", flags.ToCommaDelimitedString());
}
public class TestMapConfig
{
[JsonConverter(typeof(FlagsConverter<MapSelectionFlags>))]

193
Projects/Server.Tests/Tests/Maps/MobileByDistanceEnumeratorTests.cs
View file

@ -71,76 +71,6 @@ public class MobileByDistanceEnumeratorTests
}
}
[Fact]
public void MobileByDistanceEnumerator_ReturnsMinDistance()
{
var map = Map.Felucca;
var center = new Point3D(300, 300, 0);
const int range = 10;
var mobiles = new TestMobile[2];
try
{
mobiles[0] = CreateMobile(map, new Point3D(305, 305, 0));
mobiles[1] = CreateMobile(map, new Point3D(302, 302, 0));
var foundWithDistance = new List<(Mobile, int)>();
foreach (var result in map.GetMobilesInRangeByDistance(center, range))
{
foundWithDistance.Add(result);
}
Assert.Equal(2, foundWithDistance.Count);
// Each mobile should have a non-negative min distance
Assert.All(foundWithDistance, item => Assert.True(item.Item2 >= 0));
}
finally
{
DeleteAll(mobiles);
}
}
[Fact]
public void MobileByDistanceEnumerator_OrderedBySector()
{
var map = Map.Felucca;
var center = new Point3D(400, 400, 0);
const int range = Map.SectorSize * 2;
var mobiles = new TestMobile[3];
try
{
// Place mobiles in different sectors
mobiles[0] = CreateMobile(map, new Point3D(center.X + 2, center.Y + 2, 0));
mobiles[1] = CreateMobile(map, new Point3D(center.X + Map.SectorSize + 2, center.Y + 2, 0));
mobiles[2] = CreateMobile(map, new Point3D(center.X + 2, center.Y + Map.SectorSize + 2, 0));
var found = new List<Mobile>();
foreach (var (mobile, _) in map.GetMobilesInRangeByDistance(center, range))
{
found.Add(mobile);
}
Assert.Equal(3, found.Count);
Assert.Contains(mobiles[0], found);
Assert.Contains(mobiles[1], found);
Assert.Contains(mobiles[2], found);
}
finally
{
DeleteAll(mobiles);
}
}
[Fact]
public void MobileByDistanceEnumerator_MapNullYieldsEmpty()
{
var center = new Point2D(0, 0);
var bounds = new Rectangle2D(center.m_X - 10, center.m_Y - 10, 21, 21);
var enumerator = new Map.MobileDistanceEnumerable<Mobile>(null, bounds, center, false).GetEnumerator();
Assert.False(enumerator.MoveNext());
}
[Fact]
public void MobileByDistanceEnumerator_ThrowsOnVersionChange()
{
@ -241,50 +171,6 @@ public class MobileByDistanceEnumeratorTests
}
}
[Fact]
public void MobileByDistanceEnumerator_UsesDifferentPointOverloads()
{
var map = Map.Felucca;
var center = new Point3D(800, 800, 5);
const int range = 5;
var mobiles = new TestMobile[1];
try
{
mobiles[0] = CreateMobile(map, new Point3D(802, 802, 0));
// Test Point3D overload
var found1 = new List<Mobile>();
foreach (var (mobile, _) in map.GetMobilesInRangeByDistance(center, range))
{
found1.Add(mobile);
}
// Test (int, int) overload
var found2 = new List<Mobile>();
foreach (var (mobile, _) in map.GetMobilesInRangeByDistance<Mobile>(center.X, center.Y, range))
{
found2.Add(mobile);
}
// Test Point2D overload
var found3 = new List<Mobile>();
foreach (var (mobile, _) in map.GetMobilesInRangeByDistance(new Point2D(center.X, center.Y), range))
{
found3.Add(mobile);
}
Assert.Single(found1);
Assert.Equal(mobiles[0], found1[0]);
Assert.Equal(found1, found2);
Assert.Equal(found1, found3);
}
finally
{
DeleteAll(mobiles);
}
}
[Fact]
public void MobileByDistanceEnumerator_RingTraversal()
{
@ -386,58 +272,6 @@ public class MobileByDistanceEnumeratorTests
}
}
[Fact]
public void MobileByDistanceEnumerator_MultipleRings()
{
var map = Map.Felucca;
var center = new Point3D(1100, 1100, 0);
const int range = Map.SectorSize * 3;
var mobiles = new List<TestMobile>();
try
{
// Create a grid of mobiles across multiple sectors
for (var ringOffset = 0; ringOffset <= 2; ringOffset++)
{
for (var side = 0; side < 4; side++)
{
var offset = ringOffset * Map.SectorSize;
var pos = side switch
{
0 => new Point3D(center.X + offset, center.Y, 0),
1 => new Point3D(center.X, center.Y + offset, 0),
2 => new Point3D(center.X - offset, center.Y, 0),
_ => new Point3D(center.X, center.Y - offset, 0)
};
mobiles.Add(CreateMobile(map, pos));
}
}
var found = new List<Mobile>();
foreach (var (mobile, _) in map.GetMobilesInRangeByDistance(center, range))
{
found.Add(mobile);
}
// Should find all mobiles within range
Assert.True(found.Count > 0);
Assert.All(found, mobile =>
{
var dx = mobile.X - center.X;
var dy = mobile.Y - center.Y;
var distSq = dx * dx + dy * dy;
Assert.True(distSq <= range * range);
});
}
finally
{
foreach (var mobile in mobiles)
{
mobile?.Delete();
}
}
}
private static TestMobile CreateMobile(Map map, Point3D location)
{
var mobile = new TestMobile(World.NewMobile);
@ -526,33 +360,6 @@ public class MobileByDistanceEnumeratorTests
}
}
[Fact]
public void MobileByDistanceEnumerator_Bounds_ReturnsMinDistance()
{
var map = Map.Felucca;
var bounds = new Rectangle2D(300, 300, 20, 20);
var mobiles = new TestMobile[2];
try
{
mobiles[0] = CreateMobile(map, new Point3D(305, 305, 0));
mobiles[1] = CreateMobile(map, new Point3D(315, 315, 0));
var foundWithDistance = new List<(Mobile, int)>();
foreach (var result in map.GetMobilesInBoundsByDistance<Mobile>(bounds))
{
foundWithDistance.Add(result);
}
Assert.Equal(2, foundWithDistance.Count);
Assert.All(foundWithDistance, item => Assert.True(item.Item2 >= 0));
}
finally
{
DeleteAll(mobiles);
}
}
[Fact]
public void MobileByDistanceEnumerator_Bounds_OrdersByProximityToCenter()
{

7
Projects/Server.Tests/Tests/Maps/MobileEnumeratorTests.cs
View file

@ -87,13 +87,6 @@ public class MobileEnumeratorTests
}
}
[Fact]
public void MobileEnumerator_MapNullYieldsEmpty()
{
var enumerator = new Map.MobileEnumerator<Mobile>(null, Rectangle2D.Empty, false);
Assert.False(enumerator.MoveNext());
}
[Fact]
public void MobileEnumerator_ThrowsOnVersionChange()
{

79
Projects/Server.Tests/Tests/Maps/MultiEnumeratorTests.cs
View file

@ -88,13 +88,6 @@ public class MultiEnumeratorTests
}
}
[Fact]
public void MultiEnumerator_MapNullYieldsEmpty()
{
var enumerator = new Map.MultiBoundsEnumerable<BaseMulti>(null, Rectangle2D.Empty, false).GetEnumerator();
Assert.False(enumerator.MoveNext());
}
[Fact]
public void MultiEnumerator_ThrowsOnVersionChange()
{
@ -250,35 +243,6 @@ public class MultiEnumeratorTests
}
}
[Fact]
public void MultiSectorEnumerator_DeletedMultisAreSkipped()
{
var map = Map.Felucca;
var location = new Point3D(750, 750, 0);
var multis = new TestMulti[3];
try
{
multis[0] = CreateMulti(map, location);
multis[1] = CreateMulti(map, new Point3D(location.X + 1, location.Y, 0));
multis[2] = CreateMulti(map, new Point3D(location.X + 2, location.Y, 0));
multis[1].Delete();
var found = new List<BaseMulti>();
foreach (var multi in map.GetMultisInRange<BaseMulti>(location, 10))
{
found.Add(multi);
}
Assert.Equal(new[] { multis[0], multis[2] }, found);
}
finally
{
DeleteAll(multis);
}
}
[Fact]
public void MultiSectorEnumerator_MapNullYieldsEmpty()
{
@ -286,49 +250,6 @@ public class MultiEnumeratorTests
Assert.False(enumerator.MoveNext());
}
[Fact]
public void MultiSectorEnumerator_UsesDifferentPointOverloads()
{
var map = Map.Felucca;
var location = new Point3D(800, 800, 5);
var multis = new TestMulti[1];
try
{
multis[0] = CreateMulti(map, location);
// Test Point3D overload
var found1 = new List<BaseMulti>();
foreach (var multi in map.GetMultisInSector(location))
{
found1.Add(multi);
}
// Test (int, int) overload
var found2 = new List<BaseMulti>();
foreach (var multi in map.GetMultisInSector(location.X, location.Y))
{
found2.Add(multi);
}
// Test Point2D overload
var found3 = new List<BaseMulti>();
foreach (var multi in map.GetMultisInSector(new Point2D(location.X, location.Y)))
{
found3.Add(multi);
}
Assert.Single(found1);
Assert.Equal(multis[0], found1[0]);
Assert.Equal(found1, found2);
Assert.Equal(found1, found3);
}
finally
{
DeleteAll(multis);
}
}
[Fact]
public void MultiEnumerator_ZeroRangeReturnsOnlyCenter()
{

48
Projects/Server.Tests/Tests/Maps/StaticTileEnumeratorTests.cs
View file

@ -7,29 +7,6 @@ namespace Server.Tests.Maps;
[Collection("Sequential Server Tests")]
public class StaticTileEnumeratorTests
{
[Fact]
public void StaticTileEnumerator_MapNullYieldsEmpty()
{
var enumerator = new Map.StaticTileEnumerable(null, new Point2D(0, 0)).GetEnumerator();
Assert.False(enumerator.MoveNext());
}
[Fact]
public void StaticTileEnumerator_EmptyLocationYieldsEmpty()
{
var map = Map.Felucca;
var location = new Point2D(100, 100);
var tiles = new List<StaticTile>();
foreach (var tile in new Map.StaticTileEnumerable(map, location, includeStatics: true, includeMultis: false))
{
tiles.Add(tile);
}
// Since we don't have actual map files loaded, this should be empty
Assert.Empty(tiles);
}
[Fact]
public void StaticTileEnumerator_IncludeStaticsOnlyWorks()
{
@ -144,24 +121,6 @@ public class StaticTileEnumeratorTests
}
}
[Fact]
public void StaticTileEnumerator_TileMatrixGetStaticTilesWorks()
{
var map = Map.Felucca;
var x = 600;
var y = 600;
// Test the TileMatrix.GetStaticTiles method
var tiles = new List<StaticTile>();
foreach (var tile in map.Tiles.GetStaticTiles(x, y))
{
tiles.Add(tile);
}
// Without map files loaded, should be empty
Assert.Empty(tiles);
}
[Fact]
public void StaticTileEnumerator_TileMatrixGetStaticAndMultiTilesWorks()
{
@ -252,13 +211,6 @@ public class StaticTileEnumeratorTests
}
}
[Fact]
public void StaticTileEnumerator_EmptyReturnsCorrectly()
{
var enumerator = Map.StaticTileEnumerable.Empty.GetEnumerator();
Assert.False(enumerator.MoveNext());
}
[Fact]
public void StaticTileEnumerator_DeletedMultiSkipped()
{