test: fix shared state, CI-vacuous tests and harness duplication (#2722)
Follow-up to #2721. It fixes how the remaining tests behave and changes no production code. ## CI - Both `dotnet test` steps pass `--filter "Category!=Manual"`. Before this, Manual-tagged tests ran on CI anyway. - The one surviving movement-throttle latency test is the only coverage of burst forgiveness over a full, wrapped history. It loses its Manual tag, so it runs on CI. ## Tests that passed on CI without testing anything - **Corpse and throwing tests.** They relied on tiledata for the weapon `Layer`, so on CI the equip silently failed and they asserted against empty lists. They now set `Layer` explicitly and assert the equip took effect. `TestThrown` also pins its own strength and range values, so a shard retuning SoulGlaive no longer breaks them. - **Healthbar poison rows.** Server.Tests registers no poisons, so every row tested `null`. They now use real poison levels. - **Account packet tests.** The mock accounts reported `Length` 0, so the character-list tests only ever encoded empty slots. They now encode the real characters. - **Pathing and AI tests that only mean something on real Trammel/Felucca terrain** are now guarded with `TileDataRequirement.SkipIfMissing()`: Britain desk and clutter scenes, house footprints (no MultiData on CI) and fingerprints. Tests that are valid on flat blank terrain stay unguarded. (A synthetic tiledata fixture to run these on CI is a planned follow-up.) - **Assertions that couldn't fail now check their claim.** Affected tests include the `DefaultWalker` cache use, cache on/off parity requiring a path, the recorder capability flags, the idle-pet gate, the monthly DST recurrence, the AdvancedSearch `Record.Exception` wrappers, `CanFitItem` with no branch-guarded assert, the Firewall callback, and `Import_NoMap`. The Geometry Parse asserts also now use the same input as their TryParse. ## Shared state Every test that changes process-wide state now restores it, even when an assert fails: - **The clock.** A new `TimerWheelScope` saves and restores `Core._tickCount`, `Core._now` and the timer wheel. `SimulatedClockScope` covers decay tests. - **StepCache settings and caches**, via `StepCacheStateScope`. - **Network state.** The ManualAllowlist, LoginAllowlist, firewall and BanChannel reporters are restored. Global packet handlers are now registered per test and removed afterwards, so they no longer stay registered for later tests. - **Data and config tables.** `ArchiveJournal` statics, `TileData.ItemTable`, `ObjectPropertyList.Enabled`, `Core.Expansion` and the localization table are restored. One `MobileStatusVersion` restore was resetting a different expansion than the one the test changed. - **Entities.** Tests with fixed serials now delete what they create. Fixed mobile serials moved to `World.NewMobile`, because deleting a hard-coded serial could unregister a live entity. - **Collection race.** `SpiralScanTests` no longer clears the spawn cache from a separate collection that could run in parallel with the cache-manager tests. - **Shared statics.** Classes reading shared static allowlists joined the sequential collection. ## Duplication New shared helpers replace copy-pasted harness code: - **Server.Tests:** `PacketAssert.Sends`, used by about 130 packet tests; `TestClientHarness`, `PersistencePipelineScope`, `NetTestHelpers`, `EntityCleanup` and one `TestMulti`. - **UOContent.Tests:** `TimerWheelScope`, which also holds one wraparound-safe `RunFor`/`RunUntil`; `AiTestStubs`, which merges six walker copies and five identical creature stubs; `MobileTestHarness`, `CommandTestHarness` and `TempDirectory`. Dead oracle packet classes are removed. ## Cost | Test | Before | After | |---|---|---| | `VirtualSerialTests` | 1.57s | 2ms (starts near the wrap via reflection instead of drawing ~17.9M serials) | | Event scheduler recurrence loop | 473ms | 1ms | | CrowdSec drain | 517ms | 16ms (event-driven instead of a fixed 500ms wait) | | AuthId tests | 248ms | 99ms (SHA2 except the two GameLogin tests) | | Container cap tests | 5,000 items | 3,449 / 3,277 (one past each protocol cap) | | Bulk removal | 100k children | 20k children | | OPL hash distribution | 60k builds | 10k builds | ## Shard-tuning decoupling - AI assertions read `ReacquireDelay` and `FollowMoveSpeed` instead of hard-coding production tuning. - The guard friendly-fire test uses an `AI_Mage` stub instead of WhiteWyrm. - Argon2 assertions pin the `argon2id` variant and `v=19` but read the cost parameters from the configured hasher. ## Tests | Run | Server.Tests | UOContent.Tests | |---|---|---| | With client files | 812 pass | 1,123 pass | | Without client files (CI simulation) | 800 pass, 12 skip | 1,021 pass, 102 skip | - The UOContent fixture reads `MODERNUO_TEST_DATA_DIR`; Server.Tests reads `MODERNUO_CLIENT_PATH`. - The 15 new UOContent skips are the map-dependent guards above. - Total run time with client files is about 5s, down from about 8s.
This commit is contained in:
Kamron Batman
GitHub
parent
79f736aa83
commit
00134cac33
135 changed files with 3164 additions and 4020 deletions
|
|
@ -2,13 +2,13 @@ using Xunit;
|
|||
|
||||
namespace Server.Tests.Network;
|
||||
|
||||
[Collection("Sequential Server Tests")]
|
||||
public class ClientVersionTests
|
||||
{
|
||||
[Theory]
|
||||
[InlineData("7.0.33.1", "67.0.33", false, 0)]
|
||||
[InlineData("7.0.45.65", "67.0.33", false, 1)]
|
||||
[InlineData("6.0.0.0", "67.0.33", false, -1)]
|
||||
[InlineData("7.0.33.1", "7.0.33.1", true, 0)]
|
||||
public void TestCCAndECStringCtor(string ccVersion, string ecVersion, bool equal, int comparison)
|
||||
{
|
||||
var cc = new ClientVersion(ccVersion);
|
||||
|
|
@ -22,6 +22,7 @@ public class ClientVersionTests
|
|||
[InlineData(7, 0, 33, 1, 67, 0, 33, 0, false, 0)]
|
||||
[InlineData(7, 0, 45, 65, 67, 0, 33, 0, false, 1)]
|
||||
[InlineData(6, 0, 0, 0, 67, 0, 33, 0, false, -1)]
|
||||
[InlineData(7, 0, 33, 1, 7, 0, 33, 1, true, 0)]
|
||||
public void TestCCAndECCtor(
|
||||
int ccMaj, int ccMin, int ccRev, int ccPatch, int ecMaj, int ecMin, int ecRev, int ecPatch,
|
||||
bool equal, int comparison
|
||||
|
|
|
|||
|
|
@ -70,10 +70,11 @@ public class ConsoleInputPumpTests
|
|||
cmd => cmd == "ping" ? onPing : null
|
||||
);
|
||||
|
||||
Task.Run(pump.Run);
|
||||
var run = Task.Run(pump.Run);
|
||||
|
||||
Assert.True(invokedWith.Task.Wait(Timeout), "command not dispatched");
|
||||
Assert.Equal("hello", invokedWith.Task.Result);
|
||||
Assert.True(run.Wait(Timeout), "Run() did not return on EOF");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -81,7 +82,7 @@ public class ConsoleInputPumpTests
|
|||
{
|
||||
var reader = new BlockingTextReader();
|
||||
var pump = new ConsoleInputPump(reader, _ => null);
|
||||
Task.Run(pump.Run);
|
||||
var run = Task.Run(pump.Run);
|
||||
|
||||
// Register the prompt, then wait until it is actually pending before feeding a
|
||||
// line — otherwise the line could be consumed as a command before registration.
|
||||
|
|
@ -93,6 +94,7 @@ public class ConsoleInputPumpTests
|
|||
Assert.Equal("the answer", prompt.Result);
|
||||
|
||||
reader.Complete();
|
||||
Assert.True(run.Wait(Timeout), "Run() did not return on EOF");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -100,7 +102,7 @@ public class ConsoleInputPumpTests
|
|||
{
|
||||
var reader = new BlockingTextReader();
|
||||
var pump = new ConsoleInputPump(reader, _ => null);
|
||||
Task.Run(pump.Run);
|
||||
var run = Task.Run(pump.Run);
|
||||
|
||||
var prompt = Task.Run(pump.ReadLine);
|
||||
WaitUntil(() => pump.HasPendingPrompt, "prompt did not register");
|
||||
|
|
@ -108,6 +110,7 @@ public class ConsoleInputPumpTests
|
|||
|
||||
Assert.True(prompt.Wait(Timeout), "prompt hung on EOF");
|
||||
Assert.Null(prompt.Result);
|
||||
Assert.True(run.Wait(Timeout), "Run() did not return on EOF");
|
||||
Assert.False(pump.Running);
|
||||
}
|
||||
|
||||
|
|
@ -116,7 +119,7 @@ public class ConsoleInputPumpTests
|
|||
{
|
||||
var reader = new BlockingTextReader();
|
||||
var pump = new ConsoleInputPump(reader, _ => throw new InvalidOperationException("boom"));
|
||||
Task.Run(pump.Run);
|
||||
var run = Task.Run(pump.Run);
|
||||
|
||||
// Wait until the reader loop is blocked on its first read, then feed a bad command.
|
||||
WaitUntil(() => reader.ReadCallCount >= 1, "reader did not start");
|
||||
|
|
@ -133,6 +136,7 @@ public class ConsoleInputPumpTests
|
|||
|
||||
Assert.True(prompt.Wait(Timeout), "prompt hung after throwing lookup");
|
||||
Assert.Null(prompt.Result);
|
||||
Assert.True(run.Wait(Timeout), "Run() did not return on EOF");
|
||||
Assert.False(pump.Running);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ public class Point3DTests
|
|||
Assert.Equal(new Point3D(101, 23, 55), Point3D.Parse(" (101,23 ,55) ", null));
|
||||
|
||||
// No parenthesis
|
||||
Assert.False(Point3D.TryParse("101, 23 55)", null, out p));
|
||||
Assert.False(Point3D.TryParse("101, 23, 55)", null, out p));
|
||||
Assert.Equal(default, p);
|
||||
Assert.Throws<FormatException>(() => Point3D.Parse("101, 23, 55)", null));
|
||||
|
||||
|
|
|
|||
|
|
@ -104,7 +104,7 @@ public class Rectangle3DTests
|
|||
|
||||
Assert.False(Rectangle3D.TryParse("(101,,10)+(55, 89 1)", null, out p));
|
||||
Assert.Equal(default, p);
|
||||
Assert.Throws<FormatException>(() => Rectangle3D.Parse("(,23,)+(,89)", null));
|
||||
Assert.Throws<FormatException>(() => Rectangle3D.Parse("(101,,10)+(55, 89 1)", null));
|
||||
|
||||
Assert.False(Rectangle3D.TryParse("(,,)+(55,89, 1)", null, out p));
|
||||
Assert.Equal(default, p);
|
||||
|
|
|
|||
|
|
@ -90,16 +90,16 @@ public sealed class WorldLocationTests
|
|||
Assert.Equal(new WorldLocation(101, 23, 55, null), WorldLocation.Parse(" (101,23 ,55) [(-null-)]", null));
|
||||
|
||||
// No Brackets
|
||||
Assert.False(WorldLocation.TryParse("(101, 23 55) Felucca]", null, out p));
|
||||
Assert.False(WorldLocation.TryParse("(101, 23, 55) Felucca]", null, out p));
|
||||
Assert.Equal(default, p);
|
||||
Assert.Throws<FormatException>(() => WorldLocation.Parse("(101, 23, 55) Felucca]", null));
|
||||
|
||||
Assert.False(WorldLocation.TryParse("(101, 23 55) [Felucca", null, out p));
|
||||
Assert.False(WorldLocation.TryParse("(101, 23, 55) [Felucca", null, out p));
|
||||
Assert.Equal(default, p);
|
||||
Assert.Throws<FormatException>(() => WorldLocation.Parse("(101, 23, 55) [Felucca", null));
|
||||
|
||||
// No parenthesis
|
||||
Assert.False(WorldLocation.TryParse("101, 23 55) [Felucca]", null, out p));
|
||||
Assert.False(WorldLocation.TryParse("101, 23, 55) [Felucca]", null, out p));
|
||||
Assert.Equal(default, p);
|
||||
Assert.Throws<FormatException>(() => WorldLocation.Parse("101, 23, 55) [Felucca]", null));
|
||||
|
||||
|
|
|
|||
|
|
@ -6,32 +6,43 @@ namespace Server.Tests;
|
|||
[Collection("Sequential Server Tests")]
|
||||
public class ContainerBulkRemovalTests
|
||||
{
|
||||
// Large enough that a quadratic child removal (a front-to-back IndexOf per child) costs
|
||||
// roughly 2 * 10^8 comparisons and shows up in the test's run time.
|
||||
private const int ChildCount = 20_000;
|
||||
|
||||
[Fact]
|
||||
public void DeletingLargeContainer_DeletesAllChildren_AndTotalsStayConsistent()
|
||||
{
|
||||
var outer = new Container(0xE75);
|
||||
var pack = new Container(0xE75);
|
||||
outer.DropItem(pack);
|
||||
|
||||
var children = new Item[100_000];
|
||||
for (var i = 0; i < children.Length; i++)
|
||||
try
|
||||
{
|
||||
children[i] = new Item(0x1234);
|
||||
pack.DropItem(children[i]);
|
||||
var pack = new Container(0xE75);
|
||||
outer.DropItem(pack);
|
||||
|
||||
var children = new Item[ChildCount];
|
||||
for (var i = 0; i < children.Length; i++)
|
||||
{
|
||||
children[i] = new Item(0x1234);
|
||||
pack.DropItem(children[i]);
|
||||
}
|
||||
|
||||
Assert.Equal(children.Length + 1, outer.TotalItems);
|
||||
|
||||
pack.Delete();
|
||||
|
||||
for (var i = 0; i < children.Length; i++)
|
||||
{
|
||||
Assert.True(children[i].Deleted);
|
||||
}
|
||||
|
||||
Assert.Empty(outer.Items);
|
||||
Assert.Equal(0, outer.TotalItems);
|
||||
}
|
||||
|
||||
Assert.Equal(children.Length + 1, outer.TotalItems);
|
||||
|
||||
pack.Delete();
|
||||
|
||||
for (var i = 0; i < children.Length; i++)
|
||||
finally
|
||||
{
|
||||
Assert.True(children[i].Deleted);
|
||||
outer.Delete();
|
||||
}
|
||||
|
||||
Assert.Empty(outer.Items);
|
||||
Assert.Equal(0, outer.TotalItems);
|
||||
outer.Delete();
|
||||
}
|
||||
|
||||
// The tail fast path must not change which entry is removed when the item is elsewhere.
|
||||
|
|
@ -39,20 +50,27 @@ public class ContainerBulkRemovalTests
|
|||
public void RemovingFromFrontMiddleAndEnd_RemovesExactlyThatItem()
|
||||
{
|
||||
var pack = new Container(0xE75);
|
||||
var items = new Item[5];
|
||||
for (var i = 0; i < items.Length; i++)
|
||||
|
||||
try
|
||||
{
|
||||
items[i] = new Item(0x1234);
|
||||
pack.DropItem(items[i]);
|
||||
var items = new Item[5];
|
||||
for (var i = 0; i < items.Length; i++)
|
||||
{
|
||||
items[i] = new Item(0x1234);
|
||||
pack.DropItem(items[i]);
|
||||
}
|
||||
|
||||
items[0].Delete();
|
||||
items[2].Delete();
|
||||
items[4].Delete();
|
||||
|
||||
Assert.Equal(2, pack.Items.Count);
|
||||
Assert.Same(items[1], pack.Items[0]);
|
||||
Assert.Same(items[3], pack.Items[1]);
|
||||
}
|
||||
finally
|
||||
{
|
||||
pack.Delete();
|
||||
}
|
||||
|
||||
items[0].Delete();
|
||||
items[2].Delete();
|
||||
items[4].Delete();
|
||||
|
||||
Assert.Equal(2, pack.Items.Count);
|
||||
Assert.Same(items[1], pack.Items[0]);
|
||||
Assert.Same(items[3], pack.Items[1]);
|
||||
pack.Delete();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,8 +1,7 @@
|
|||
using System;
|
||||
using Server.Items;
|
||||
using Server.Network;
|
||||
using Server.Tests.Network;
|
||||
using Xunit;
|
||||
using static Server.Tests.TestClientHarness;
|
||||
|
||||
namespace Server.Tests;
|
||||
|
||||
|
|
@ -44,19 +43,6 @@ public class ContainerChildRemovalTests
|
|||
|
||||
private static readonly Point3D _ownerLoc = new(1500, 1500, 0);
|
||||
|
||||
private static (NetState, Mobile) CreateClient(Point3D location)
|
||||
{
|
||||
var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.Account = new MockAccount();
|
||||
|
||||
var mobile = new Mobile(World.NewMobile);
|
||||
mobile.DefaultMobileInit();
|
||||
ns.Mobile = mobile;
|
||||
mobile.NetState = ns;
|
||||
mobile.MoveToWorld(location, Map.Felucca);
|
||||
return (ns, mobile);
|
||||
}
|
||||
|
||||
private static Mobile CreateOwnerWith(Container pack)
|
||||
{
|
||||
var owner = new Mobile(World.NewMobile);
|
||||
|
|
@ -68,44 +54,6 @@ public class ContainerChildRemovalTests
|
|||
return owner;
|
||||
}
|
||||
|
||||
private static bool ReceivedRemove(NetState ns, Serial serial)
|
||||
{
|
||||
Span<byte> expected = stackalloc byte[OutgoingEntityPackets.RemoveEntityLength];
|
||||
OutgoingEntityPackets.CreateRemoveEntity(expected, serial);
|
||||
return ns.SendBuffer.GetReadSpan().IndexOf(expected) >= 0;
|
||||
}
|
||||
|
||||
private static int CountRemoves(NetState ns, Serial serial)
|
||||
{
|
||||
Span<byte> expected = stackalloc byte[OutgoingEntityPackets.RemoveEntityLength];
|
||||
OutgoingEntityPackets.CreateRemoveEntity(expected, serial);
|
||||
|
||||
var span = ns.SendBuffer.GetReadSpan();
|
||||
var count = 0;
|
||||
|
||||
while (true)
|
||||
{
|
||||
var index = span.IndexOf(expected);
|
||||
|
||||
if (index < 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
count++;
|
||||
span = span[(index + expected.Length)..];
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
private static void DisposeClient(NetState ns, Mobile mobile)
|
||||
{
|
||||
ns.Mobile = null;
|
||||
ns.Dispose();
|
||||
mobile.Delete();
|
||||
}
|
||||
|
||||
private static void Cleanup(NetState ns, Mobile client, Mobile owner)
|
||||
{
|
||||
DisposeClient(ns, client);
|
||||
|
|
|
|||
|
|
@ -5,11 +5,15 @@ using Xunit;
|
|||
namespace Server.Tests;
|
||||
|
||||
[Collection("Sequential Server Tests")]
|
||||
public class DecayRegistrationTests
|
||||
public class DecayRegistrationTests : IDisposable
|
||||
{
|
||||
private readonly EntityCleanup _cleanup = new();
|
||||
|
||||
// The wheel is static and these tests move the clock, so start each from a known schedule.
|
||||
public DecayRegistrationTests() => DecayScheduler.ResetForTests();
|
||||
|
||||
public void Dispose() => _cleanup.Dispose();
|
||||
|
||||
// Stands in for a region that refuses decay, e.g. HouseRegion over a locked down item.
|
||||
private class RefusesDecayItem : Item
|
||||
{
|
||||
|
|
@ -20,61 +24,34 @@ public class DecayRegistrationTests
|
|||
public override bool OnDecay() => false;
|
||||
}
|
||||
|
||||
// The item is already dequeued, so a refusal that does not reschedule strands it forever.
|
||||
// Drives the scheduler and the game clock without depending on the shared timer wheel.
|
||||
private static void AdvanceDecay(DateTime start, TimeSpan duration, Item item)
|
||||
{
|
||||
var deadline = start + duration;
|
||||
|
||||
for (var now = start; now <= deadline && !item.Deleted; now += TimeSpan.FromMilliseconds(256))
|
||||
{
|
||||
Core._now = now;
|
||||
DecayScheduler.ProcessTick(now);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ItemOnGround_ActuallyDecaysAfterDecayTime()
|
||||
{
|
||||
var start = Core._now;
|
||||
using var clock = new SimulatedClockScope();
|
||||
|
||||
try
|
||||
{
|
||||
var item = new Item(0x1234);
|
||||
item.MoveToWorld(new Point3D(100, 100, 0), Map.Felucca);
|
||||
var item = _cleanup.Track(new Item(0x1234));
|
||||
item.MoveToWorld(new Point3D(100, 100, 0), Map.Felucca);
|
||||
|
||||
Assert.True(DecayScheduler.IsRegistered(item));
|
||||
Assert.True(DecayScheduler.IsRegistered(item));
|
||||
|
||||
AdvanceDecay(start, item.DecayTime + TimeSpan.FromMinutes(2), item);
|
||||
clock.AdvanceDecay(item.DecayTime + TimeSpan.FromMinutes(2), item);
|
||||
|
||||
Assert.True(item.Deleted, "Item on the ground must decay once DecayTime elapses.");
|
||||
}
|
||||
finally
|
||||
{
|
||||
Core._now = start;
|
||||
}
|
||||
Assert.True(item.Deleted, "Item on the ground must decay once DecayTime elapses.");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ItemOnGround_DoesNotDecayBeforeDecayTime()
|
||||
{
|
||||
var start = Core._now;
|
||||
using var clock = new SimulatedClockScope();
|
||||
|
||||
try
|
||||
{
|
||||
var item = new Item(0x1234);
|
||||
item.MoveToWorld(new Point3D(102, 100, 0), Map.Felucca);
|
||||
var item = _cleanup.Track(new Item(0x1234));
|
||||
item.MoveToWorld(new Point3D(102, 100, 0), Map.Felucca);
|
||||
|
||||
AdvanceDecay(start, item.DecayTime - TimeSpan.FromMinutes(2), item);
|
||||
clock.AdvanceDecay(item.DecayTime - TimeSpan.FromMinutes(2), item);
|
||||
|
||||
Assert.False(item.Deleted, "Item must not decay before DecayTime elapses.");
|
||||
Assert.False(item.Deleted, "Item must not decay before DecayTime elapses.");
|
||||
|
||||
item.Delete();
|
||||
}
|
||||
finally
|
||||
{
|
||||
Core._now = start;
|
||||
}
|
||||
item.Delete();
|
||||
}
|
||||
|
||||
// The real client path: Mobile.Lift internalizes, then Mobile.Drop calls MoveToWorld.
|
||||
|
|
@ -84,7 +61,7 @@ public class DecayRegistrationTests
|
|||
[Fact]
|
||||
public void DecaySlot_AgreesWithStructures_AcrossLifecycle()
|
||||
{
|
||||
var item = new Item(0x1234);
|
||||
var item = _cleanup.Track(new Item(0x1234));
|
||||
|
||||
item.MoveToWorld(new Point3D(103, 100, 0), Map.Felucca);
|
||||
Assert.NotEqual(DecayScheduler.SlotNone, item.DecaySlot);
|
||||
|
|
@ -108,10 +85,10 @@ public class DecayRegistrationTests
|
|||
[Fact]
|
||||
public void ContainerDestroy_ContentsDroppedToGroundAreTracked()
|
||||
{
|
||||
var pack = new Container(0xE75);
|
||||
var pack = _cleanup.Track(new Container(0xE75));
|
||||
pack.MoveToWorld(new Point3D(105, 100, 0), Map.Felucca);
|
||||
|
||||
var item = new Item(0x1234);
|
||||
var item = _cleanup.Track(new Item(0x1234));
|
||||
pack.AddItem(item);
|
||||
Assert.False(DecayScheduler.IsRegistered(item));
|
||||
|
||||
|
|
@ -128,163 +105,127 @@ public class DecayRegistrationTests
|
|||
[Fact]
|
||||
public void StaleImmovableItemMadeMovable_GetsAFreshDecayWindow()
|
||||
{
|
||||
var start = Core._now;
|
||||
using var clock = new SimulatedClockScope();
|
||||
|
||||
try
|
||||
{
|
||||
var item = new Item(0x1234);
|
||||
item.MoveToWorld(new Point3D(107, 100, 0), Map.Felucca);
|
||||
var item = _cleanup.Track(new Item(0x1234));
|
||||
item.MoveToWorld(new Point3D(107, 100, 0), Map.Felucca);
|
||||
|
||||
item.Movable = false;
|
||||
Assert.False(DecayScheduler.IsRegistered(item), "A frozen item must not be tracked for decay.");
|
||||
item.Movable = false;
|
||||
Assert.False(DecayScheduler.IsRegistered(item), "A frozen item must not be tracked for decay.");
|
||||
|
||||
Core._now = start + TimeSpan.FromDays(30);
|
||||
var flipped = Core._now;
|
||||
clock.Now = clock.Start + TimeSpan.FromDays(30);
|
||||
|
||||
item.Movable = true;
|
||||
item.Movable = true;
|
||||
|
||||
Assert.True(DecayScheduler.IsRegistered(item), "An unfrozen item must be tracked for decay.");
|
||||
Assert.True(DecayScheduler.IsRegistered(item), "An unfrozen item must be tracked for decay.");
|
||||
|
||||
AdvanceDecay(flipped, item.DecayTime - TimeSpan.FromMinutes(2), item);
|
||||
Assert.False(item.Deleted, "An unfrozen item must get a full decay window, not vanish immediately.");
|
||||
clock.AdvanceDecay(item.DecayTime - TimeSpan.FromMinutes(2), item);
|
||||
Assert.False(item.Deleted, "An unfrozen item must get a full decay window, not vanish immediately.");
|
||||
|
||||
AdvanceDecay(Core._now, TimeSpan.FromMinutes(4), item);
|
||||
Assert.True(item.Deleted, "An unfrozen item must still decay once the fresh window elapses.");
|
||||
}
|
||||
finally
|
||||
{
|
||||
Core._now = start;
|
||||
}
|
||||
clock.AdvanceDecay(TimeSpan.FromMinutes(4), item);
|
||||
Assert.True(item.Deleted, "An unfrozen item must still decay once the fresh window elapses.");
|
||||
}
|
||||
|
||||
// Same transition through the Visible setter: unhiding a long-hidden item.
|
||||
[Fact]
|
||||
public void StaleHiddenItemMadeVisible_GetsAFreshDecayWindow()
|
||||
{
|
||||
var start = Core._now;
|
||||
using var clock = new SimulatedClockScope();
|
||||
|
||||
try
|
||||
{
|
||||
var item = new Item(0x1234);
|
||||
item.MoveToWorld(new Point3D(109, 100, 0), Map.Felucca);
|
||||
var item = _cleanup.Track(new Item(0x1234));
|
||||
item.MoveToWorld(new Point3D(109, 100, 0), Map.Felucca);
|
||||
|
||||
item.Visible = false;
|
||||
Assert.False(DecayScheduler.IsRegistered(item), "A hidden item must not be tracked for decay.");
|
||||
item.Visible = false;
|
||||
Assert.False(DecayScheduler.IsRegistered(item), "A hidden item must not be tracked for decay.");
|
||||
|
||||
Core._now = start + TimeSpan.FromDays(30);
|
||||
var flipped = Core._now;
|
||||
clock.Now = clock.Start + TimeSpan.FromDays(30);
|
||||
|
||||
item.Visible = true;
|
||||
item.Visible = true;
|
||||
|
||||
Assert.True(DecayScheduler.IsRegistered(item), "An unhidden item must be tracked for decay.");
|
||||
Assert.True(DecayScheduler.IsRegistered(item), "An unhidden item must be tracked for decay.");
|
||||
|
||||
AdvanceDecay(flipped, item.DecayTime - TimeSpan.FromMinutes(2), item);
|
||||
Assert.False(item.Deleted, "An unhidden item must get a full decay window, not vanish immediately.");
|
||||
clock.AdvanceDecay(item.DecayTime - TimeSpan.FromMinutes(2), item);
|
||||
Assert.False(item.Deleted, "An unhidden item must get a full decay window, not vanish immediately.");
|
||||
|
||||
AdvanceDecay(Core._now, TimeSpan.FromMinutes(4), item);
|
||||
Assert.True(item.Deleted, "An unhidden item must still decay once the fresh window elapses.");
|
||||
}
|
||||
finally
|
||||
{
|
||||
Core._now = start;
|
||||
}
|
||||
clock.AdvanceDecay(TimeSpan.FromMinutes(4), item);
|
||||
Assert.True(item.Deleted, "An unhidden item must still decay once the fresh window elapses.");
|
||||
}
|
||||
|
||||
// A refusal restarts the countdown without rewriting LastMoved.
|
||||
// A refusal restarts the countdown without rewriting LastMoved. The item is already dequeued
|
||||
// when OnDecay refuses, so a refusal that does not reschedule strands it forever.
|
||||
[Fact]
|
||||
public void RefusedDecay_DoesNotRewriteLastMoved()
|
||||
{
|
||||
var start = Core._now;
|
||||
using var clock = new SimulatedClockScope();
|
||||
|
||||
try
|
||||
{
|
||||
var item = new RefusesDecayItem();
|
||||
item.MoveToWorld(new Point3D(110, 100, 0), Map.Felucca);
|
||||
var lastMoved = item.LastMoved;
|
||||
var item = _cleanup.Track(new RefusesDecayItem());
|
||||
item.MoveToWorld(new Point3D(110, 100, 0), Map.Felucca);
|
||||
var lastMoved = item.LastMoved;
|
||||
|
||||
AdvanceDecay(start, item.DecayTime + TimeSpan.FromMinutes(2), item);
|
||||
clock.AdvanceDecay(item.DecayTime + TimeSpan.FromMinutes(2), item);
|
||||
|
||||
Assert.False(item.Deleted, "A refused decay must not delete the item.");
|
||||
Assert.True(DecayScheduler.IsRegistered(item), "A refused decay must leave the item tracked.");
|
||||
Assert.Equal(lastMoved, item.LastMoved);
|
||||
Assert.False(item.Deleted, "A refused decay must not delete the item.");
|
||||
Assert.True(DecayScheduler.IsRegistered(item), "A refused decay must leave the item tracked.");
|
||||
Assert.Equal(lastMoved, item.LastMoved);
|
||||
|
||||
item.Delete();
|
||||
}
|
||||
finally
|
||||
{
|
||||
Core._now = start;
|
||||
}
|
||||
item.Delete();
|
||||
}
|
||||
|
||||
// The fresh window must survive a save/load cycle, or a restart mid-window deletes the item.
|
||||
[Fact]
|
||||
public void FreshDecayWindow_SurvivesSerialization()
|
||||
{
|
||||
var start = Core._now;
|
||||
using var clock = new SimulatedClockScope();
|
||||
|
||||
try
|
||||
{
|
||||
var item = new Item(0x1234);
|
||||
item.MoveToWorld(new Point3D(111, 100, 0), Map.Felucca);
|
||||
var item = _cleanup.Track(new Item(0x1234));
|
||||
item.MoveToWorld(new Point3D(111, 100, 0), Map.Felucca);
|
||||
|
||||
item.Movable = false;
|
||||
Core._now = start + TimeSpan.FromDays(30);
|
||||
item.Movable = true;
|
||||
item.Movable = false;
|
||||
clock.Now = clock.Start + TimeSpan.FromDays(30);
|
||||
item.Movable = true;
|
||||
|
||||
var expected = item.ScheduledDecayTime;
|
||||
var expected = item.ScheduledDecayTime;
|
||||
|
||||
var writer = new BufferWriter(new byte[512], true);
|
||||
item.Serialize(writer);
|
||||
var writer = new BufferWriter(new byte[512], true);
|
||||
item.Serialize(writer);
|
||||
|
||||
var copy = new Item(item.Serial);
|
||||
copy.Deserialize(new BufferReader(writer.Buffer));
|
||||
var copy = new Item(item.Serial);
|
||||
copy.Deserialize(new BufferReader(writer.Buffer));
|
||||
|
||||
// The stamp is stored as a delta, so it ages only by the real time between
|
||||
// write and read - milliseconds here, the downtime in production.
|
||||
Assert.True(
|
||||
(copy.ScheduledDecayTime - expected).Duration() <= TimeSpan.FromSeconds(5),
|
||||
"The restarted decay window must survive a save/load cycle."
|
||||
);
|
||||
// The stamp is stored as a delta, so it ages only by the real time between
|
||||
// write and read - milliseconds here, the downtime in production.
|
||||
Assert.True(
|
||||
(copy.ScheduledDecayTime - expected).Duration() <= TimeSpan.FromSeconds(5),
|
||||
"The restarted decay window must survive a save/load cycle."
|
||||
);
|
||||
|
||||
item.Delete();
|
||||
copy.Delete();
|
||||
}
|
||||
finally
|
||||
{
|
||||
Core._now = start;
|
||||
}
|
||||
item.Delete();
|
||||
copy.Delete();
|
||||
}
|
||||
|
||||
// A real move supersedes the reset stamp; it must be dropped so the CompactInfo can collapse.
|
||||
[Fact]
|
||||
public void MovingAnItem_ClearsASupersededDecayResetStamp()
|
||||
{
|
||||
var start = Core._now;
|
||||
using var clock = new SimulatedClockScope();
|
||||
|
||||
try
|
||||
{
|
||||
var item = new Item(0x1234);
|
||||
item.MoveToWorld(new Point3D(112, 100, 0), Map.Felucca);
|
||||
var item = _cleanup.Track(new Item(0x1234));
|
||||
item.MoveToWorld(new Point3D(112, 100, 0), Map.Felucca);
|
||||
|
||||
item.Movable = false;
|
||||
Core._now = start + TimeSpan.FromDays(30);
|
||||
item.Movable = true;
|
||||
item.Movable = false;
|
||||
clock.Now = clock.Start + TimeSpan.FromDays(30);
|
||||
item.Movable = true;
|
||||
|
||||
Assert.NotEqual(default, item.DecayResetTime);
|
||||
Assert.NotEqual(default, item.DecayResetTime);
|
||||
|
||||
Core._now += TimeSpan.FromMinutes(1);
|
||||
item.MoveToWorld(new Point3D(113, 100, 0), Map.Felucca);
|
||||
clock.Now += TimeSpan.FromMinutes(1);
|
||||
item.MoveToWorld(new Point3D(113, 100, 0), Map.Felucca);
|
||||
|
||||
Assert.Equal(default, item.DecayResetTime);
|
||||
Assert.Equal(item.LastMoved + item.DecayTime, item.ScheduledDecayTime);
|
||||
Assert.True(DecayScheduler.IsRegistered(item));
|
||||
Assert.Equal(default, item.DecayResetTime);
|
||||
Assert.Equal(item.LastMoved + item.DecayTime, item.ScheduledDecayTime);
|
||||
Assert.True(DecayScheduler.IsRegistered(item));
|
||||
|
||||
item.Delete();
|
||||
}
|
||||
finally
|
||||
{
|
||||
Core._now = start;
|
||||
}
|
||||
item.Delete();
|
||||
}
|
||||
|
||||
// Losing decay eligibility makes the stamp meaningless; it must be dropped so the
|
||||
|
|
@ -292,29 +233,22 @@ public class DecayRegistrationTests
|
|||
[Fact]
|
||||
public void ItemBecomingIneligible_DropsTheDecayResetStamp()
|
||||
{
|
||||
var start = Core._now;
|
||||
using var clock = new SimulatedClockScope();
|
||||
|
||||
try
|
||||
{
|
||||
var item = new Item(0x1234);
|
||||
item.MoveToWorld(new Point3D(115, 100, 0), Map.Felucca);
|
||||
var item = _cleanup.Track(new Item(0x1234));
|
||||
item.MoveToWorld(new Point3D(115, 100, 0), Map.Felucca);
|
||||
|
||||
item.Movable = false;
|
||||
Core._now = start + TimeSpan.FromDays(30);
|
||||
item.Movable = true;
|
||||
item.Movable = false;
|
||||
clock.Now = clock.Start + TimeSpan.FromDays(30);
|
||||
item.Movable = true;
|
||||
|
||||
Assert.NotEqual(default, item.DecayResetTime);
|
||||
Assert.NotEqual(default, item.DecayResetTime);
|
||||
|
||||
item.Movable = false;
|
||||
item.Movable = false;
|
||||
|
||||
Assert.Equal(default, item.DecayResetTime);
|
||||
Assert.Equal(default, item.DecayResetTime);
|
||||
|
||||
item.Delete();
|
||||
}
|
||||
finally
|
||||
{
|
||||
Core._now = start;
|
||||
}
|
||||
item.Delete();
|
||||
}
|
||||
|
||||
// Moving a stamped item into a container programmatically (no drop, no SetLastMoved)
|
||||
|
|
@ -322,32 +256,25 @@ public class DecayRegistrationTests
|
|||
[Fact]
|
||||
public void StampedItemAddedToContainer_DropsTheDecayResetStamp()
|
||||
{
|
||||
var start = Core._now;
|
||||
using var clock = new SimulatedClockScope();
|
||||
|
||||
try
|
||||
{
|
||||
var pack = new Container(0xE75);
|
||||
pack.MoveToWorld(new Point3D(116, 100, 0), Map.Felucca);
|
||||
var pack = _cleanup.Track(new Container(0xE75));
|
||||
pack.MoveToWorld(new Point3D(116, 100, 0), Map.Felucca);
|
||||
|
||||
var item = new Item(0x1234);
|
||||
item.MoveToWorld(new Point3D(117, 100, 0), Map.Felucca);
|
||||
var item = _cleanup.Track(new Item(0x1234));
|
||||
item.MoveToWorld(new Point3D(117, 100, 0), Map.Felucca);
|
||||
|
||||
item.Movable = false;
|
||||
Core._now = start + TimeSpan.FromDays(30);
|
||||
item.Movable = true;
|
||||
item.Movable = false;
|
||||
clock.Now = clock.Start + TimeSpan.FromDays(30);
|
||||
item.Movable = true;
|
||||
|
||||
Assert.NotEqual(default, item.DecayResetTime);
|
||||
Assert.NotEqual(default, item.DecayResetTime);
|
||||
|
||||
pack.AddItem(item);
|
||||
pack.AddItem(item);
|
||||
|
||||
Assert.Equal(default, item.DecayResetTime);
|
||||
Assert.Equal(default, item.DecayResetTime);
|
||||
|
||||
pack.Delete();
|
||||
}
|
||||
finally
|
||||
{
|
||||
Core._now = start;
|
||||
}
|
||||
pack.Delete();
|
||||
}
|
||||
|
||||
// A raw Map assignment (e.g. a GM changing Map through props) is a move: it must
|
||||
|
|
@ -355,7 +282,7 @@ public class DecayRegistrationTests
|
|||
[Fact]
|
||||
public void ItemMovedToRealMapViaMapSetter_IsRegisteredForDecay()
|
||||
{
|
||||
var item = new Item(0x1234);
|
||||
var item = _cleanup.Track(new Item(0x1234));
|
||||
Assert.False(DecayScheduler.IsRegistered(item));
|
||||
|
||||
item.Map = Map.Felucca;
|
||||
|
|
@ -371,10 +298,10 @@ public class DecayRegistrationTests
|
|||
[Fact]
|
||||
public void PartialLiftOfGroundStack_LeavesRemainderRegisteredForDecay()
|
||||
{
|
||||
var stack = new Item(0x1234) { Stackable = true, Amount = 10 };
|
||||
var stack = _cleanup.Track(new Item(0x1234) { Stackable = true, Amount = 10 });
|
||||
stack.MoveToWorld(new Point3D(114, 100, 0), Map.Felucca);
|
||||
|
||||
var remainder = Mobile.LiftItemDupe(stack, 3);
|
||||
var remainder = _cleanup.Track(Mobile.LiftItemDupe(stack, 3));
|
||||
|
||||
Assert.NotNull(remainder);
|
||||
Assert.Equal(7, remainder.Amount);
|
||||
|
|
@ -388,6 +315,4 @@ public class DecayRegistrationTests
|
|||
stack.Delete();
|
||||
remainder.Delete();
|
||||
}
|
||||
|
||||
// Dropping into a container must untrack; taking it back out to the ground must re-track.
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +1,7 @@
|
|||
using System;
|
||||
using System.Buffers;
|
||||
using Server.Items;
|
||||
using Server.Network;
|
||||
using Server.Tests.Network;
|
||||
using Xunit;
|
||||
using static Server.Tests.TestClientHarness;
|
||||
|
||||
namespace Server.Tests;
|
||||
|
||||
|
|
@ -12,51 +10,6 @@ public class LiftRejectResyncTests
|
|||
{
|
||||
private static readonly Point3D _baseLoc = new(2200, 2200, 0);
|
||||
|
||||
private static (NetState, Mobile) CreateClient(Point3D location)
|
||||
{
|
||||
var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.Account = new MockAccount();
|
||||
|
||||
var mobile = new Mobile(World.NewMobile);
|
||||
mobile.DefaultMobileInit();
|
||||
ns.Mobile = mobile;
|
||||
mobile.NetState = ns;
|
||||
mobile.MoveToWorld(location, Map.Felucca);
|
||||
return (ns, mobile);
|
||||
}
|
||||
|
||||
private static void DisposeClient(NetState ns, Mobile mobile)
|
||||
{
|
||||
ns.Mobile = null;
|
||||
ns.Dispose();
|
||||
mobile.Delete();
|
||||
}
|
||||
|
||||
private static bool ReceivedContentUpdate(NetState ns, Serial serial)
|
||||
{
|
||||
Span<byte> expected = stackalloc byte[5];
|
||||
var writer = new SpanWriter(expected);
|
||||
writer.Write((byte)0x25); // ContainerContentUpdate packet ID
|
||||
writer.Write(serial);
|
||||
return ns.SendBuffer.GetReadSpan().IndexOf(expected) >= 0;
|
||||
}
|
||||
|
||||
private static bool ReceivedWorldItem(NetState ns, Item item)
|
||||
{
|
||||
Span<byte> expected = stackalloc byte[OutgoingEntityPackets.MaxWorldEntityPacketLength];
|
||||
var length = OutgoingItemPackets.CreateWorldItem(expected, item);
|
||||
return ns.SendBuffer.GetReadSpan().IndexOf(expected[..length]) >= 0;
|
||||
}
|
||||
|
||||
private static bool ReceivedEquipUpdate(NetState ns, Serial serial)
|
||||
{
|
||||
Span<byte> expected = stackalloc byte[5];
|
||||
var writer = new SpanWriter(expected);
|
||||
writer.Write((byte)0x2E); // EquipUpdate packet ID
|
||||
writer.Write(serial);
|
||||
return ns.SendBuffer.GetReadSpan().IndexOf(expected) >= 0;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PrivateNestedItem_RejectedLift_DoesNotResyncBystander()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -5,8 +5,10 @@ using Xunit;
|
|||
namespace Server.Tests;
|
||||
|
||||
[Collection("Sequential Server Tests")]
|
||||
public class LockedDownContainerDecayTests
|
||||
public class LockedDownContainerDecayTests : IDisposable
|
||||
{
|
||||
private readonly EntityCleanup _cleanup = new();
|
||||
|
||||
public LockedDownContainerDecayTests()
|
||||
{
|
||||
DecayScheduler.ResetForTests();
|
||||
|
|
@ -19,6 +21,8 @@ public class LockedDownContainerDecayTests
|
|||
}
|
||||
}
|
||||
|
||||
public void Dispose() => _cleanup.Dispose();
|
||||
|
||||
private class TestChest : Container
|
||||
{
|
||||
public TestChest() : base(0xE43)
|
||||
|
|
@ -35,11 +39,11 @@ public class LockedDownContainerDecayTests
|
|||
public override bool ContentsDecay => false;
|
||||
}
|
||||
|
||||
private static Item NewLoot() => new Item(0x1F03) { Movable = true, Visible = true };
|
||||
private Item NewLoot() => _cleanup.Track(new Item(0x1F03) { Movable = true, Visible = true });
|
||||
|
||||
private static TestChest PlaceLockedDownChest(int x)
|
||||
private TestChest PlaceLockedDownChest(int x)
|
||||
{
|
||||
var chest = new TestChest { Movable = false };
|
||||
var chest = _cleanup.Track(new TestChest { Movable = false });
|
||||
chest.MoveToWorld(new Point3D(x, 100, 0), Map.Felucca);
|
||||
chest.IsLockedDown = true;
|
||||
return chest;
|
||||
|
|
@ -62,7 +66,7 @@ public class LockedDownContainerDecayTests
|
|||
[Fact]
|
||||
public void ItemInOrdinaryContainer_IsNotTracked()
|
||||
{
|
||||
var chest = new TestChest();
|
||||
var chest = _cleanup.Track(new TestChest());
|
||||
chest.MoveToWorld(new Point3D(121, 100, 0), Map.Felucca);
|
||||
var loot = NewLoot();
|
||||
|
||||
|
|
@ -77,7 +81,7 @@ public class LockedDownContainerDecayTests
|
|||
[Fact]
|
||||
public void LockingAndReleasingContainer_RegistersAndUnregistersContents()
|
||||
{
|
||||
var chest = new TestChest { Movable = false };
|
||||
var chest = _cleanup.Track(new TestChest { Movable = false });
|
||||
chest.MoveToWorld(new Point3D(122, 100, 0), Map.Felucca);
|
||||
var loot = NewLoot();
|
||||
chest.AddItem(loot);
|
||||
|
|
@ -102,7 +106,7 @@ public class LockedDownContainerDecayTests
|
|||
[Fact]
|
||||
public void ContainerThatKeepsContents_DoesNotTrackThem()
|
||||
{
|
||||
var board = new KeepsContentsChest { Movable = false };
|
||||
var board = _cleanup.Track(new KeepsContentsChest { Movable = false });
|
||||
board.MoveToWorld(new Point3D(123, 100, 0), Map.Felucca);
|
||||
board.IsLockedDown = true;
|
||||
var piece = NewLoot();
|
||||
|
|
@ -118,7 +122,7 @@ public class LockedDownContainerDecayTests
|
|||
public void NestedContainerContents_AreNotTracked()
|
||||
{
|
||||
var chest = PlaceLockedDownChest(124);
|
||||
var bag = new TestChest();
|
||||
var bag = _cleanup.Track(new TestChest());
|
||||
chest.AddItem(bag);
|
||||
var loot = NewLoot();
|
||||
bag.AddItem(loot);
|
||||
|
|
@ -145,29 +149,17 @@ public class LockedDownContainerDecayTests
|
|||
[Fact]
|
||||
public void TrackedContents_DecayOnSchedule()
|
||||
{
|
||||
var start = Core._now;
|
||||
using var clock = new SimulatedClockScope();
|
||||
|
||||
try
|
||||
{
|
||||
var chest = PlaceLockedDownChest(126);
|
||||
var loot = NewLoot();
|
||||
chest.AddItem(loot);
|
||||
var chest = PlaceLockedDownChest(126);
|
||||
var loot = NewLoot();
|
||||
chest.AddItem(loot);
|
||||
|
||||
var deadline = start + loot.DecayTime + TimeSpan.FromMinutes(2);
|
||||
for (var now = start; now <= deadline && !loot.Deleted; now += TimeSpan.FromMilliseconds(256))
|
||||
{
|
||||
Core._now = now;
|
||||
DecayScheduler.ProcessTick(now);
|
||||
}
|
||||
clock.AdvanceDecay(loot.DecayTime + TimeSpan.FromMinutes(2), loot);
|
||||
|
||||
Assert.True(loot.Deleted, "Contents of a locked-down container must decay.");
|
||||
Assert.False(chest.Deleted, "The locked-down container itself must not decay.");
|
||||
Assert.True(loot.Deleted, "Contents of a locked-down container must decay.");
|
||||
Assert.False(chest.Deleted, "The locked-down container itself must not decay.");
|
||||
|
||||
chest.Delete();
|
||||
}
|
||||
finally
|
||||
{
|
||||
Core._now = start;
|
||||
}
|
||||
chest.Delete();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,15 +1,24 @@
|
|||
using System;
|
||||
using System.Buffers;
|
||||
using Server.Items;
|
||||
using Server.Network;
|
||||
using Server.Tests.Network;
|
||||
using Xunit;
|
||||
using static Server.Tests.TestClientHarness;
|
||||
|
||||
namespace Server.Tests;
|
||||
|
||||
[Collection("Sequential Server Tests")]
|
||||
public class PrivateChildPropertiesTests
|
||||
public class PrivateChildPropertiesTests : IDisposable
|
||||
{
|
||||
private readonly bool _oplWasEnabled;
|
||||
|
||||
public PrivateChildPropertiesTests()
|
||||
{
|
||||
_oplWasEnabled = ObjectPropertyList.Enabled;
|
||||
ObjectPropertyList.Enabled = true;
|
||||
}
|
||||
|
||||
public void Dispose() => ObjectPropertyList.Enabled = _oplWasEnabled;
|
||||
|
||||
private class PublicContainer : Container
|
||||
{
|
||||
public PublicContainer() : base(0xE75)
|
||||
|
|
@ -21,35 +30,6 @@ public class PrivateChildPropertiesTests
|
|||
|
||||
private static readonly Point3D _ownerLoc = new(1600, 1600, 0);
|
||||
|
||||
private static (NetState, Mobile) CreateClient(Point3D location)
|
||||
{
|
||||
var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.Account = new MockAccount();
|
||||
|
||||
var mobile = new Mobile(World.NewMobile);
|
||||
mobile.DefaultMobileInit();
|
||||
ns.Mobile = mobile;
|
||||
mobile.NetState = ns;
|
||||
mobile.MoveToWorld(location, Map.Felucca);
|
||||
return (ns, mobile);
|
||||
}
|
||||
|
||||
private static void DisposeClient(NetState ns, Mobile mobile)
|
||||
{
|
||||
ns.Mobile = null;
|
||||
ns.Dispose();
|
||||
mobile.Delete();
|
||||
}
|
||||
|
||||
private static bool ReceivedOplInfo(NetState ns, Serial serial)
|
||||
{
|
||||
Span<byte> expected = stackalloc byte[5];
|
||||
var writer = new SpanWriter(expected);
|
||||
writer.Write((byte)0xDC); // OPL info packet ID
|
||||
writer.Write(serial);
|
||||
return ns.SendBuffer.GetReadSpan().IndexOf(expected) >= 0;
|
||||
}
|
||||
|
||||
// AddItem/MoveToWorld already queue their own Update (+Properties) delta as a side effect of the
|
||||
// Map setter. Draining it first isolates the properties-only delta the test actually exercises;
|
||||
// otherwise the leftover Update flag routes through the Update branch and the test would pass or
|
||||
|
|
@ -68,9 +48,6 @@ public class PrivateChildPropertiesTests
|
|||
[Fact]
|
||||
public void PrivateChildInOwnerBackpack_PropertiesOnlyUpdate_ReachesOwnerNotBystander()
|
||||
{
|
||||
var wasEnabled = ObjectPropertyList.Enabled;
|
||||
ObjectPropertyList.Enabled = true;
|
||||
|
||||
var (ownerNs, owner) = CreateClient(_ownerLoc);
|
||||
var (bystanderNs, bystander) = CreateClient(new Point3D(_ownerLoc.X + 1, _ownerLoc.Y, 0));
|
||||
|
||||
|
|
@ -93,16 +70,12 @@ public class PrivateChildPropertiesTests
|
|||
child.Delete();
|
||||
DisposeClient(ownerNs, owner);
|
||||
DisposeClient(bystanderNs, bystander);
|
||||
ObjectPropertyList.Enabled = wasEnabled;
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PrivateGroundContainer_PropertiesOnlyUpdate_ReachesOpenerNotNonOpener()
|
||||
{
|
||||
var wasEnabled = ObjectPropertyList.Enabled;
|
||||
ObjectPropertyList.Enabled = true;
|
||||
|
||||
var (openerNs, opener) = CreateClient(_ownerLoc);
|
||||
var (bystanderNs, bystander) = CreateClient(new Point3D(_ownerLoc.X + 2, _ownerLoc.Y, 0));
|
||||
|
||||
|
|
@ -126,16 +99,12 @@ public class PrivateChildPropertiesTests
|
|||
container.Delete();
|
||||
DisposeClient(openerNs, opener);
|
||||
DisposeClient(bystanderNs, bystander);
|
||||
ObjectPropertyList.Enabled = wasEnabled;
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PublicContainerChild_PropertiesOnlyUpdate_StillReachesBystander()
|
||||
{
|
||||
var wasEnabled = ObjectPropertyList.Enabled;
|
||||
ObjectPropertyList.Enabled = true;
|
||||
|
||||
var (bystanderNs, bystander) = CreateClient(_ownerLoc);
|
||||
|
||||
var pack = new PublicContainer();
|
||||
|
|
@ -155,16 +124,12 @@ public class PrivateChildPropertiesTests
|
|||
{
|
||||
pack.Delete();
|
||||
DisposeClient(bystanderNs, bystander);
|
||||
ObjectPropertyList.Enabled = wasEnabled;
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GroundItem_PropertiesOnlyUpdate_StillReachesBystander()
|
||||
{
|
||||
var wasEnabled = ObjectPropertyList.Enabled;
|
||||
ObjectPropertyList.Enabled = true;
|
||||
|
||||
var (bystanderNs, bystander) = CreateClient(_ownerLoc);
|
||||
|
||||
var item = new Item(0x1234);
|
||||
|
|
@ -181,7 +146,6 @@ public class PrivateChildPropertiesTests
|
|||
{
|
||||
item.Delete();
|
||||
DisposeClient(bystanderNs, bystander);
|
||||
ObjectPropertyList.Enabled = wasEnabled;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,18 +1,28 @@
|
|||
using System;
|
||||
using Xunit;
|
||||
|
||||
namespace Server.Tests;
|
||||
|
||||
[Collection("Sequential Server Tests")]
|
||||
public class LocalizationEntryTests
|
||||
public class LocalizationEntryTests : IDisposable
|
||||
{
|
||||
private const int FormatNumber = 500002;
|
||||
private const int ParameterNumber = 500003;
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
Localization.Remove("enu", FormatNumber);
|
||||
Localization.Remove("enu", ParameterNumber);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestClilocAsParameter()
|
||||
{
|
||||
Localization.Add("enu", 500002, "This tests ~1_NUMBER~ as parameters.");
|
||||
Localization.Add("enu", 500003, "clilocs");
|
||||
Localization.Add("enu", FormatNumber, "This tests ~1_NUMBER~ as parameters.");
|
||||
Localization.Add("enu", ParameterNumber, "clilocs");
|
||||
|
||||
string numericFormatter = Localization.Format(500002, "enu", $"{500003:#}");
|
||||
string stringParam = Localization.Format(500002, "enu", $"{"#500003"}");
|
||||
string numericFormatter = Localization.Format(FormatNumber, "enu", $"{ParameterNumber:#}");
|
||||
string stringParam = Localization.Format(FormatNumber, "enu", $"{"#500003"}");
|
||||
|
||||
Assert.Equal("This tests clilocs as parameters.", numericFormatter);
|
||||
Assert.Equal("This tests clilocs as parameters.", stringParam);
|
||||
|
|
|
|||
|
|
@ -33,6 +33,8 @@ public class CanFitItemTests
|
|||
Assert.False(map.CanFitItem(100, map.Height + 1, 0, 1));
|
||||
}
|
||||
|
||||
// Plain walkable land in the real Felucca map. Without map files every cell is the default land
|
||||
// tile at Z 0 with no flags, which these tests treat the same way: a surface with nothing above it.
|
||||
private const int TestLandX = 1500;
|
||||
private const int TestLandY = 1600;
|
||||
|
||||
|
|
@ -170,23 +172,19 @@ public class CanFitItemTests
|
|||
Item movableItem = null;
|
||||
try
|
||||
{
|
||||
// Create a movable surface item
|
||||
// Raised well clear of the land so the movable item's top is the only candidate surface there
|
||||
var itemZ = map.GetAverageZ(x, y) + 20;
|
||||
|
||||
movableItem = new Item(ServerFixture.SurfaceTileId)
|
||||
{
|
||||
Movable = true
|
||||
};
|
||||
movableItem.MoveToWorld(new Point3D(x, y, 10), map);
|
||||
movableItem.MoveToWorld(new Point3D(x, y, itemZ), map);
|
||||
|
||||
var itemTop = 10 + movableItem.ItemData.CalcHeight;
|
||||
// Try placing at item top - should fail unless there's land there too
|
||||
var avgZ = map.GetAverageZ(x, y);
|
||||
var itemTop = itemZ + movableItem.ItemData.CalcHeight;
|
||||
var result = map.CanFitItem(x, y, itemTop, 1);
|
||||
|
||||
// If avgZ != itemTop, there's no other surface, so it should fail
|
||||
if (avgZ != itemTop)
|
||||
{
|
||||
var result = map.CanFitItem(x, y, itemTop, 1);
|
||||
Assert.False(result, "Movable item should not count as valid surface");
|
||||
}
|
||||
Assert.False(result, "Movable item should not count as valid surface");
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
@ -248,16 +246,4 @@ public class CanFitItemTests
|
|||
multi.MoveToWorld(location, map);
|
||||
return multi;
|
||||
}
|
||||
|
||||
private class TestMulti : BaseMulti
|
||||
{
|
||||
private readonly MultiComponentList _components;
|
||||
|
||||
public TestMulti(MultiComponentList components) : base(0x1)
|
||||
{
|
||||
_components = components ?? MultiComponentList.Empty;
|
||||
}
|
||||
|
||||
public override MultiComponentList Components => _components;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,7 +29,8 @@ public class CanSpawnMobileTests
|
|||
Assert.False(map.CanSpawnMobile(100, map.Height + 1, -128, 127, false, false, out _));
|
||||
}
|
||||
|
||||
// Use coordinates near Britain which should be walkable land in both test and real data
|
||||
// Plain walkable land near Britain in the real Felucca map. Without map files every cell is the
|
||||
// default land tile at Z 0 with no flags, which CanSpawnMobile treats the same way: walkable, not water.
|
||||
private const int TestLandX = 1500;
|
||||
private const int TestLandY = 1600;
|
||||
|
||||
|
|
@ -37,10 +38,9 @@ public class CanSpawnMobileTests
|
|||
public void CanSpawnMobile_EmptyLocationWithLandReturnsTrue()
|
||||
{
|
||||
var map = Map.Felucca;
|
||||
map.GetAverageZ(TestLandX, TestLandY, out _, out var landZ, out _);
|
||||
|
||||
// Test with full Z range to find land
|
||||
var result = map.CanSpawnMobile(TestLandX, TestLandY, -128, 127, false, false, out var spawnZ);
|
||||
var result = map.CanSpawnMobile(TestLandX, TestLandY, -128, 127, false, false, out _);
|
||||
|
||||
// Should find a valid spawn point (land surface)
|
||||
Assert.True(result, $"Expected to find valid spawn point on land at ({TestLandX}, {TestLandY})");
|
||||
|
|
@ -53,7 +53,7 @@ public class CanSpawnMobileTests
|
|||
map.GetAverageZ(TestLandX, TestLandY, out _, out var avgZ, out _);
|
||||
|
||||
// Use a Z range that excludes the land surface (50+ units above land)
|
||||
var result = map.CanSpawnMobile(TestLandX, TestLandY, avgZ + 50, avgZ + 100, false, false, out var spawnZ);
|
||||
var result = map.CanSpawnMobile(TestLandX, TestLandY, avgZ + 50, avgZ + 100, false, false, out _);
|
||||
|
||||
Assert.False(result, $"Expected no spawn point above land at Z={avgZ}");
|
||||
}
|
||||
|
|
@ -63,7 +63,7 @@ public class CanSpawnMobileTests
|
|||
{
|
||||
var map = Map.Felucca;
|
||||
// cantWalk=true means the mob can only swim, so land shouldn't be valid
|
||||
var result = map.CanSpawnMobile(TestLandX, TestLandY, -128, 127, false, true, out var spawnZ);
|
||||
var result = map.CanSpawnMobile(TestLandX, TestLandY, -128, 127, false, true, out _);
|
||||
|
||||
Assert.False(result, "cantWalk=true should not find land as valid surface");
|
||||
}
|
||||
|
|
@ -83,7 +83,7 @@ public class CanSpawnMobileTests
|
|||
blockingMobile.MoveToWorld(new Point3D(TestLandX, TestLandY, landZ), map);
|
||||
|
||||
// The mobile should block spawning at its location and Z
|
||||
var result = map.CanSpawnMobile(TestLandX, TestLandY, landZ - 16, landZ + 16, false, false, out var spawnZ);
|
||||
var result = map.CanSpawnMobile(TestLandX, TestLandY, landZ - 16, landZ + 16, false, false, out _);
|
||||
|
||||
// Land surface is blocked by mobile at the same Z
|
||||
Assert.False(result, "Mobile should block spawn at same location");
|
||||
|
|
@ -115,7 +115,7 @@ public class CanSpawnMobileTests
|
|||
gm.MoveToWorld(new Point3D(x, y, landZ), map);
|
||||
|
||||
// Hidden GM should not block spawning
|
||||
var result = map.CanSpawnMobile(x, y, landZ - 16, landZ + 16, false, false, out var spawnZ);
|
||||
var result = map.CanSpawnMobile(x, y, landZ - 16, landZ + 16, false, false, out _);
|
||||
|
||||
Assert.True(result, "Hidden GM should not block spawn");
|
||||
}
|
||||
|
|
@ -142,7 +142,7 @@ public class CanSpawnMobileTests
|
|||
blockingMobile.MoveToWorld(new Point3D(x, y, landZ + 50), map);
|
||||
|
||||
// Land should still be valid (mobile above doesn't block ground level)
|
||||
var result = map.CanSpawnMobile(x, y, landZ - 16, landZ + 16, false, false, out var spawnZ);
|
||||
var result = map.CanSpawnMobile(x, y, landZ - 16, landZ + 16, false, false, out _);
|
||||
|
||||
Assert.True(result, "Mobile at different Z should not block");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,13 +11,6 @@ namespace Server.Tests.Maps;
|
|||
[Collection("Sequential Server Tests")]
|
||||
public class CanSpawnMobileTileDataTests
|
||||
{
|
||||
private readonly ServerFixture _fixture;
|
||||
|
||||
public CanSpawnMobileTileDataTests(ServerFixture fixture)
|
||||
{
|
||||
_fixture = fixture;
|
||||
}
|
||||
|
||||
private void SkipIfNoTileData()
|
||||
{
|
||||
Skip.If(!ServerFixture.TileDataLoaded, "TileData not loaded - client files required");
|
||||
|
|
@ -96,7 +89,7 @@ public class CanSpawnMobileTileDataTests
|
|||
multi = CreateFloorWithCeilingMulti(map, new Point3D(x, y, 0), floorZ: 20, ceilingZ: 28);
|
||||
|
||||
// The low ceiling should block spawning (need 16 units clearance for mobiles)
|
||||
var result = map.CanSpawnMobile(x, y, 15, 35, false, false, out var spawnZ);
|
||||
var result = map.CanSpawnMobile(x, y, 15, 35, false, false, out _);
|
||||
|
||||
Assert.False(result);
|
||||
}
|
||||
|
|
@ -121,7 +114,7 @@ public class CanSpawnMobileTileDataTests
|
|||
// Create a multi with floor at Z=20 and ceiling at Z=50 (30 units clearance)
|
||||
multi = CreateFloorWithCeilingMulti(map, new Point3D(x, y, 0), floorZ: 20, ceilingZ: 50);
|
||||
|
||||
var result = map.CanSpawnMobile(x, y, 15, 35, false, false, out var spawnZ);
|
||||
var result = map.CanSpawnMobile(x, y, 15, 35, false, false, out _);
|
||||
|
||||
Assert.True(result);
|
||||
}
|
||||
|
|
@ -147,7 +140,7 @@ public class CanSpawnMobileTileDataTests
|
|||
multi = CreateFloorWithCeilingMulti(map, new Point3D(x, y, 0), floorZ: 20, ceilingZ: 100);
|
||||
|
||||
// The blocker at Z=100 shouldn't affect spawning in range 15-35
|
||||
var result = map.CanSpawnMobile(x, y, 15, 35, false, false, out var spawnZ);
|
||||
var result = map.CanSpawnMobile(x, y, 15, 35, false, false, out _);
|
||||
|
||||
Assert.True(result);
|
||||
}
|
||||
|
|
@ -173,7 +166,7 @@ public class CanSpawnMobileTileDataTests
|
|||
multi = CreateWaterMulti(map, new Point3D(x, y, 0), waterZ: 0);
|
||||
|
||||
// canSwim=true should find the water surface
|
||||
var result = map.CanSpawnMobile(x, y, -10, 10, true, false, out var spawnZ);
|
||||
var result = map.CanSpawnMobile(x, y, -10, 10, true, false, out _);
|
||||
|
||||
Assert.True(result);
|
||||
}
|
||||
|
|
@ -202,7 +195,7 @@ public class CanSpawnMobileTileDataTests
|
|||
};
|
||||
surfaceItem.MoveToWorld(new Point3D(x, y, 10), map);
|
||||
|
||||
var result = map.CanSpawnMobile(x, y, 5, 30, false, false, out var spawnZ);
|
||||
var result = map.CanSpawnMobile(x, y, 5, 30, false, false, out _);
|
||||
|
||||
// Should find either land at Z=0 or the item surface, whichever is lowest
|
||||
Assert.True(result);
|
||||
|
|
@ -274,16 +267,4 @@ public class CanSpawnMobileTileDataTests
|
|||
new MultiTileEntry(ServerFixture.WetTileId, 0, 0, (short)waterZ, TileFlag.Wet)
|
||||
]);
|
||||
}
|
||||
|
||||
private class TestMulti : BaseMulti
|
||||
{
|
||||
private readonly MultiComponentList _components;
|
||||
|
||||
public TestMulti(MultiComponentList components) : base(0x1)
|
||||
{
|
||||
_components = components ?? MultiComponentList.Empty;
|
||||
}
|
||||
|
||||
public override MultiComponentList Components => _components;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -313,7 +313,7 @@ public class MultiEnumeratorTests
|
|||
var map = Map.Felucca;
|
||||
|
||||
// Components reach two tiles either side, so at x = 1024 the multi spans sectors 63 and 64
|
||||
var spanning = new SpanningMulti();
|
||||
var spanning = new TestMulti(SpanningComponents);
|
||||
try
|
||||
{
|
||||
spanning.MoveToWorld(new Point3D(1024, 1000, 0), map);
|
||||
|
|
@ -351,29 +351,11 @@ public class MultiEnumeratorTests
|
|||
}
|
||||
}
|
||||
|
||||
// Test implementation of BaseMulti
|
||||
private class TestMulti : BaseMulti
|
||||
{
|
||||
public TestMulti() : base(0x1)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
private class SpanningMulti : BaseMulti
|
||||
{
|
||||
// Entries after the first need non-zero flags or MultiComponentList drops them
|
||||
private static readonly MultiComponentList _components = new(
|
||||
[
|
||||
new MultiTileEntry(0x1, -2, 0, 0, TileFlag.Background),
|
||||
new MultiTileEntry(0x1, 2, 0, 0, TileFlag.Background)
|
||||
]
|
||||
);
|
||||
|
||||
public SpanningMulti() : base(0x1)
|
||||
{
|
||||
}
|
||||
|
||||
public override MultiComponentList Components => _components;
|
||||
}
|
||||
// Entries after the first need non-zero flags or MultiComponentList drops them
|
||||
private static readonly MultiComponentList SpanningComponents = new(
|
||||
[
|
||||
new MultiTileEntry(0x1, -2, 0, 0, TileFlag.Background),
|
||||
new MultiTileEntry(0x1, 2, 0, 0, TileFlag.Background)
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -13,21 +13,17 @@ public class StaticTileEnumeratorTests
|
|||
var map = Map.Felucca;
|
||||
var location = new Point2D(200, 200);
|
||||
|
||||
// Real map files may have statics here; without them there are none. Either way the multi adds nothing.
|
||||
var mapStatics = CollectTiles(map, location, includeStatics: true, includeMultis: false);
|
||||
|
||||
TestMulti multi = null;
|
||||
try
|
||||
{
|
||||
// Create a multi at the location
|
||||
multi = CreateMultiWithComponents(map, new Point3D(200, 200, 0));
|
||||
|
||||
// Get tiles with statics only (no multis)
|
||||
var tiles = new List<StaticTile>();
|
||||
foreach (var tile in new Map.StaticTileEnumerable(map, location, includeStatics: true, includeMultis: false))
|
||||
{
|
||||
tiles.Add(tile);
|
||||
}
|
||||
var tiles = CollectTiles(map, location, includeStatics: true, includeMultis: false);
|
||||
|
||||
// Should not include multi tiles
|
||||
Assert.Empty(tiles);
|
||||
Assert.Equal(mapStatics, tiles);
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
@ -69,21 +65,20 @@ public class StaticTileEnumeratorTests
|
|||
var map = Map.Felucca;
|
||||
var location = new Point2D(400, 400);
|
||||
|
||||
var mapStatics = CollectTiles(map, location, includeStatics: true, includeMultis: false);
|
||||
|
||||
TestMulti multi = null;
|
||||
try
|
||||
{
|
||||
// Create a multi at the location
|
||||
multi = CreateMultiWithComponents(map, new Point3D(400, 400, 0));
|
||||
|
||||
// Get all tiles (statics and multis)
|
||||
var tiles = new List<StaticTile>();
|
||||
foreach (var tile in new Map.StaticTileEnumerable(map, location, includeStatics: true, includeMultis: true))
|
||||
{
|
||||
tiles.Add(tile);
|
||||
}
|
||||
var multiTiles = CollectTiles(map, location, includeStatics: false, includeMultis: true);
|
||||
var tiles = CollectTiles(map, location, includeStatics: true, includeMultis: true);
|
||||
|
||||
// Should include multi tiles (statics would be empty without map files)
|
||||
Assert.NotEmpty(tiles);
|
||||
Assert.NotEmpty(multiTiles);
|
||||
Assert.Equal(mapStatics.Count + multiTiles.Count, tiles.Count);
|
||||
Assert.All(mapStatics, tile => Assert.Contains(tile, tiles));
|
||||
Assert.All(multiTiles, tile => Assert.Contains(tile, tiles));
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
@ -257,10 +252,10 @@ public class StaticTileEnumeratorTests
|
|||
{
|
||||
// Outer's bounds cover the probe cell but it has no tile there; placing it first puts it
|
||||
// ahead of inner in the sector's multi list
|
||||
outer = new TestMulti(World.NewItem, GappedComponents);
|
||||
outer = new TestMulti(GappedComponents);
|
||||
outer.MoveToWorld(new Point3D(1100, 1100, 0), map);
|
||||
|
||||
inner = new TestMulti(World.NewItem, SingleTileComponents);
|
||||
inner = new TestMulti(SingleTileComponents);
|
||||
inner.MoveToWorld(new Point3D(location.X, location.Y, 20), map);
|
||||
|
||||
var tiles = new List<StaticTile>();
|
||||
|
|
@ -294,28 +289,28 @@ public class StaticTileEnumeratorTests
|
|||
]
|
||||
);
|
||||
|
||||
private static readonly MultiComponentList DefaultComponents = new(
|
||||
[
|
||||
new MultiTileEntry(0x1, 0, 0, 0, 0x0),
|
||||
new MultiTileEntry(0x2, 1, 0, 0, 0x0)
|
||||
]
|
||||
);
|
||||
|
||||
private static List<StaticTile> CollectTiles(Map map, Point2D location, bool includeStatics, bool includeMultis)
|
||||
{
|
||||
var tiles = new List<StaticTile>();
|
||||
foreach (var tile in new Map.StaticTileEnumerable(map, location, includeStatics, includeMultis))
|
||||
{
|
||||
tiles.Add(tile);
|
||||
}
|
||||
|
||||
return tiles;
|
||||
}
|
||||
|
||||
private static TestMulti CreateMultiWithComponents(Map map, Point3D location)
|
||||
{
|
||||
var multi = new TestMulti(World.NewItem);
|
||||
var multi = new TestMulti(DefaultComponents);
|
||||
multi.MoveToWorld(location, map);
|
||||
return multi;
|
||||
}
|
||||
|
||||
private class TestMulti : BaseMulti
|
||||
{
|
||||
private readonly MultiComponentList _components;
|
||||
|
||||
public TestMulti(Serial serial, MultiComponentList components = null) : base(serial) =>
|
||||
_components = components ?? DefaultComponents;
|
||||
|
||||
public override MultiComponentList Components => _components;
|
||||
|
||||
private static readonly MultiComponentList DefaultComponents = new(
|
||||
[
|
||||
new MultiTileEntry(0x1, 0, 0, 0, 0x0),
|
||||
new MultiTileEntry(0x2, 1, 0, 0, 0x0)
|
||||
]
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,8 +7,18 @@ using Xunit;
|
|||
|
||||
namespace Server.Tests.Network.Bans;
|
||||
|
||||
public class BanChannelTests
|
||||
[Collection("Sequential Server Tests")]
|
||||
public class BanChannelTests : IDisposable
|
||||
{
|
||||
private readonly IBanReporter[] _previousReporters = [..BanChannel.Reporters];
|
||||
private readonly Func<IPAddress, string, bool> _previousIsExempt = BanChannel.IsExempt;
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
BanChannel.ConfigureForTesting(_previousReporters);
|
||||
BanChannel.IsExempt = _previousIsExempt;
|
||||
}
|
||||
|
||||
private sealed class FakeReporter : IBanReporter
|
||||
{
|
||||
public readonly List<(IPAddress ip, TimeSpan ttl, string reason)> Reports = [];
|
||||
|
|
@ -69,18 +79,11 @@ public class BanChannelTests
|
|||
var exempt = IPAddress.Parse("203.0.113.7");
|
||||
BanChannel.IsExempt = (ip, _) => ip.Equals(exempt);
|
||||
|
||||
try
|
||||
{
|
||||
BanChannel.Report(exempt, TimeSpan.FromHours(1), "rate-limit");
|
||||
Assert.Empty(reporter.Reports); // escalation suppressed; the local gate already acted
|
||||
BanChannel.Report(exempt, TimeSpan.FromHours(1), "rate-limit");
|
||||
Assert.Empty(reporter.Reports); // escalation suppressed; the local gate already acted
|
||||
|
||||
BanChannel.Report(IPAddress.Parse("203.0.113.8"), TimeSpan.FromHours(1), "rate-limit");
|
||||
Assert.Single(reporter.Reports); // everyone else is still contributed
|
||||
}
|
||||
finally
|
||||
{
|
||||
BanChannel.IsExempt = null;
|
||||
}
|
||||
BanChannel.Report(IPAddress.Parse("203.0.113.8"), TimeSpan.FromHours(1), "rate-limit");
|
||||
Assert.Single(reporter.Reports); // everyone else is still contributed
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
|
|||
|
|
@ -4,89 +4,20 @@ using Xunit;
|
|||
namespace Server.Tests.Network;
|
||||
|
||||
/// <summary>
|
||||
/// Manual tests for MovementThrottle latency scenarios.
|
||||
/// These tests simulate specific timing scenarios and should NOT run in CI/CD.
|
||||
///
|
||||
/// To run these tests manually:
|
||||
/// dotnet test --filter "Category=Manual"
|
||||
///
|
||||
/// To exclude from CI/CD, add to your test command:
|
||||
/// dotnet test --filter "Category!=Manual"
|
||||
/// MovementThrottle burst forgiveness against a full, wrapped movement history.
|
||||
/// </summary>
|
||||
[Collection("Sequential Server Tests")]
|
||||
[Trait("Category", "Manual")]
|
||||
public class MovementThrottleLatencyTests
|
||||
{
|
||||
/// <summary>
|
||||
/// Sets the simulated tick count for testing.
|
||||
/// </summary>
|
||||
private static void SetTickCount(long ticks)
|
||||
{
|
||||
Core._tickCount = ticks;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Simulates recording movements at specific intervals.
|
||||
/// </summary>
|
||||
private static void SimulateMovements(NetState ns, params (int delayMs, int costMs)[] movements)
|
||||
{
|
||||
ns._movementHistory ??= new NetState.MovementRecord[20];
|
||||
ns._movementHistoryIndex = 0;
|
||||
ns._movementHistoryFull = false;
|
||||
ns._lastMovementRecordTime = 0;
|
||||
|
||||
var currentTime = 0L;
|
||||
|
||||
foreach (var (delayMs, costMs) in movements)
|
||||
{
|
||||
currentTime += delayMs;
|
||||
SetTickCount(currentTime);
|
||||
|
||||
if (ns._lastMovementRecordTime > 0)
|
||||
{
|
||||
var interval = (int)(currentTime - ns._lastMovementRecordTime);
|
||||
|
||||
// Skip chain-breaking gaps (> 2000ms) like the real code does
|
||||
if (interval > 2000)
|
||||
{
|
||||
ns._lastGapDuration = interval;
|
||||
ns._lastMovementRecordTime = currentTime;
|
||||
continue;
|
||||
}
|
||||
|
||||
ns._movementHistory[ns._movementHistoryIndex] = new NetState.MovementRecord
|
||||
{
|
||||
Interval = (short)interval,
|
||||
TargetSpeed = (ushort)costMs,
|
||||
QueueDepth = 0,
|
||||
Flags = 0
|
||||
};
|
||||
|
||||
ns._movementHistoryIndex++;
|
||||
if (ns._movementHistoryIndex >= 20)
|
||||
{
|
||||
ns._movementHistoryIndex = 0;
|
||||
ns._movementHistoryFull = true;
|
||||
}
|
||||
}
|
||||
|
||||
ns._lastMovementRecordTime = currentTime;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Scenario: Verifies that burst forgiveness triggers correctly and clears gap duration.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void MultipleLagSpikes_NoAccumulatedSuspicion()
|
||||
public void AnalyzeMovement_BurstAfterGap_WrappedFullHistory_ForgivesAndClearsGap()
|
||||
{
|
||||
var ns = PacketTestUtilities.CreateTestNetState();
|
||||
SetTickCount(0);
|
||||
|
||||
// Set up history buffer with mostly normal movements and a burst at the end
|
||||
// The production recorder is private and only reachable through a full movement request, so
|
||||
// the history is laid out directly: 17 normal steps, then a 3-step burst ending at the wrap
|
||||
ns._movementHistory = new NetState.MovementRecord[20];
|
||||
|
||||
// Fill with 17 normal movements (100ms intervals)
|
||||
for (var i = 0; i < 17; i++)
|
||||
{
|
||||
ns._movementHistory[i] = new NetState.MovementRecord
|
||||
|
|
@ -98,7 +29,6 @@ public class MovementThrottleLatencyTests
|
|||
};
|
||||
}
|
||||
|
||||
// Add 3 burst movements at the end (10ms intervals = burst)
|
||||
for (var i = 17; i < 20; i++)
|
||||
{
|
||||
ns._movementHistory[i] = new NetState.MovementRecord
|
||||
|
|
@ -110,26 +40,19 @@ public class MovementThrottleLatencyTests
|
|||
};
|
||||
}
|
||||
|
||||
ns._movementHistoryIndex = 0; // Next write position (wrapped)
|
||||
ns._movementHistoryFull = true; // Buffer is full
|
||||
ns._movementHistoryIndex = 0;
|
||||
ns._movementHistoryFull = true;
|
||||
|
||||
// Set gap duration (simulating a lag spike before the burst)
|
||||
// A lag spike longer than the chain gap preceded the burst
|
||||
ns._lastGapDuration = 2500;
|
||||
|
||||
// Analyze - burst forgiveness should trigger
|
||||
var verdict = MovementThrottle.AnalyzeMovement(ns, out var rate, out var samples, out var confidence);
|
||||
var verdict = MovementThrottle.AnalyzeMovement(ns, out var rate, out _, out var confidence);
|
||||
|
||||
// Key assertions:
|
||||
// 1. Gap duration should be cleared (burst forgiveness triggered)
|
||||
Assert.Equal(0, ns._lastGapDuration);
|
||||
|
||||
// 2. Confidence should be reduced by 0.3x multiplier
|
||||
Assert.True(
|
||||
confidence < 0.5f,
|
||||
$"Burst after gap should have low confidence. Confidence={confidence}, Rate={rate}"
|
||||
);
|
||||
|
||||
// 3. Should NOT be Definite despite the burst (forgiveness applied)
|
||||
Assert.True(
|
||||
verdict != MovementThrottle.DetectionVerdict.Definite,
|
||||
$"Should not be Definite after burst forgiveness. Verdict={verdict}"
|
||||
|
|
|
|||
|
|
@ -1,6 +1,4 @@
|
|||
using System;
|
||||
using System.Diagnostics;
|
||||
using System.Net.Sockets;
|
||||
using Server.Network;
|
||||
using Xunit;
|
||||
|
||||
|
|
@ -96,35 +94,10 @@ public class NetStateDisconnectTests
|
|||
|
||||
Assert.True(ns._socket.DisconnectPending);
|
||||
|
||||
var received = new byte[payload.Length];
|
||||
var total = 0;
|
||||
var deadline = Stopwatch.StartNew();
|
||||
|
||||
while (total < payload.Length && deadline.ElapsedMilliseconds < 5000)
|
||||
{
|
||||
NetState.Slice();
|
||||
if (client.Poll(1000, SelectMode.SelectRead))
|
||||
{
|
||||
var read = client.Receive(received, total, payload.Length - total, SocketFlags.None);
|
||||
Assert.NotEqual(0, read);
|
||||
total += read;
|
||||
}
|
||||
}
|
||||
|
||||
Assert.Equal(payload, received);
|
||||
Assert.Equal(payload, NetTestHelpers.ReadAll(client, payload.Length, 5000));
|
||||
|
||||
// FIN follows once the send completes
|
||||
var eof = -1;
|
||||
while (eof != 0 && deadline.ElapsedMilliseconds < 5000)
|
||||
{
|
||||
NetState.Slice();
|
||||
if (client.Poll(1000, SelectMode.SelectRead))
|
||||
{
|
||||
eof = client.Receive(received);
|
||||
}
|
||||
}
|
||||
|
||||
Assert.Equal(0, eof);
|
||||
NetTestHelpers.WaitForEof(client, 5000);
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
@ -156,35 +129,8 @@ public class NetStateDisconnectTests
|
|||
|
||||
Assert.True(ns._socket.DisconnectPending);
|
||||
|
||||
var received = new byte[payload.Length];
|
||||
var total = 0;
|
||||
var deadline = Stopwatch.StartNew();
|
||||
|
||||
while (total < payload.Length && deadline.ElapsedMilliseconds < 10000)
|
||||
{
|
||||
NetState.Slice();
|
||||
if (client.Poll(1000, SelectMode.SelectRead))
|
||||
{
|
||||
var read = client.Receive(received, total, payload.Length - total, SocketFlags.None);
|
||||
Assert.NotEqual(0, read);
|
||||
total += read;
|
||||
}
|
||||
}
|
||||
|
||||
Assert.Equal(payload.Length, total);
|
||||
Assert.Equal(payload, received);
|
||||
|
||||
var eof = -1;
|
||||
while (eof != 0 && deadline.ElapsedMilliseconds < 10000)
|
||||
{
|
||||
NetState.Slice();
|
||||
if (client.Poll(1000, SelectMode.SelectRead))
|
||||
{
|
||||
eof = client.Receive(received);
|
||||
}
|
||||
}
|
||||
|
||||
Assert.Equal(0, eof);
|
||||
Assert.Equal(payload, NetTestHelpers.ReadAll(client, payload.Length));
|
||||
NetTestHelpers.WaitForEof(client);
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,8 +1,4 @@
|
|||
using System;
|
||||
using System.Buffers;
|
||||
using System.Diagnostics;
|
||||
using System.Network;
|
||||
using System.Threading;
|
||||
using Server.Network;
|
||||
using Xunit;
|
||||
|
||||
|
|
@ -12,71 +8,33 @@ namespace Server.Tests.Network;
|
|||
public class NetStateRecvGuardTests
|
||||
{
|
||||
private const byte TestPacketId = 0xB1;
|
||||
private const byte AttachAccountPacketId = 0x71;
|
||||
|
||||
private static unsafe void RegisterVariableLength()
|
||||
{
|
||||
if (IncomingPackets.GetHandler(TestPacketId) == null)
|
||||
{
|
||||
IncomingPackets.Register(TestPacketId, 0, false, &NoOp);
|
||||
}
|
||||
}
|
||||
private static unsafe NetTestHelpers.HandlerRegistration RegisterVariableLength() =>
|
||||
NetTestHelpers.RegisterHandler(TestPacketId, 0, &NoOp);
|
||||
|
||||
private static void NoOp(NetState state, SpanReader reader)
|
||||
{
|
||||
}
|
||||
|
||||
// Not 0x73: NetStateSendBufferTests registers its own no-op there first-come-wins, since the
|
||||
// handler table is process-global, and this test needs its own handler's side effect to fire.
|
||||
private const byte TestPingPacketId = 0x72;
|
||||
|
||||
private static byte _lastPing;
|
||||
|
||||
private static unsafe void RegisterNoOpPing()
|
||||
{
|
||||
if (IncomingPackets.GetHandler(TestPingPacketId) == null)
|
||||
{
|
||||
IncomingPackets.Register(TestPingPacketId, 2, false, &RecordPing);
|
||||
}
|
||||
}
|
||||
|
||||
private static void RecordPing(NetState state, SpanReader reader) => _lastPing = reader.ReadByte();
|
||||
|
||||
private const byte AttachAccountPacketId = 0x71;
|
||||
|
||||
private static unsafe void RegisterAttachAccount()
|
||||
{
|
||||
if (IncomingPackets.GetHandler(AttachAccountPacketId) == null)
|
||||
{
|
||||
IncomingPackets.Register(AttachAccountPacketId, 3, false, &AttachAccount);
|
||||
}
|
||||
}
|
||||
private static unsafe NetTestHelpers.HandlerRegistration RegisterAttachAccount() =>
|
||||
NetTestHelpers.RegisterHandler(AttachAccountPacketId, 3, &AttachAccount);
|
||||
|
||||
// Stands in for the 0x91 handler: the account attaches mid-parse, so the promotion is pending
|
||||
// with a receive armed when the next packet in the same completion reaches the guard
|
||||
private static void AttachAccount(NetState state, SpanReader reader) => state.Account = new MockAccount();
|
||||
|
||||
private static void SliceUntil(Func<bool> done)
|
||||
{
|
||||
var deadline = Stopwatch.StartNew();
|
||||
while (!done() && deadline.ElapsedMilliseconds < 5000)
|
||||
{
|
||||
NetState.Slice();
|
||||
Thread.Sleep(5);
|
||||
}
|
||||
|
||||
Assert.True(done());
|
||||
}
|
||||
|
||||
[SkippableFact]
|
||||
public void HandleReceive_PacketLongerThanTheRecvBuffer_IsAnError()
|
||||
{
|
||||
RegisterVariableLength();
|
||||
// A 16-bit length cannot exceed the 64 KiB base buffer, so the guard is only reachable
|
||||
// through a pre-auth buffer
|
||||
NetTestHelpers.RequirePreAuthBuffers();
|
||||
using var handler = RegisterVariableLength();
|
||||
var ns = PacketTestUtilities.CreateTestNetState(out var client);
|
||||
try
|
||||
{
|
||||
// A 16-bit length cannot exceed a 64 KiB buffer, so the guard is unreachable there and
|
||||
// this only ever hit the `< 3` check on a buffer that size.
|
||||
Skip.If(ns._socket.RecvBuffer.PhysicalSize > ushort.MaxValue);
|
||||
Assert.True(ns._socket.RecvBuffer.PhysicalSize <= ushort.MaxValue);
|
||||
|
||||
ns._protocolState = NetState.ProtocolState.GameServer_LoggedIn;
|
||||
|
||||
|
|
@ -84,7 +42,7 @@ public class NetStateRecvGuardTests
|
|||
// park the connection with nothing to arm a recv into
|
||||
var declared = ns._socket.RecvBuffer.PhysicalSize; // one more than the buffer can ever hold
|
||||
client.Send(new byte[] { TestPacketId, (byte)(declared >> 8), (byte)declared });
|
||||
SliceUntil(() => ns._protocolState == NetState.ProtocolState.Error);
|
||||
NetTestHelpers.SliceUntil(() => ns._protocolState == NetState.ProtocolState.Error);
|
||||
|
||||
Assert.Contains("bad state", ns._disconnectReason);
|
||||
}
|
||||
|
|
@ -98,7 +56,7 @@ public class NetStateRecvGuardTests
|
|||
[Fact]
|
||||
public void HandleReceive_PacketThatFits_WaitsForTheRest()
|
||||
{
|
||||
RegisterVariableLength();
|
||||
using var handler = RegisterVariableLength();
|
||||
var ns = PacketTestUtilities.CreateTestNetState(out var client);
|
||||
try
|
||||
{
|
||||
|
|
@ -106,7 +64,7 @@ public class NetStateRecvGuardTests
|
|||
|
||||
var declared = ns._socket.RecvBuffer.PhysicalSize / 2;
|
||||
client.Send(new byte[] { TestPacketId, (byte)(declared >> 8), (byte)declared });
|
||||
SliceUntil(() => ns._socket.RecvBuffer.ReadableBytes == 3);
|
||||
NetTestHelpers.SliceUntil(() => ns._socket.RecvBuffer.ReadableBytes == 3);
|
||||
|
||||
Assert.Equal(NetState.ProtocolState.GameServer_LoggedIn, ns._protocolState);
|
||||
Assert.True(ns.Running);
|
||||
|
|
@ -122,8 +80,8 @@ public class NetStateRecvGuardTests
|
|||
[SkippableFact]
|
||||
public void HandleReceive_OversizePacket_WithAnAccount_RetriesPromotionInsteadOfErroring()
|
||||
{
|
||||
Skip.If(NetState.InitialRecvBufferSize == 0);
|
||||
RegisterVariableLength();
|
||||
NetTestHelpers.RequirePreAuthBuffers();
|
||||
using var handler = RegisterVariableLength();
|
||||
var ns = PacketTestUtilities.CreateTestNetState(out var client);
|
||||
try
|
||||
{
|
||||
|
|
@ -135,7 +93,7 @@ public class NetStateRecvGuardTests
|
|||
|
||||
var declared = NetState.InitialRecvBufferSize; // as much as the initial buffer can ever hold
|
||||
client.Send(new byte[] { TestPacketId, (byte)(declared >> 8), (byte)declared });
|
||||
SliceUntil(() => ns._socket.RecvBuffer.ReadableBytes == 3);
|
||||
NetTestHelpers.SliceUntil(() => ns._socket.RecvBuffer.ReadableBytes == 3);
|
||||
|
||||
Assert.Equal(NetState.ProtocolState.GameServer_LoggedIn, ns._protocolState);
|
||||
Assert.True(ns.Running);
|
||||
|
|
@ -143,7 +101,7 @@ public class NetStateRecvGuardTests
|
|||
// The deferred promotion applies at this next completion; the header is then delivered
|
||||
// whole to the 0xB1 no-op handler
|
||||
client.Send(new byte[declared - 3]);
|
||||
SliceUntil(
|
||||
NetTestHelpers.SliceUntil(
|
||||
() => ns._socket.RecvBuffer.ReadableBytes == 0 &&
|
||||
ns._socket.RecvBuffer.PhysicalSize == NetState.RecvBufferSize
|
||||
);
|
||||
|
|
@ -161,8 +119,8 @@ public class NetStateRecvGuardTests
|
|||
[SkippableFact]
|
||||
public void HandleReceive_AfterABurstFillsTheInitialBuffer_KeepsReceiving()
|
||||
{
|
||||
Skip.If(NetState.InitialRecvBufferSize == 0);
|
||||
RegisterNoOpPing();
|
||||
NetTestHelpers.RequirePreAuthBuffers();
|
||||
using var ping = NetTestHelpers.RegisterPing();
|
||||
var ns = PacketTestUtilities.CreateTestNetState(out var client);
|
||||
try
|
||||
{
|
||||
|
|
@ -174,17 +132,17 @@ public class NetStateRecvGuardTests
|
|||
var pings = new byte[capacity + 1];
|
||||
for (var i = 0; i < pings.Length; i += 2)
|
||||
{
|
||||
pings[i] = TestPingPacketId;
|
||||
pings[i] = NetTestHelpers.PingPacketId;
|
||||
pings[i + 1] = (byte)(i / 2);
|
||||
}
|
||||
|
||||
client.Send(pings);
|
||||
SliceUntil(() => ns._socket.RecvBuffer.ReadableBytes == 0 && ns._receivedData);
|
||||
NetTestHelpers.SliceUntil(() => ns._socket.RecvBuffer.ReadableBytes == 0 && ns._receivedData);
|
||||
Assert.True(ns.Running);
|
||||
|
||||
// Without a re-arm this ping never arrives
|
||||
client.Send(new byte[] { TestPingPacketId, 0xEE });
|
||||
SliceUntil(() => _lastPing == 0xEE);
|
||||
client.Send(new byte[] { NetTestHelpers.PingPacketId, 0xEE });
|
||||
NetTestHelpers.SliceUntil(() => NetTestHelpers.LastPing == 0xEE);
|
||||
Assert.True(ns.Running);
|
||||
}
|
||||
finally
|
||||
|
|
@ -197,9 +155,9 @@ public class NetStateRecvGuardTests
|
|||
[SkippableFact]
|
||||
public void HandleReceive_AccountAttachedMidParse_ThenOversizeHeader_WaitsForThePendingPromotion()
|
||||
{
|
||||
Skip.If(NetState.InitialRecvBufferSize == 0);
|
||||
RegisterAttachAccount();
|
||||
RegisterVariableLength();
|
||||
NetTestHelpers.RequirePreAuthBuffers();
|
||||
using var attach = RegisterAttachAccount();
|
||||
using var handler = RegisterVariableLength();
|
||||
var ns = PacketTestUtilities.CreateTestNetState(out var client);
|
||||
try
|
||||
{
|
||||
|
|
@ -212,7 +170,7 @@ public class NetStateRecvGuardTests
|
|||
// header then hits the guard after the promotion already applied and simply waits on the
|
||||
// 64 KiB buffer, so the test cannot flake, it just exercises the weaker path on that run.
|
||||
client.Send(new byte[] { AttachAccountPacketId, 0x00, 0x00, TestPacketId, (byte)(declared >> 8), (byte)declared });
|
||||
SliceUntil(() => ns.Account != null);
|
||||
NetTestHelpers.SliceUntil(() => ns.Account != null);
|
||||
|
||||
Assert.True(ns.Running);
|
||||
Assert.Equal(NetState.ProtocolState.GameServer_LoggedIn, ns._protocolState);
|
||||
|
|
@ -220,7 +178,7 @@ public class NetStateRecvGuardTests
|
|||
|
||||
// The next completion applies the promotion and the whole packet is delivered
|
||||
client.Send(new byte[declared - 3]);
|
||||
SliceUntil(
|
||||
NetTestHelpers.SliceUntil(
|
||||
() => ns._socket.RecvBuffer.ReadableBytes == 0 &&
|
||||
ns._socket.RecvBuffer.PhysicalSize == NetState.RecvBufferSize
|
||||
);
|
||||
|
|
|
|||
|
|
@ -1,10 +1,8 @@
|
|||
using System;
|
||||
using System.Buffers;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.Net.Sockets;
|
||||
using System.Network;
|
||||
using System.Threading;
|
||||
using Server.Network;
|
||||
using Xunit;
|
||||
|
||||
|
|
@ -22,42 +20,11 @@ public class NetStateSendBufferTests
|
|||
return ns;
|
||||
}
|
||||
|
||||
private static byte[] Pattern(int length, int seed)
|
||||
{
|
||||
var data = new byte[length];
|
||||
new System.Random(seed).NextBytes(data);
|
||||
return data;
|
||||
}
|
||||
|
||||
private static unsafe void RegisterNoOpPing()
|
||||
{
|
||||
if (IncomingPackets.GetHandler(0x73) == null)
|
||||
{
|
||||
IncomingPackets.Register(0x73, 2, false, &NoOp);
|
||||
}
|
||||
}
|
||||
|
||||
private static void NoOp(NetState state, SpanReader reader)
|
||||
{
|
||||
}
|
||||
|
||||
private static void SliceUntil(Func<bool> done)
|
||||
{
|
||||
var deadline = Stopwatch.StartNew();
|
||||
while (!done() && deadline.ElapsedMilliseconds < 5000)
|
||||
{
|
||||
NetState.Slice();
|
||||
Thread.Sleep(5);
|
||||
}
|
||||
|
||||
Assert.True(done());
|
||||
}
|
||||
|
||||
[SkippableFact]
|
||||
public void Account_InTheGameServerState_PromotesBothBuffers()
|
||||
{
|
||||
Skip.If(NetState.InitialSendBufferSize == 0);
|
||||
RegisterNoOpPing();
|
||||
NetTestHelpers.RequirePreAuthBuffers();
|
||||
using var ping = NetTestHelpers.RegisterPing();
|
||||
var ns = PacketTestUtilities.CreateTestNetState(out var client);
|
||||
try
|
||||
{
|
||||
|
|
@ -73,8 +40,8 @@ public class NetStateSendBufferTests
|
|||
|
||||
// Recv promotes at the next completion
|
||||
ns._protocolState = NetState.ProtocolState.GameServer_LoggedIn;
|
||||
client.Send(new byte[] { 0x73, 0x01 });
|
||||
SliceUntil(() => ns._socket.RecvBuffer.PhysicalSize == NetState.RecvBufferSize);
|
||||
client.Send(new byte[] { NetTestHelpers.PingPacketId, 0x01 });
|
||||
NetTestHelpers.SliceUntil(() => ns._socket.RecvBuffer.PhysicalSize == NetState.RecvBufferSize);
|
||||
Assert.True(ns.Running);
|
||||
}
|
||||
finally
|
||||
|
|
@ -87,7 +54,7 @@ public class NetStateSendBufferTests
|
|||
[SkippableFact]
|
||||
public void Account_OnTheLoginServer_KeepsTheInitialBuffers()
|
||||
{
|
||||
Skip.If(NetState.InitialSendBufferSize == 0);
|
||||
NetTestHelpers.RequirePreAuthBuffers();
|
||||
var ns = PacketTestUtilities.CreateTestNetState(out var client);
|
||||
try
|
||||
{
|
||||
|
|
@ -108,11 +75,11 @@ public class NetStateSendBufferTests
|
|||
public void Send_BeyondTheInitialBuffer_BeforeCredentials_IsExhausted()
|
||||
{
|
||||
// Nothing promotes before credentials verify: the 4 KiB ring is the whole pre-auth budget
|
||||
Skip.If(NetState.InitialSendBufferSize == 0);
|
||||
NetTestHelpers.RequirePreAuthBuffers();
|
||||
var ns = PacketTestUtilities.CreateTestNetState(out var client);
|
||||
try
|
||||
{
|
||||
var data = Pattern(NetState.InitialSendBufferSize + 512, 7);
|
||||
var data = NetTestHelpers.Pattern(NetState.InitialSendBufferSize + 512, 7);
|
||||
ns.Send(data);
|
||||
|
||||
Assert.Contains("exhausted", ns._disconnectReason, StringComparison.OrdinalIgnoreCase);
|
||||
|
|
@ -123,7 +90,7 @@ public class NetStateSendBufferTests
|
|||
// Once it completes the NetState is disposed and _socket goes null, so nothing below
|
||||
// this point may touch it.
|
||||
client.Close();
|
||||
SliceUntil(() => !ns.Running);
|
||||
NetTestHelpers.SliceUntil(() => !ns.Running);
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
@ -137,19 +104,19 @@ public class NetStateSendBufferTests
|
|||
{
|
||||
// The late-verdict path from Account_AssignedAfterTheStateFlipped_StillPromotes: an account
|
||||
// attached while the setter's own gate does not fire must still let the send path promote
|
||||
Skip.If(NetState.InitialSendBufferSize == 0);
|
||||
NetTestHelpers.RequirePreAuthBuffers();
|
||||
var ns = PacketTestUtilities.CreateTestNetState(out var client);
|
||||
try
|
||||
{
|
||||
ns.Account = new MockAccount(); // _protocolState is still AwaitingSeed: the setter does not promote
|
||||
var data = Pattern(NetState.InitialSendBufferSize + 512, 7);
|
||||
var data = NetTestHelpers.Pattern(NetState.InitialSendBufferSize + 512, 7);
|
||||
ns.Send(data);
|
||||
|
||||
Assert.True(ns.Running);
|
||||
Assert.Equal(string.Empty, ns._disconnectReason);
|
||||
Assert.Equal(NetState.SendBufferSize, ns._socket.SendBuffer.PhysicalSize);
|
||||
Assert.False(ns._sendBufferGrown); // promotion is not growth: nothing to shrink later
|
||||
Assert.Equal(data, ReadAll(client, data.Length));
|
||||
Assert.Equal(data, NetTestHelpers.ReadAll(client, data.Length));
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
@ -161,12 +128,12 @@ public class NetStateSendBufferTests
|
|||
[SkippableFact]
|
||||
public void Send_BacklogBeforeCredentials_IsExhaustedInsteadOfPromoted()
|
||||
{
|
||||
Skip.If(NetState.InitialSendBufferSize == 0);
|
||||
NetTestHelpers.RequirePreAuthBuffers();
|
||||
var ns = PacketTestUtilities.CreateTestNetState(out var client);
|
||||
try
|
||||
{
|
||||
// No Slice() between sends: nothing drains, so a second write finds a non-empty initial buffer
|
||||
var half = Pattern(NetState.InitialSendBufferSize / 2, 11);
|
||||
var half = NetTestHelpers.Pattern(NetState.InitialSendBufferSize / 2, 11);
|
||||
ns.Send(half);
|
||||
ns.Send(half);
|
||||
ns.Send(half); // cannot fit, buffer not empty, no account: refused
|
||||
|
|
@ -179,7 +146,7 @@ public class NetStateSendBufferTests
|
|||
// Once it completes the NetState is disposed and _socket goes null, so nothing below
|
||||
// this point may touch it.
|
||||
client.Close();
|
||||
SliceUntil(() => !ns.Running);
|
||||
NetTestHelpers.SliceUntil(() => !ns.Running);
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
@ -191,7 +158,7 @@ public class NetStateSendBufferTests
|
|||
[SkippableFact]
|
||||
public void Account_AssignedAfterTheStateFlipped_StillPromotes()
|
||||
{
|
||||
Skip.If(NetState.InitialSendBufferSize == 0);
|
||||
NetTestHelpers.RequirePreAuthBuffers();
|
||||
var ns = PacketTestUtilities.CreateTestNetState(out var client);
|
||||
try
|
||||
{
|
||||
|
|
@ -211,7 +178,7 @@ public class NetStateSendBufferTests
|
|||
{
|
||||
var randomLength = compressedLength * 5 / 8;
|
||||
var data = new byte[compressedLength * 8];
|
||||
Pattern(randomLength, seed).CopyTo(data, 0);
|
||||
NetTestHelpers.Pattern(randomLength, seed).CopyTo(data, 0);
|
||||
|
||||
var scratch = new byte[compressedLength * 2 + 16];
|
||||
for (var length = randomLength; length < data.Length; length++)
|
||||
|
|
@ -228,47 +195,12 @@ public class NetStateSendBufferTests
|
|||
throw new InvalidOperationException($"No chunk compresses to exactly {compressedLength} bytes");
|
||||
}
|
||||
|
||||
private static byte[] ReadAll(Socket client, int length)
|
||||
{
|
||||
var received = new byte[length];
|
||||
var total = 0;
|
||||
var deadline = Stopwatch.StartNew();
|
||||
while (total < length && deadline.ElapsedMilliseconds < 10000)
|
||||
{
|
||||
NetState.Slice();
|
||||
|
||||
// Poll takes microseconds, not milliseconds
|
||||
if (client.Poll(50_000, SelectMode.SelectRead))
|
||||
{
|
||||
var read = client.Receive(received, total, length - total, SocketFlags.None);
|
||||
Assert.NotEqual(0, read);
|
||||
total += read;
|
||||
}
|
||||
}
|
||||
|
||||
Assert.Equal(length, total);
|
||||
return received;
|
||||
}
|
||||
|
||||
// Peer receipt does not free the buffer; the completion must land first
|
||||
private static void WaitForDrain(NetState ns)
|
||||
{
|
||||
var deadline = Stopwatch.StartNew();
|
||||
while (deadline.ElapsedMilliseconds < 10000)
|
||||
{
|
||||
NetState.Slice();
|
||||
|
||||
if (ns._socket.SendBuffer.ReadableBytes == 0 && ns._socket.SendBuffer.InFlightBytes == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
Thread.Sleep(5);
|
||||
}
|
||||
|
||||
Assert.Equal(0, ns._socket.SendBuffer.ReadableBytes);
|
||||
Assert.Equal(0, ns._socket.SendBuffer.InFlightBytes);
|
||||
}
|
||||
private static void WaitForDrain(NetState ns) =>
|
||||
NetTestHelpers.SliceUntil(
|
||||
() => ns._socket.SendBuffer.ReadableBytes == 0 && ns._socket.SendBuffer.InFlightBytes == 0,
|
||||
10000
|
||||
);
|
||||
|
||||
[Fact]
|
||||
public void Send_GrowsInsteadOfDisconnecting_AndStreamStaysIntact()
|
||||
|
|
@ -283,7 +215,7 @@ public class NetStateSendBufferTests
|
|||
var expected = new byte[chunk * 6];
|
||||
for (var i = 0; i < 6; i++)
|
||||
{
|
||||
var data = Pattern(chunk, i);
|
||||
var data = NetTestHelpers.Pattern(chunk, i);
|
||||
data.CopyTo(expected, i * chunk);
|
||||
ns.Send(data);
|
||||
}
|
||||
|
|
@ -293,7 +225,7 @@ public class NetStateSendBufferTests
|
|||
Assert.True(ns._socket.SendBuffer.PhysicalSize > baseSize);
|
||||
Assert.True(ns._sendBufferGrown);
|
||||
|
||||
Assert.Equal(expected, ReadAll(client, expected.Length));
|
||||
Assert.Equal(expected, NetTestHelpers.ReadAll(client, expected.Length));
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
@ -318,7 +250,7 @@ public class NetStateSendBufferTests
|
|||
var expectedLength = 0;
|
||||
for (var i = 0; i < 6; i++)
|
||||
{
|
||||
var data = Pattern(chunkLength, i + 100);
|
||||
var data = NetTestHelpers.Pattern(chunkLength, i + 100);
|
||||
var compressedLength = NetworkCompression.Compress(data, scratch);
|
||||
Assert.True(compressedLength > 0);
|
||||
scratch.AsSpan(0, compressedLength).CopyTo(expected.AsSpan(expectedLength));
|
||||
|
|
@ -332,7 +264,7 @@ public class NetStateSendBufferTests
|
|||
Assert.True(ns._sendBufferGrown);
|
||||
|
||||
Array.Resize(ref expected, expectedLength);
|
||||
Assert.Equal(expected, ReadAll(client, expected.Length));
|
||||
Assert.Equal(expected, NetTestHelpers.ReadAll(client, expected.Length));
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
@ -365,7 +297,7 @@ public class NetStateSendBufferTests
|
|||
while (ns._socket.SendBuffer.WritableBytes > 4096)
|
||||
{
|
||||
var writable = ns._socket.SendBuffer.WritableBytes;
|
||||
SendAndRecord(Pattern(Math.Min(baseSize / 8, (writable - 2048) * 8 / 11), seed++));
|
||||
SendAndRecord(NetTestHelpers.Pattern(Math.Min(baseSize / 8, (writable - 2048) * 8 / 11), seed++));
|
||||
}
|
||||
|
||||
// Full; no span to compress into
|
||||
|
|
@ -381,7 +313,7 @@ public class NetStateSendBufferTests
|
|||
Assert.Equal(baseSize * 2, ns._socket.SendBuffer.PhysicalSize);
|
||||
Assert.True(ns._sendBufferGrown);
|
||||
|
||||
Assert.Equal(expected.ToArray(), ReadAll(client, expected.Count));
|
||||
Assert.Equal(expected.ToArray(), NetTestHelpers.ReadAll(client, expected.Count));
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
@ -401,8 +333,8 @@ public class NetStateSendBufferTests
|
|||
// A small peer buffer keeps the first send in flight through the growth
|
||||
client.ReceiveBufferSize = 4096;
|
||||
|
||||
var first = Pattern(baseSize / 2, 300);
|
||||
var second = Pattern(baseSize / 2 + 1, 301);
|
||||
var first = NetTestHelpers.Pattern(baseSize / 2, 300);
|
||||
var second = NetTestHelpers.Pattern(baseSize / 2 + 1, 301);
|
||||
|
||||
ns.Send(first);
|
||||
NetState.Slice(); // posts the first send
|
||||
|
|
@ -419,7 +351,7 @@ public class NetStateSendBufferTests
|
|||
first.CopyTo(expected, 0);
|
||||
second.CopyTo(expected, first.Length);
|
||||
|
||||
Assert.Equal(expected, ReadAll(client, expected.Length));
|
||||
Assert.Equal(expected, NetTestHelpers.ReadAll(client, expected.Length));
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
@ -439,11 +371,11 @@ public class NetStateSendBufferTests
|
|||
var chunk = baseSize / 4;
|
||||
for (var i = 0; i < 6; i++)
|
||||
{
|
||||
ns.Send(Pattern(chunk, i));
|
||||
ns.Send(NetTestHelpers.Pattern(chunk, i));
|
||||
}
|
||||
|
||||
Assert.True(ns._sendBufferGrown);
|
||||
ReadAll(client, chunk * 6);
|
||||
NetTestHelpers.ReadAll(client, chunk * 6);
|
||||
WaitForDrain(ns);
|
||||
|
||||
var grewAt = ns._sendBufferGrewAt;
|
||||
|
|
@ -471,11 +403,11 @@ public class NetStateSendBufferTests
|
|||
var chunk = baseSize / 4;
|
||||
for (var i = 0; i < 6; i++)
|
||||
{
|
||||
ns.Send(Pattern(chunk, i + 400));
|
||||
ns.Send(NetTestHelpers.Pattern(chunk, i + 400));
|
||||
}
|
||||
|
||||
Assert.True(ns._sendBufferGrown);
|
||||
ReadAll(client, chunk * 6);
|
||||
NetTestHelpers.ReadAll(client, chunk * 6);
|
||||
WaitForDrain(ns);
|
||||
|
||||
// The sweep shrinks; nothing here calls TryShrinkSendBuffer
|
||||
|
|
@ -504,7 +436,7 @@ public class NetStateSendBufferTests
|
|||
var writes = NetState.MaxSendBufferSize / chunk + 1;
|
||||
for (var i = 0; i < writes; i++)
|
||||
{
|
||||
ns.Send(Pattern(chunk, i));
|
||||
ns.Send(NetTestHelpers.Pattern(chunk, i));
|
||||
}
|
||||
|
||||
Assert.Contains("Send buffer exhausted", ns._disconnectReason);
|
||||
|
|
@ -532,7 +464,7 @@ public class NetStateSendBufferTests
|
|||
|
||||
for (var i = 0; i < 6; i++)
|
||||
{
|
||||
ns.Send(Pattern(baseSize / 4, i));
|
||||
ns.Send(NetTestHelpers.Pattern(baseSize / 4, i));
|
||||
}
|
||||
|
||||
Assert.Equal(baseSize, ns._socket.SendBuffer.PhysicalSize);
|
||||
|
|
@ -558,7 +490,7 @@ public class NetStateSendBufferTests
|
|||
NetState.Slice(); // handoff
|
||||
|
||||
// CannotSendPackets short-circuits before any growth
|
||||
ns.Send(Pattern(baseSize * 2, 500));
|
||||
ns.Send(NetTestHelpers.Pattern(baseSize * 2, 500));
|
||||
|
||||
Assert.Equal(baseSize, ns._socket.SendBuffer.PhysicalSize);
|
||||
Assert.False(ns._sendBufferGrown);
|
||||
|
|
|
|||
|
|
@ -1,7 +1,5 @@
|
|||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Net;
|
||||
using Server.Accounting;
|
||||
using Server.Network;
|
||||
using Xunit;
|
||||
|
||||
|
|
@ -10,60 +8,6 @@ namespace Server.Tests.Network;
|
|||
[Collection("Sequential Server Tests")]
|
||||
public class AccountPacketTests
|
||||
{
|
||||
private class MockedAccount : IAccount
|
||||
{
|
||||
public int TotalGold { get; }
|
||||
public int TotalPlat { get; }
|
||||
public bool DepositGold(int amount) => throw new NotImplementedException();
|
||||
|
||||
public bool DepositPlat(int amount) => throw new NotImplementedException();
|
||||
|
||||
public bool WithdrawGold(int amount) => throw new NotImplementedException();
|
||||
|
||||
public bool WithdrawPlat(int amount) => throw new NotImplementedException();
|
||||
|
||||
public long GetTotalGold() => throw new NotImplementedException();
|
||||
|
||||
public int CompareTo(IAccount other) => throw new NotImplementedException();
|
||||
|
||||
public string Username { get; }
|
||||
public string Email { get; set; }
|
||||
public AccessLevel AccessLevel { get; set; }
|
||||
public int Length { get; }
|
||||
public int Limit { get; }
|
||||
public int Count { get; }
|
||||
|
||||
private Dictionary<int, Mobile> _mobiles = new();
|
||||
|
||||
public Mobile this[int index]
|
||||
{
|
||||
get => _mobiles[index];
|
||||
set
|
||||
{
|
||||
_mobiles[index] = value;
|
||||
if (value != null)
|
||||
{
|
||||
value.Account = this;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public DateTime Created { get; set; }
|
||||
public Serial Serial { get; }
|
||||
public void Deserialize(IGenericReader reader) => throw new NotImplementedException();
|
||||
|
||||
public void Serialize(IGenericWriter writer) => throw new NotImplementedException();
|
||||
|
||||
public bool Deleted { get; }
|
||||
|
||||
public void Delete() => throw new NotImplementedException();
|
||||
public bool TrySetUsername(string username) => throw new NotImplementedException();
|
||||
|
||||
public void SetPassword(string password) => throw new NotImplementedException();
|
||||
|
||||
public bool CheckPassword(string password) => throw new NotImplementedException();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestChangeCharacter()
|
||||
{
|
||||
|
|
@ -75,58 +19,38 @@ public class AccountPacketTests
|
|||
secondMobile.DefaultMobileInit();
|
||||
secondMobile.RawName = null;
|
||||
|
||||
var account = new MockedAccount
|
||||
var account = new MockAccount
|
||||
{
|
||||
[0] = firstMobile,
|
||||
[1] = null,
|
||||
[2] = secondMobile
|
||||
};
|
||||
|
||||
// var account = new MockAccount(new[] { firstMobile, null, secondMobile });
|
||||
var expected = new ChangeCharacter(account).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendChangeCharacter(account);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new ChangeCharacter(account), ns => ns.SendChangeCharacter(account));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestClientVersionReq()
|
||||
{
|
||||
var expected = new ClientVersionReq().Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
|
||||
ns.SendClientVersionRequest();
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new ClientVersionReq(), ns => ns.SendClientVersionRequest());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestDeleteResult()
|
||||
{
|
||||
var expected = new DeleteResult(DeleteResultType.BadRequest).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendCharacterDeleteResult(DeleteResultType.BadRequest);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new DeleteResult(DeleteResultType.BadRequest),
|
||||
ns => ns.SendCharacterDeleteResult(DeleteResultType.BadRequest)
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestPopupMessage()
|
||||
{
|
||||
var expected = new PopupMessage(PMMessage.LoginSyncError).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendPopupMessage(PMMessage.LoginSyncError);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new PopupMessage(PMMessage.LoginSyncError),
|
||||
ns => ns.SendPopupMessage(PMMessage.LoginSyncError)
|
||||
);
|
||||
}
|
||||
|
||||
[Theory, InlineData(ProtocolChanges.Version70610), InlineData(ProtocolChanges.Version6000)]
|
||||
|
|
@ -136,7 +60,7 @@ public class AccountPacketTests
|
|||
firstMobile.DefaultMobileInit();
|
||||
firstMobile.Name = "Test Mobile";
|
||||
|
||||
var account = new MockedAccount
|
||||
var account = new MockAccount
|
||||
{
|
||||
[0] = firstMobile,
|
||||
[1] = null,
|
||||
|
|
@ -168,25 +92,13 @@ public class AccountPacketTests
|
|||
m.Direction = Direction.Down;
|
||||
m.LogoutMap = Map.Felucca;
|
||||
|
||||
var expected = new LoginConfirm(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendLoginConfirmation(m);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new LoginConfirm(m), ns => ns.SendLoginConfirmation(m));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestLoginComplete()
|
||||
{
|
||||
var expected = new LoginComplete().Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendLoginComplete();
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new LoginComplete(), ns => ns.SendLoginComplete());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -196,7 +108,7 @@ public class AccountPacketTests
|
|||
firstMobile.DefaultMobileInit();
|
||||
firstMobile.RawName = "Test Mobile";
|
||||
|
||||
var account = new MockedAccount
|
||||
var account = new MockAccount
|
||||
{
|
||||
[0] = null,
|
||||
[1] = firstMobile,
|
||||
|
|
@ -205,13 +117,7 @@ public class AccountPacketTests
|
|||
[4] = null
|
||||
};
|
||||
|
||||
var expected = new CharacterListUpdate(account).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendCharacterListUpdate(account);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new CharacterListUpdate(account), ns => ns.SendCharacterListUpdate(account));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -221,7 +127,7 @@ public class AccountPacketTests
|
|||
firstMobile.DefaultMobileInit();
|
||||
firstMobile.Name = "Test Mobile";
|
||||
|
||||
var account = new MockedAccount
|
||||
var account = new MockAccount
|
||||
{
|
||||
[0] = null,
|
||||
[1] = firstMobile,
|
||||
|
|
@ -235,17 +141,16 @@ public class AccountPacketTests
|
|||
new CityInfo("Test City", "Test Building", 50, 100, 10, -10)
|
||||
};
|
||||
|
||||
var expected = new CharacterList(account, info).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.CityInfo = info;
|
||||
ns.Account = account;
|
||||
ns.ProtocolChanges = ProtocolChanges.Version70130;
|
||||
|
||||
ns.SendCharacterList();
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new CharacterList(account, info),
|
||||
ns =>
|
||||
{
|
||||
ns.CityInfo = info;
|
||||
ns.Account = account;
|
||||
ns.SendCharacterList();
|
||||
},
|
||||
ProtocolChanges.Version70130
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -255,7 +160,7 @@ public class AccountPacketTests
|
|||
firstMobile.DefaultMobileInit();
|
||||
firstMobile.Name = "Test Mobile";
|
||||
|
||||
var account = new MockedAccount
|
||||
var account = new MockAccount
|
||||
{
|
||||
[0] = null,
|
||||
[1] = firstMobile,
|
||||
|
|
@ -269,29 +174,23 @@ public class AccountPacketTests
|
|||
new CityInfo("Test City", "Test Building", 50, 100, 10, -10)
|
||||
};
|
||||
|
||||
var expected = new CharacterListOld(account, info).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.CityInfo = info;
|
||||
ns.Account = account;
|
||||
|
||||
ns.SendCharacterList();
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new CharacterListOld(account, info),
|
||||
ns =>
|
||||
{
|
||||
ns.CityInfo = info;
|
||||
ns.Account = account;
|
||||
ns.SendCharacterList();
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestAccountLoginRej()
|
||||
{
|
||||
var reason = ALRReason.BadComm;
|
||||
var expected = new AccountLoginRej(reason).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendAccountLoginRejected(reason);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new AccountLoginRej(reason), ns => ns.SendAccountLoginRejected(reason));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -302,15 +201,14 @@ public class AccountPacketTests
|
|||
new ServerInfo("Test Server", 0, TimeZoneInfo.Local, IPEndPoint.Parse("127.0.0.1"))
|
||||
};
|
||||
|
||||
var expected = new AccountLoginAck(info).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ServerInfo = info;
|
||||
|
||||
ns.SendAccountLoginAck();
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new AccountLoginAck(info),
|
||||
ns =>
|
||||
{
|
||||
ns.ServerInfo = info;
|
||||
ns.SendAccountLoginAck();
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -319,13 +217,6 @@ public class AccountPacketTests
|
|||
var si = new ServerInfo("Test Server", 0, TimeZoneInfo.Local, IPEndPoint.Parse("127.0.0.1"));
|
||||
const int authId = 0x123456;
|
||||
|
||||
var expected = new PlayServerAck(si, authId).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
|
||||
ns.SendPlayServerAck(si, authId);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new PlayServerAck(si, authId), ns => ns.SendPlayServerAck(si, authId));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,25 +12,13 @@ public class CombatPacketTests
|
|||
var attacker = (Serial)0x1024;
|
||||
var defender = (Serial)0x2048;
|
||||
|
||||
var expected = new Swing(attacker, defender).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendSwing(attacker, defender);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new Swing(attacker, defender), ns => ns.SendSwing(attacker, defender));
|
||||
}
|
||||
|
||||
[Theory, InlineData(true), InlineData(false)]
|
||||
public void TestSetWarMode(bool warmode)
|
||||
{
|
||||
var expected = new SetWarMode(warmode).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendSetWarMode(warmode);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new SetWarMode(warmode), ns => ns.SendSetWarMode(warmode));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -38,12 +26,6 @@ public class CombatPacketTests
|
|||
{
|
||||
var serial = (Serial)0x1024;
|
||||
|
||||
var expected = new ChangeCombatant(serial).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendChangeCombatant(serial);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new ChangeCombatant(serial), ns => ns.SendChangeCombatant(serial));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,13 +14,7 @@ public class ContainerPacketTests
|
|||
var serial = (Serial)0x1024;
|
||||
ushort gumpId = 100;
|
||||
|
||||
var expected = new ContainerDisplay(serial, gumpId).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendDisplayContainer(serial, gumpId);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new ContainerDisplay(serial, gumpId), ns => ns.SendDisplayContainer(serial, gumpId));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -29,14 +23,11 @@ public class ContainerPacketTests
|
|||
var serial = (Serial)0x1024;
|
||||
ushort gumpId = 100;
|
||||
|
||||
var expected = new ContainerDisplayHS(serial, gumpId).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges = ns.ProtocolChanges | ProtocolChanges.ContainerGridLines | ProtocolChanges.HighSeas;
|
||||
ns.SendDisplayContainer(serial, gumpId);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new ContainerDisplayHS(serial, gumpId),
|
||||
ns => ns.SendDisplayContainer(serial, gumpId),
|
||||
ProtocolChanges.ContainerGridLines | ProtocolChanges.HighSeas
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -44,13 +35,7 @@ public class ContainerPacketTests
|
|||
{
|
||||
var serial = (Serial)0x1024;
|
||||
|
||||
var expected = new DisplaySpellbook(serial).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendDisplaySpellbook(serial);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new DisplaySpellbook(serial), ns => ns.SendDisplaySpellbook(serial));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -58,14 +43,11 @@ public class ContainerPacketTests
|
|||
{
|
||||
var serial = (Serial)0x1024;
|
||||
|
||||
var expected = new DisplaySpellbookHS(serial).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges = ns.ProtocolChanges | ProtocolChanges.ContainerGridLines | ProtocolChanges.HighSeas;
|
||||
ns.SendDisplaySpellbook(serial);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new DisplaySpellbookHS(serial),
|
||||
ns => ns.SendDisplaySpellbook(serial),
|
||||
ProtocolChanges.ContainerGridLines | ProtocolChanges.HighSeas
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -76,17 +58,20 @@ public class ContainerPacketTests
|
|||
ushort offset = 10;
|
||||
ulong content = 0x123456789ABCDEF0;
|
||||
var opl = ObjectPropertyList.Enabled;
|
||||
|
||||
var expected = new NewSpellbookContent(serial, graphic, offset, content).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges = ns.ProtocolChanges | ProtocolChanges.ContainerGridLines | ProtocolChanges.NewSpellbook;
|
||||
ObjectPropertyList.Enabled = true;
|
||||
ns.SendSpellbookContent(serial, graphic, offset, content);
|
||||
ObjectPropertyList.Enabled = opl;
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
try
|
||||
{
|
||||
PacketAssert.Sends(
|
||||
new NewSpellbookContent(serial, graphic, offset, content),
|
||||
ns => ns.SendSpellbookContent(serial, graphic, offset, content),
|
||||
ProtocolChanges.ContainerGridLines | ProtocolChanges.NewSpellbook
|
||||
);
|
||||
}
|
||||
finally
|
||||
{
|
||||
ObjectPropertyList.Enabled = opl;
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -97,13 +82,10 @@ public class ContainerPacketTests
|
|||
ushort graphic = 100;
|
||||
ulong content = 0x123456789ABCDEF0;
|
||||
|
||||
var expected = new SpellbookContent(serial, offset, content).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendSpellbookContent(serial, graphic, offset, content);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new SpellbookContent(serial, offset, content),
|
||||
ns => ns.SendSpellbookContent(serial, graphic, offset, content)
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -114,14 +96,11 @@ public class ContainerPacketTests
|
|||
ushort graphic = 100;
|
||||
ulong content = 0x123456789ABCDEF0;
|
||||
|
||||
var expected = new SpellbookContent6017(serial, offset, content).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges |= ProtocolChanges.ContainerGridLines;
|
||||
ns.SendSpellbookContent(serial, graphic, offset, content);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new SpellbookContent6017(serial, offset, content),
|
||||
ns => ns.SendSpellbookContent(serial, graphic, offset, content),
|
||||
ProtocolChanges.ContainerGridLines
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -130,13 +109,7 @@ public class ContainerPacketTests
|
|||
var serial = (Serial)0x1024;
|
||||
var item = new Item(serial);
|
||||
|
||||
var expected = new ContainerContentUpdate(item).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendContainerContentUpdate(item);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new ContainerContentUpdate(item), ns => ns.SendContainerContentUpdate(item));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -145,66 +118,17 @@ public class ContainerPacketTests
|
|||
var serial = (Serial)0x1024;
|
||||
var item = new Item(serial);
|
||||
|
||||
var expected = new ContainerContentUpdate6017(item).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges |= ProtocolChanges.ContainerGridLines;
|
||||
ns.SendContainerContentUpdate(item);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new ContainerContentUpdate6017(item),
|
||||
ns => ns.SendContainerContentUpdate(item),
|
||||
ProtocolChanges.ContainerGridLines
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestContainerContent()
|
||||
// An administrator beholder on the container's map, so every item is visible and sent.
|
||||
private static (Container Container, Mobile Beholder) CreateViewedContainer(int itemCount)
|
||||
{
|
||||
var cont = new Container(World.NewItem);
|
||||
cont.AddItem(new Item(World.NewItem));
|
||||
cont.Map = Map.Felucca;
|
||||
|
||||
var m = new Mobile((Serial)0x1);
|
||||
m.DefaultMobileInit();
|
||||
m.AccessLevel = AccessLevel.Administrator;
|
||||
m.Map = Map.Felucca;
|
||||
|
||||
var expected = new ContainerContent(m, cont).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendContainerContent(m, cont);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestContainerContent6017()
|
||||
{
|
||||
var cont = new Container(World.NewItem);
|
||||
cont.AddItem(new Item(World.NewItem));
|
||||
cont.Map = Map.Felucca;
|
||||
|
||||
var m = new Mobile((Serial)0x1);
|
||||
m.DefaultMobileInit();
|
||||
m.AccessLevel = AccessLevel.Administrator;
|
||||
m.Map = Map.Felucca;
|
||||
|
||||
var expected = new ContainerContent6017(m, cont).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges |= ProtocolChanges.ContainerGridLines;
|
||||
ns.SendContainerContent(m, cont);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestContainerContent_CapsAtProtocolLimit()
|
||||
{
|
||||
var cont = new Container(World.NewItem);
|
||||
|
||||
// Past the 3448-entry cap (19-byte entries) so truncation engages.
|
||||
const int itemCount = 5000;
|
||||
for (var i = 0; i < itemCount; i++)
|
||||
{
|
||||
cont.AddItem(new Item(World.NewItem));
|
||||
|
|
@ -217,9 +141,62 @@ public class ContainerPacketTests
|
|||
m.AccessLevel = AccessLevel.Administrator;
|
||||
m.Map = Map.Felucca;
|
||||
|
||||
return (cont, m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestContainerContent()
|
||||
{
|
||||
var (cont, m) = CreateViewedContainer(1);
|
||||
|
||||
try
|
||||
{
|
||||
PacketAssert.Sends(new ContainerContent(m, cont), ns => ns.SendContainerContent(m, cont));
|
||||
}
|
||||
finally
|
||||
{
|
||||
cont.Delete();
|
||||
m.Delete();
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestContainerContent6017()
|
||||
{
|
||||
var (cont, m) = CreateViewedContainer(1);
|
||||
|
||||
try
|
||||
{
|
||||
PacketAssert.Sends(
|
||||
new ContainerContent6017(m, cont),
|
||||
ns => ns.SendContainerContent(m, cont),
|
||||
ProtocolChanges.ContainerGridLines
|
||||
);
|
||||
}
|
||||
finally
|
||||
{
|
||||
cont.Delete();
|
||||
m.Delete();
|
||||
}
|
||||
}
|
||||
|
||||
// 0x3C's length and count fields are 16-bit: 19-byte entries cap at 3448, 20-byte grid-line entries at 3276.
|
||||
[Theory]
|
||||
[InlineData(false, 3448, 65517)]
|
||||
[InlineData(true, 3276, 65525)]
|
||||
public void TestContainerContent_CapsAtProtocolLimit(bool gridLines, int maxEntries, int maxLength)
|
||||
{
|
||||
// One item past the cap is enough to make truncation engage.
|
||||
var (cont, m) = CreateViewedContainer(maxEntries + 1);
|
||||
|
||||
try
|
||||
{
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
if (gridLines)
|
||||
{
|
||||
ns.ProtocolChanges |= ProtocolChanges.ContainerGridLines;
|
||||
}
|
||||
|
||||
// A ~64KB packet exceeds the 4KB pre-auth send buffer; an account lets Send() promote it
|
||||
// on demand instead of exhausting the buffer and disconnecting.
|
||||
ns.Account = new MockAccount();
|
||||
|
|
@ -233,57 +210,9 @@ public class ContainerPacketTests
|
|||
var length = BinaryPrimitives.ReadUInt16BigEndian(span[1..3]);
|
||||
var count = BinaryPrimitives.ReadUInt16BigEndian(span[3..5]);
|
||||
|
||||
const int entrySize = 19; // no grid lines negotiated on this NetState
|
||||
var expectedMaxEntries = (ushort.MaxValue - 5) / entrySize;
|
||||
|
||||
Assert.Equal(65517, length);
|
||||
Assert.Equal(maxLength, length);
|
||||
Assert.Equal(length, span.Length);
|
||||
Assert.Equal(expectedMaxEntries, count);
|
||||
}
|
||||
finally
|
||||
{
|
||||
cont.Delete();
|
||||
m.Delete();
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestContainerContent_CapsAtProtocolLimit_WithGridLines()
|
||||
{
|
||||
var cont = new Container(World.NewItem);
|
||||
|
||||
// Past the 3276-entry cap (20-byte entries with grid lines) so truncation engages.
|
||||
const int itemCount = 5000;
|
||||
for (var i = 0; i < itemCount; i++)
|
||||
{
|
||||
cont.AddItem(new Item(World.NewItem));
|
||||
}
|
||||
|
||||
cont.Map = Map.Felucca;
|
||||
|
||||
var m = new Mobile((Serial)0x1);
|
||||
m.DefaultMobileInit();
|
||||
m.AccessLevel = AccessLevel.Administrator;
|
||||
m.Map = Map.Felucca;
|
||||
|
||||
try
|
||||
{
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges |= ProtocolChanges.ContainerGridLines;
|
||||
ns.Account = new MockAccount();
|
||||
|
||||
var ex = Record.Exception(() => ns.SendContainerContent(m, cont));
|
||||
Assert.Null(ex);
|
||||
|
||||
var span = ns.SendBuffer.GetReadSpan();
|
||||
Assert.Equal((byte)0x3C, span[0]);
|
||||
|
||||
var length = BinaryPrimitives.ReadUInt16BigEndian(span[1..3]);
|
||||
var count = BinaryPrimitives.ReadUInt16BigEndian(span[3..5]);
|
||||
|
||||
Assert.Equal(65525, length);
|
||||
Assert.Equal(length, span.Length);
|
||||
Assert.Equal(3276, count);
|
||||
Assert.Equal(maxEntries, count);
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
@ -295,32 +224,13 @@ public class ContainerPacketTests
|
|||
[Fact]
|
||||
public void TestContainerContent_RentedBuffer_MatchesReferencePacket()
|
||||
{
|
||||
var cont = new Container(World.NewItem);
|
||||
|
||||
// Below the entry cap but past the 1024-byte stackalloc threshold, so SendContainerContent
|
||||
// rents its buffer instead of using the stack.
|
||||
const int itemCount = 100;
|
||||
for (var i = 0; i < itemCount; i++)
|
||||
{
|
||||
cont.AddItem(new Item(World.NewItem));
|
||||
}
|
||||
|
||||
cont.Map = Map.Felucca;
|
||||
|
||||
var m = new Mobile((Serial)0x1);
|
||||
m.DefaultMobileInit();
|
||||
m.AccessLevel = AccessLevel.Administrator;
|
||||
m.Map = Map.Felucca;
|
||||
var (cont, m) = CreateViewedContainer(100);
|
||||
|
||||
try
|
||||
{
|
||||
var expected = new ContainerContent(m, cont).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendContainerContent(m, cont);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new ContainerContent(m, cont), ns => ns.SendContainerContent(m, cont));
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
|
|||
|
|
@ -11,13 +11,7 @@ public class DamagePacketTests
|
|||
{
|
||||
var serial = (Serial)0x1024;
|
||||
|
||||
var expected = new DamagePacketOld(serial, inputAmount).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendDamage(serial, inputAmount);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new DamagePacketOld(serial, inputAmount), ns => ns.SendDamage(serial, inputAmount));
|
||||
}
|
||||
|
||||
[Theory, InlineData(10), InlineData(-5), InlineData(1024), InlineData(100000)]
|
||||
|
|
@ -25,14 +19,10 @@ public class DamagePacketTests
|
|||
{
|
||||
var serial = (Serial)0x1024;
|
||||
|
||||
var expected = new DamagePacket(serial, inputAmount).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges = ProtocolChanges.DamagePacket;
|
||||
|
||||
ns.SendDamage(serial, inputAmount);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new DamagePacket(serial, inputAmount),
|
||||
ns => ns.SendDamage(serial, inputAmount),
|
||||
ProtocolChanges.DamagePacket
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,18 +7,13 @@ namespace Server.Tests.Network;
|
|||
[Collection("Sequential Server Tests")]
|
||||
public class EffectPackets
|
||||
{
|
||||
[Theory, InlineData(10, 1000, 10, 5)]
|
||||
public void TestSoundEffect(ushort soundID, int x, int y, int z)
|
||||
[Fact]
|
||||
public void TestSoundEffect()
|
||||
{
|
||||
var p = new Point3D(x, y, z);
|
||||
const ushort soundID = 10;
|
||||
var p = new Point3D(1000, 10, 5);
|
||||
|
||||
var expected = new PlaySound(soundID, p).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendSoundEffect(soundID, p);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new PlaySound(soundID, p), ns => ns.SendSoundEffect(soundID, p));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -94,13 +89,7 @@ public class EffectPackets
|
|||
[Theory, InlineData(ScreenEffectType.DarkFlash), InlineData(ScreenEffectType.FadeInOut)]
|
||||
public void TestScreenEffect(ScreenEffectType screenType)
|
||||
{
|
||||
var expected = new ScreenEffect(screenType).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendScreenEffect(screenType);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new ScreenEffect(screenType), ns => ns.SendScreenEffect(screenType));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
|
|||
|
|
@ -76,157 +76,6 @@ public class HuedEffect : Packet
|
|||
}
|
||||
}
|
||||
|
||||
public sealed class TargetParticleEffect : ParticleEffect
|
||||
{
|
||||
public TargetParticleEffect(
|
||||
IEntity e, int itemID, int speed, int duration, int hue, int renderMode, int effect,
|
||||
int layer, int unknown
|
||||
) : base(
|
||||
EffectType.FixedFrom,
|
||||
e.Serial,
|
||||
Serial.Zero,
|
||||
itemID,
|
||||
e.Location,
|
||||
e.Location,
|
||||
speed,
|
||||
duration,
|
||||
true,
|
||||
false,
|
||||
hue,
|
||||
renderMode,
|
||||
effect,
|
||||
1,
|
||||
0,
|
||||
e.Serial,
|
||||
layer,
|
||||
unknown
|
||||
)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
public sealed class TargetEffect : HuedEffect
|
||||
{
|
||||
public TargetEffect(IEntity e, int itemID, int speed, int duration, int hue, int renderMode) : base(
|
||||
EffectType.FixedFrom,
|
||||
e.Serial,
|
||||
Serial.Zero,
|
||||
itemID,
|
||||
e.Location,
|
||||
e.Location,
|
||||
speed,
|
||||
duration,
|
||||
true,
|
||||
false,
|
||||
hue,
|
||||
renderMode
|
||||
)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
public sealed class LocationParticleEffect : ParticleEffect
|
||||
{
|
||||
public LocationParticleEffect(
|
||||
IEntity e, int itemID, int speed, int duration, int hue, int renderMode, int effect,
|
||||
int unknown
|
||||
) : base(
|
||||
EffectType.FixedXYZ,
|
||||
e.Serial,
|
||||
Serial.Zero,
|
||||
itemID,
|
||||
e.Location,
|
||||
e.Location,
|
||||
speed,
|
||||
duration,
|
||||
true,
|
||||
false,
|
||||
hue,
|
||||
renderMode,
|
||||
effect,
|
||||
1,
|
||||
0,
|
||||
e.Serial,
|
||||
255,
|
||||
unknown
|
||||
)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
public sealed class LocationEffect : HuedEffect
|
||||
{
|
||||
public LocationEffect(IPoint3D p, int itemID, int speed, int duration, int hue, int renderMode) : base(
|
||||
EffectType.FixedXYZ,
|
||||
Serial.Zero,
|
||||
Serial.Zero,
|
||||
itemID,
|
||||
p,
|
||||
p,
|
||||
speed,
|
||||
duration,
|
||||
true,
|
||||
false,
|
||||
hue,
|
||||
renderMode
|
||||
)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
public sealed class MovingParticleEffect : ParticleEffect
|
||||
{
|
||||
public MovingParticleEffect(
|
||||
IEntity from, IEntity to, int itemID, int speed, int duration, bool fixedDirection,
|
||||
bool explodes, int hue, int renderMode, int effect, int explodeEffect, int explodeSound, EffectLayer layer,
|
||||
int unknown
|
||||
) : base(
|
||||
EffectType.Moving,
|
||||
from.Serial,
|
||||
to.Serial,
|
||||
itemID,
|
||||
from.Location,
|
||||
to.Location,
|
||||
speed,
|
||||
duration,
|
||||
fixedDirection,
|
||||
explodes,
|
||||
hue,
|
||||
renderMode,
|
||||
effect,
|
||||
explodeEffect,
|
||||
explodeSound,
|
||||
Serial.Zero,
|
||||
(int)layer,
|
||||
unknown
|
||||
)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
public sealed class MovingEffect : HuedEffect
|
||||
{
|
||||
public MovingEffect(
|
||||
IEntity from, IEntity to, int itemID, int speed, int duration, bool fixedDirection,
|
||||
bool explodes, int hue, int renderMode
|
||||
) : base(
|
||||
EffectType.Moving,
|
||||
from.Serial,
|
||||
to.Serial,
|
||||
itemID,
|
||||
from.Location,
|
||||
to.Location,
|
||||
speed,
|
||||
duration,
|
||||
fixedDirection,
|
||||
explodes,
|
||||
hue,
|
||||
renderMode
|
||||
)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
public class ScreenEffect : Packet
|
||||
{
|
||||
public ScreenEffect(ScreenEffectType type)
|
||||
|
|
|
|||
|
|
@ -31,19 +31,16 @@ public class EquipmentPacketTests
|
|||
}
|
||||
);
|
||||
|
||||
var expected = new DisplayEquipmentInfo(item, info).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendDisplayEquipmentInfo(
|
||||
item.Serial,
|
||||
info.Number,
|
||||
info.Crafter?.RawName,
|
||||
info.Unidentified,
|
||||
new List<EquipInfoAttribute>(info.Attributes)
|
||||
PacketAssert.Sends(
|
||||
new DisplayEquipmentInfo(item, info),
|
||||
ns => ns.SendDisplayEquipmentInfo(
|
||||
item.Serial,
|
||||
info.Number,
|
||||
info.Crafter?.RawName,
|
||||
info.Unidentified,
|
||||
new List<EquipInfoAttribute>(info.Attributes)
|
||||
)
|
||||
);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -54,12 +51,6 @@ public class EquipmentPacketTests
|
|||
|
||||
var item = new Item(World.NewItem) { Parent = m };
|
||||
|
||||
var expected = new EquipUpdate(item).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendEquipUpdate(item);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new EquipUpdate(item), ns => ns.SendEquipUpdate(item));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,17 +6,13 @@ namespace Server.Tests.Network;
|
|||
[Collection("Sequential Server Tests")]
|
||||
public class GumpPacketTests
|
||||
{
|
||||
[Theory]
|
||||
[InlineData(100, 10)]
|
||||
public void TestCloseGump(int typeId, int buttonId)
|
||||
[Fact]
|
||||
public void TestCloseGump()
|
||||
{
|
||||
var expected = new CloseGump(typeId, buttonId).Compile();
|
||||
const int typeId = 100;
|
||||
const int buttonId = 10;
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendCloseGump(typeId, buttonId);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new CloseGump(typeId, buttonId), ns => ns.SendCloseGump(typeId, buttonId));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -27,13 +23,10 @@ public class GumpPacketTests
|
|||
const string unknownString = "This is an unknown string";
|
||||
const string caption = "This is a caption";
|
||||
|
||||
var expected = new DisplaySignGump(gumpSerial, gumpId, unknownString, caption).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendDisplaySignGump(gumpSerial, gumpId, unknownString, caption);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new DisplaySignGump(gumpSerial, gumpId, unknownString, caption),
|
||||
ns => ns.SendDisplaySignGump(gumpSerial, gumpId, unknownString, caption)
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -41,13 +34,7 @@ public class GumpPacketTests
|
|||
{
|
||||
var gump = new NameChangeDeedGump();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
|
||||
var expected = gump.Compile(ns).Compile();
|
||||
ns.SendGump(gump);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(ns => gump.Compile(ns), ns => ns.SendGump(gump));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -60,13 +47,7 @@ public class GumpPacketTests
|
|||
|
||||
var gump = new AdminGump(m, AdminGumpPage.Clients);
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
|
||||
var expected = gump.Compile(ns).Compile();
|
||||
ns.SendGump(gump);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(ns => gump.Compile(ns), ns => ns.SendGump(gump));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,116 +1,75 @@
|
|||
using System;
|
||||
using Server.Network;
|
||||
using Xunit;
|
||||
|
||||
namespace Server.Tests.Network;
|
||||
|
||||
[Collection("Sequential Server Tests")]
|
||||
public class ItemPacketTests
|
||||
public class ItemPacketTests : IDisposable
|
||||
{
|
||||
private const int TestItemId = 1;
|
||||
|
||||
// TileData is global and holds real client data when client files are loaded, so each test restores it.
|
||||
private readonly ItemData _originalItemData;
|
||||
|
||||
public ItemPacketTests()
|
||||
{
|
||||
_originalItemData = TileData.ItemTable[TestItemId];
|
||||
TileData.ItemTable[TestItemId] = new ItemData("Test Item Data", TileFlag.Generic, 1, 1, 1, 1, 1, 1);
|
||||
}
|
||||
|
||||
public void Dispose() => TileData.ItemTable[TestItemId] = _originalItemData;
|
||||
|
||||
[Fact]
|
||||
public void TestWorldItemPacket()
|
||||
{
|
||||
var serial = (Serial)0x1024;
|
||||
var itemId = 1;
|
||||
|
||||
// Move to fixture
|
||||
TileData.ItemTable[itemId] = new ItemData(
|
||||
"Test Item Data",
|
||||
TileFlag.Generic,
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
1
|
||||
);
|
||||
|
||||
var item = new Item(serial)
|
||||
{
|
||||
ItemID = itemId,
|
||||
ItemID = TestItemId,
|
||||
Hue = 0x1024,
|
||||
Amount = 10,
|
||||
Location = new Point3D(1000, 100, -10),
|
||||
Direction = Direction.Left
|
||||
};
|
||||
|
||||
var expected = new WorldItem(item).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendWorldItem(item);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new WorldItem(item), ns => ns.SendWorldItem(item));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestWorldItemSAPacket()
|
||||
{
|
||||
var serial = (Serial)0x1024;
|
||||
ushort itemId = 1;
|
||||
|
||||
// Move to fixture
|
||||
TileData.ItemTable[itemId] = new ItemData(
|
||||
"Test Item Data",
|
||||
TileFlag.Generic,
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
1
|
||||
);
|
||||
|
||||
var item = new Item(serial)
|
||||
{
|
||||
ItemID = itemId,
|
||||
ItemID = TestItemId,
|
||||
Hue = 0x1024,
|
||||
Amount = 10,
|
||||
Location = new Point3D(1000, 100, -10)
|
||||
};
|
||||
|
||||
var expected = new WorldItemSA(item).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges = ProtocolChanges.StygianAbyss;
|
||||
ns.SendWorldItem(item);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new WorldItemSA(item), ns => ns.SendWorldItem(item), ProtocolChanges.StygianAbyss);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestWorldItemHSPacket()
|
||||
{
|
||||
var serial = (Serial)0x1024;
|
||||
var itemId = 1;
|
||||
|
||||
// Move to fixture
|
||||
TileData.ItemTable[itemId] = new ItemData(
|
||||
"Test Item Data",
|
||||
TileFlag.Generic,
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
1,
|
||||
1
|
||||
);
|
||||
|
||||
var item = new Item(serial)
|
||||
{
|
||||
ItemID = itemId,
|
||||
ItemID = TestItemId,
|
||||
Hue = 0x1024,
|
||||
Amount = 10,
|
||||
Location = new Point3D(1000, 100, -10)
|
||||
};
|
||||
|
||||
var expected = new WorldItemHS(item).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges = ProtocolChanges.StygianAbyss | ProtocolChanges.HighSeas;
|
||||
ns.SendWorldItem(item);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new WorldItemHS(item),
|
||||
ns => ns.SendWorldItem(item),
|
||||
ProtocolChanges.StygianAbyss | ProtocolChanges.HighSeas
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -187,21 +187,3 @@ public sealed class WorldItemHS : Packet
|
|||
Stream.Write((short)0x00); // ??
|
||||
}
|
||||
}
|
||||
|
||||
public sealed class OPLInfo : Packet
|
||||
{
|
||||
/*public OPLInfo( ObjectPropertyList list ) : base( 0xBF )
|
||||
{
|
||||
EnsureCapacity( 13 );
|
||||
|
||||
m_Stream.Write( (short) 0x10 );
|
||||
m_Stream.Write( (int) list.Entity.Serial );
|
||||
m_Stream.Write( (int) list.Hash );
|
||||
}*/
|
||||
|
||||
public OPLInfo(Serial serial, int hash) : base(0xDC, 9)
|
||||
{
|
||||
Stream.Write(serial);
|
||||
Stream.Write(hash);
|
||||
}
|
||||
}
|
||||
|
|
@ -10,13 +10,8 @@ public class LightPacketTests
|
|||
public void TestGlobalLightLevel()
|
||||
{
|
||||
const byte lightLevel = 5;
|
||||
var expected = new GlobalLightLevel(lightLevel).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendGlobalLightLevel(lightLevel);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new GlobalLightLevel(lightLevel), ns => ns.SendGlobalLightLevel(lightLevel));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -24,12 +19,10 @@ public class LightPacketTests
|
|||
{
|
||||
var serial = (Serial)0x1024;
|
||||
byte lightLevel = 5;
|
||||
var expected = new PersonalLightLevel(serial, lightLevel).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendPersonalLightLevel(serial, lightLevel);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new PersonalLightLevel(serial, lightLevel),
|
||||
ns => ns.SendPersonalLightLevel(serial, lightLevel)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,26 +9,13 @@ public class MapPatchesTests
|
|||
[Fact]
|
||||
public void TestMapPatches()
|
||||
{
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
|
||||
var expected = new MapPatches().Compile();
|
||||
|
||||
ns.SendMapPatches();
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MapPatches(), ns => ns.SendMapPatches());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestInvalidMapEnable()
|
||||
{
|
||||
var expected = new InvalidMapEnable().Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendInvalidMap();
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new InvalidMapEnable(), ns => ns.SendInvalidMap());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -37,12 +24,7 @@ public class MapPatchesTests
|
|||
public void TestMapChange(string mapName)
|
||||
{
|
||||
var map = Map.Parse(mapName);
|
||||
var expected = new MapChange(map).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMapChange(map);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MapChange(map), ns => ns.SendMapChange(map));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -42,13 +42,7 @@ public class MenuPacketTests
|
|||
]
|
||||
);
|
||||
|
||||
var expected = new DisplayItemListMenu(menu).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendDisplayItemListMenu(menu);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new DisplayItemListMenu(menu), ns => ns.SendDisplayItemListMenu(menu));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -63,12 +57,7 @@ public class MenuPacketTests
|
|||
]
|
||||
);
|
||||
|
||||
var expected = new DisplayQuestionMenu(menu).Compile();
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendDisplayQuestionMenu(menu);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new DisplayQuestionMenu(menu), ns => ns.SendDisplayQuestionMenu(menu));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -84,18 +73,12 @@ public class MenuPacketTests
|
|||
var item = new ContextMenuItem(World.NewItem, newPacket);
|
||||
var menu = ContextMenuSystem.CreateContextMenu(m, item);
|
||||
|
||||
var packet = newHaven && newPacket ? (Packet)new DisplayContextMenu(menu) : new DisplayContextMenuOld(menu);
|
||||
var expected = packet.Compile();
|
||||
var expected = newHaven && newPacket ? (Packet)new DisplayContextMenu(menu) : new DisplayContextMenuOld(menu);
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
if (newHaven)
|
||||
{
|
||||
ns.ProtocolChanges |= ProtocolChanges.NewHaven;
|
||||
}
|
||||
|
||||
ns.SendDisplayContextMenu(menu);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
expected,
|
||||
ns => ns.SendDisplayContextMenu(menu),
|
||||
newHaven ? ProtocolChanges.NewHaven : ProtocolChanges.None
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,31 +19,10 @@ public class MessageTests
|
|||
var name = "Stuff";
|
||||
var args = "Arguments";
|
||||
|
||||
var expected = new MessageLocalized(
|
||||
serial,
|
||||
graphic,
|
||||
messageType,
|
||||
hue,
|
||||
font,
|
||||
number,
|
||||
name,
|
||||
args
|
||||
).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMessageLocalized(
|
||||
serial,
|
||||
graphic,
|
||||
messageType,
|
||||
hue,
|
||||
font,
|
||||
number,
|
||||
name,
|
||||
args
|
||||
PacketAssert.Sends(
|
||||
new MessageLocalized(serial, graphic, messageType, hue, font, number, name, args),
|
||||
ns => ns.SendMessageLocalized(serial, graphic, messageType, hue, font, number, name, args)
|
||||
);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -58,15 +37,10 @@ public class MessageTests
|
|||
var name = "Stuff";
|
||||
var argValue = 42;
|
||||
|
||||
var expected = new MessageLocalized(
|
||||
serial, graphic, messageType, hue, font, number, name, $"value: {argValue}"
|
||||
).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMessageLocalized(serial, graphic, messageType, hue, font, number, name, $"value: {argValue}");
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new MessageLocalized(serial, graphic, messageType, hue, font, number, name, $"value: {argValue}"),
|
||||
ns => ns.SendMessageLocalized(serial, graphic, messageType, hue, font, number, name, $"value: {argValue}")
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -83,35 +57,12 @@ public class MessageTests
|
|||
var affixType = AffixType.System;
|
||||
var affix = "Affix";
|
||||
|
||||
var expected = new MessageLocalizedAffix(
|
||||
serial,
|
||||
graphic,
|
||||
messageType,
|
||||
hue,
|
||||
font,
|
||||
number,
|
||||
name,
|
||||
affixType,
|
||||
affix,
|
||||
args
|
||||
).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMessageLocalizedAffix(
|
||||
serial,
|
||||
graphic,
|
||||
messageType,
|
||||
hue,
|
||||
font,
|
||||
number,
|
||||
name,
|
||||
affixType,
|
||||
affix,
|
||||
args
|
||||
PacketAssert.Sends(
|
||||
new MessageLocalizedAffix(serial, graphic, messageType, hue, font, number, name, affixType, affix, args),
|
||||
ns => ns.SendMessageLocalizedAffix(
|
||||
serial, graphic, messageType, hue, font, number, name, affixType, affix, args
|
||||
)
|
||||
);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -128,18 +79,14 @@ public class MessageTests
|
|||
var affix = "Affix";
|
||||
var argValue = 42;
|
||||
|
||||
var expected = new MessageLocalizedAffix(
|
||||
serial, graphic, messageType, hue, font, number, name, affixType, affix, $"value: {argValue}"
|
||||
).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMessageLocalizedAffix(
|
||||
serial, graphic, messageType, hue, font, number, name, affixType, affix,
|
||||
$"value: {argValue}"
|
||||
PacketAssert.Sends(
|
||||
new MessageLocalizedAffix(
|
||||
serial, graphic, messageType, hue, font, number, name, affixType, affix, $"value: {argValue}"
|
||||
),
|
||||
ns => ns.SendMessageLocalizedAffix(
|
||||
serial, graphic, messageType, hue, font, number, name, affixType, affix, $"value: {argValue}"
|
||||
)
|
||||
);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -154,17 +101,10 @@ public class MessageTests
|
|||
var name = "Stuff";
|
||||
var who = "Alice";
|
||||
|
||||
var expected = new UnicodeMessage(
|
||||
serial, graphic, messageType, hue, font, lang, name, $"hello, {who}"
|
||||
).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMessage(
|
||||
serial, graphic, messageType, hue, font, false, lang, name, $"hello, {who}"
|
||||
PacketAssert.Sends(
|
||||
new UnicodeMessage(serial, graphic, messageType, hue, font, lang, name, $"hello, {who}"),
|
||||
ns => ns.SendMessage(serial, graphic, messageType, hue, font, false, lang, name, $"hello, {who}")
|
||||
);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -178,31 +118,10 @@ public class MessageTests
|
|||
var name = "Stuff";
|
||||
var text = "Some Text";
|
||||
|
||||
var expected = new AsciiMessage(
|
||||
serial,
|
||||
graphic,
|
||||
messageType,
|
||||
hue,
|
||||
font,
|
||||
name,
|
||||
text
|
||||
).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMessage(
|
||||
serial,
|
||||
graphic,
|
||||
messageType,
|
||||
hue,
|
||||
font,
|
||||
true,
|
||||
null,
|
||||
name,
|
||||
text
|
||||
PacketAssert.Sends(
|
||||
new AsciiMessage(serial, graphic, messageType, hue, font, name, text),
|
||||
ns => ns.SendMessage(serial, graphic, messageType, hue, font, true, null, name, text)
|
||||
);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -217,32 +136,10 @@ public class MessageTests
|
|||
var name = "Stuff";
|
||||
var text = "Some Text";
|
||||
|
||||
var expected = new UnicodeMessage(
|
||||
serial,
|
||||
graphic,
|
||||
messageType,
|
||||
hue,
|
||||
font,
|
||||
lang,
|
||||
name,
|
||||
text
|
||||
).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMessage(
|
||||
serial,
|
||||
graphic,
|
||||
messageType,
|
||||
hue,
|
||||
font,
|
||||
false,
|
||||
lang,
|
||||
name,
|
||||
text
|
||||
PacketAssert.Sends(
|
||||
new UnicodeMessage(serial, graphic, messageType, hue, font, lang, name, text),
|
||||
ns => ns.SendMessage(serial, graphic, messageType, hue, font, false, lang, name, text)
|
||||
);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -251,13 +148,7 @@ public class MessageTests
|
|||
var serial = (Serial)0x1024;
|
||||
var serial2 = (Serial)0x2;
|
||||
|
||||
var expected = new FollowMessage(serial, serial2).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendFollowMessage(serial, serial2);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new FollowMessage(serial, serial2), ns => ns.SendFollowMessage(serial, serial2));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -266,33 +157,18 @@ public class MessageTests
|
|||
var s = (Serial)0x100;
|
||||
var text = "This is some testing text";
|
||||
|
||||
var expected = new ObjectHelpResponse(s, text).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendHelpResponse(s, text);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new ObjectHelpResponse(s, text), ns => ns.SendHelpResponse(s, text));
|
||||
}
|
||||
|
||||
internal class TestPrompt : Prompt
|
||||
[Fact]
|
||||
public void TestUnicodePrompt()
|
||||
{
|
||||
var prompt = new TestPrompt();
|
||||
|
||||
PacketAssert.Sends(new UnicodePrompt(prompt), ns => ns.SendPrompt(prompt));
|
||||
}
|
||||
|
||||
[Collection("Sequential Server Tests")]
|
||||
public class UnicodePromptTests
|
||||
private class TestPrompt : Prompt
|
||||
{
|
||||
[Fact]
|
||||
public void TestUnicodePrompt()
|
||||
{
|
||||
var prompt = new TestPrompt();
|
||||
var expected = new UnicodePrompt(prompt).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendPrompt(prompt);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,19 +6,38 @@ namespace Server.Tests.Network;
|
|||
[Collection("Sequential Server Tests")]
|
||||
public class MobilePacketTests
|
||||
{
|
||||
private static Mobile CreateMobileWithStats(uint serial = 0x1, string name = null)
|
||||
{
|
||||
var m = new Mobile((Serial)serial) { Name = name };
|
||||
m.DefaultMobileInit();
|
||||
m.Str = 50;
|
||||
m.Hits = 100;
|
||||
m.Int = 75;
|
||||
m.Mana = 100;
|
||||
m.Dex = 25;
|
||||
m.Stam = 100;
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
private sealed class TestPoison : Poison
|
||||
{
|
||||
public TestPoison(int level) : base(level) => Level = level;
|
||||
|
||||
public override string Name => $"Test Poison {Level}";
|
||||
public override int Level { get; }
|
||||
public override PoisonFamily Family => PoisonFamily.Standard;
|
||||
|
||||
public override Timer ConstructTimer(Mobile m) => null;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestDeathAnimation()
|
||||
{
|
||||
var killed = (Serial)0x1;
|
||||
var corpse = (Serial)0x1000;
|
||||
|
||||
var expected = new DeathAnimation(killed, corpse).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendDeathAnimation(killed, corpse);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new DeathAnimation(killed, corpse), ns => ns.SendDeathAnimation(killed, corpse));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -27,13 +46,7 @@ public class MobilePacketTests
|
|||
var petSerial = (Serial)0x1;
|
||||
const bool bonded = true;
|
||||
|
||||
var expected = new BondedStatus(petSerial, bonded).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendBondedStatus(petSerial, bonded);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new BondedStatus(petSerial, bonded), ns => ns.SendBondedStatus(petSerial, bonded));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -46,14 +59,11 @@ public class MobilePacketTests
|
|||
|
||||
var noto = 10;
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges = protocolChanges;
|
||||
var expected = new MobileMoving(m, noto, ns.StygianAbyss).Compile();
|
||||
|
||||
ns.SendMobileMoving(m, noto);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
ns => new MobileMoving(m, noto, ns.StygianAbyss),
|
||||
ns => ns.SendMobileMoving(m, noto),
|
||||
protocolChanges
|
||||
);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -65,13 +75,7 @@ public class MobilePacketTests
|
|||
var m = new Mobile((Serial)0x1) { Name = name };
|
||||
m.DefaultMobileInit();
|
||||
|
||||
var expected = new MobileName(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMobileName(m);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MobileName(m), ns => ns.SendMobileName(m));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -81,29 +85,10 @@ public class MobilePacketTests
|
|||
{
|
||||
var mobile = (Serial)0x1;
|
||||
|
||||
var expected = new MobileAnimation(
|
||||
mobile,
|
||||
action,
|
||||
frameCount,
|
||||
repeatCount,
|
||||
!reverse,
|
||||
repeat,
|
||||
delay
|
||||
).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMobileAnimation(
|
||||
mobile,
|
||||
action,
|
||||
frameCount,
|
||||
repeatCount,
|
||||
!reverse,
|
||||
repeat,
|
||||
delay
|
||||
PacketAssert.Sends(
|
||||
new MobileAnimation(mobile, action, frameCount, repeatCount, !reverse, repeat, delay),
|
||||
ns => ns.SendMobileAnimation(mobile, action, frameCount, repeatCount, !reverse, repeat, delay)
|
||||
);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -113,43 +98,24 @@ public class MobilePacketTests
|
|||
{
|
||||
var mobile = (Serial)0x1;
|
||||
|
||||
var expected = new NewMobileAnimation(
|
||||
mobile,
|
||||
action,
|
||||
frameCount,
|
||||
delay
|
||||
).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendNewMobileAnimation(
|
||||
mobile,
|
||||
action,
|
||||
frameCount,
|
||||
delay
|
||||
PacketAssert.Sends(
|
||||
new NewMobileAnimation(mobile, action, frameCount, delay),
|
||||
ns => ns.SendNewMobileAnimation(mobile, action, frameCount, delay)
|
||||
);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
}
|
||||
|
||||
// Level -1 means not poisoned. Constructed directly: the poison registry is filled by UOContent.
|
||||
[Theory]
|
||||
[InlineData("None")]
|
||||
[InlineData("Lesser")]
|
||||
[InlineData("Lethal")]
|
||||
public void TestHealthbarPoison(string pName)
|
||||
[InlineData(-1)]
|
||||
[InlineData(0)]
|
||||
[InlineData(4)]
|
||||
public void TestHealthbarPoison(int level)
|
||||
{
|
||||
var p = Poison.GetPoison(pName);
|
||||
var m = new Mobile((Serial)0x1);
|
||||
m.DefaultMobileInit();
|
||||
m.Poison = p;
|
||||
m.Poison = level < 0 ? null : new TestPoison(level);
|
||||
|
||||
var expected = new HealthbarPoison(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMobileHealthbar(m, Healthbar.Poison);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new HealthbarPoison(m), ns => ns.SendMobileHealthbar(m, Healthbar.Poison));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -164,13 +130,7 @@ public class MobilePacketTests
|
|||
m.Blessed = isBlessed;
|
||||
m.YellowHealthbar = isYellowHealth;
|
||||
|
||||
var expected = new HealthbarYellow(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMobileHealthbar(m, Healthbar.Yellow);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new HealthbarYellow(m), ns => ns.SendMobileHealthbar(m, Healthbar.Yellow));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -178,22 +138,9 @@ public class MobilePacketTests
|
|||
[InlineData(false)]
|
||||
public void TestMobileStatusCompact(bool canBeRenamed)
|
||||
{
|
||||
var m = new Mobile((Serial)0x1) { Name = "Random Mobile 1" };
|
||||
m.DefaultMobileInit();
|
||||
m.Str = 50;
|
||||
m.Hits = 100;
|
||||
m.Int = 75;
|
||||
m.Mana = 100;
|
||||
m.Dex = 25;
|
||||
m.Stam = 100;
|
||||
var m = CreateMobileWithStats(name: "Random Mobile 1");
|
||||
|
||||
var expected = new MobileStatusCompact(canBeRenamed, m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMobileStatusCompact(m, canBeRenamed);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MobileStatusCompact(canBeRenamed, m), ns => ns.SendMobileStatusCompact(m, canBeRenamed));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -201,32 +148,14 @@ public class MobilePacketTests
|
|||
[InlineData(ProtocolChanges.Version502b)]
|
||||
public void TestMobileStatus(ProtocolChanges changes)
|
||||
{
|
||||
var beholder = new Mobile((Serial)0x1) { Name = "Random Mobile 1" };
|
||||
beholder.DefaultMobileInit();
|
||||
beholder.Str = 50;
|
||||
beholder.Hits = 100;
|
||||
beholder.Int = 75;
|
||||
beholder.Mana = 100;
|
||||
beholder.Dex = 25;
|
||||
beholder.Stam = 100;
|
||||
var beholder = CreateMobileWithStats(0x1, "Random Mobile 1");
|
||||
var beheld = CreateMobileWithStats(0x2, "Random Mobile 2");
|
||||
|
||||
var beheld = new Mobile((Serial)0x2) { Name = "Random Mobile 2" };
|
||||
beheld.DefaultMobileInit();
|
||||
beheld.Str = 50;
|
||||
beheld.Hits = 100;
|
||||
beheld.Int = 75;
|
||||
beheld.Mana = 100;
|
||||
beheld.Dex = 25;
|
||||
beheld.Stam = 100;
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges = changes;
|
||||
|
||||
var expected = new MobileStatus(beholder, beheld, ns).Compile();
|
||||
ns.SendMobileStatus(beholder, beheld);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
ns => new MobileStatus(beholder, beheld, ns),
|
||||
ns => ns.SendMobileStatus(beholder, beheld),
|
||||
changes
|
||||
);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -240,33 +169,32 @@ public class MobilePacketTests
|
|||
int mobileStatusVersion
|
||||
)
|
||||
{
|
||||
var expansionInfo = ExpansionInfo.CoreExpansion;
|
||||
var oldExpansion = Core.Expansion;
|
||||
var expansionInfo = ExpansionInfo.GetInfo(expansion);
|
||||
var oldVersion = expansionInfo.MobileStatusVersion;
|
||||
Core.Expansion = expansion;
|
||||
ExpansionInfo.CoreExpansion.MobileStatusVersion = mobileStatusVersion;
|
||||
|
||||
var m = new Mobile((Serial)0x1) { Name = "Random Mobile 1" };
|
||||
m.DefaultMobileInit();
|
||||
m.Str = 50;
|
||||
m.Hits = 100;
|
||||
m.Int = 75;
|
||||
m.Mana = 100;
|
||||
m.Dex = 25;
|
||||
m.Stam = 100;
|
||||
try
|
||||
{
|
||||
Core.Expansion = expansion;
|
||||
expansionInfo.MobileStatusVersion = mobileStatusVersion;
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges = changes;
|
||||
ns.Version = new ClientVersion(version);
|
||||
ns.Flags = clientFlags;
|
||||
var m = CreateMobileWithStats(name: "Random Mobile 1");
|
||||
|
||||
var expected = new MobileStatusExtended(m, ns).Compile();
|
||||
ns.SendMobileStatus(m, m);
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges = changes;
|
||||
ns.Version = new ClientVersion(version);
|
||||
ns.Flags = clientFlags;
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
Core.Expansion = oldExpansion;
|
||||
expansionInfo.MobileStatusVersion = oldVersion;
|
||||
var expected = new MobileStatusExtended(m, ns).Compile();
|
||||
ns.SendMobileStatus(m, m);
|
||||
|
||||
AssertThat.Equal(ns.SendBuffer.GetReadSpan(), expected);
|
||||
}
|
||||
finally
|
||||
{
|
||||
Core.Expansion = oldExpansion;
|
||||
expansionInfo.MobileStatusVersion = oldVersion;
|
||||
}
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -278,14 +206,7 @@ public class MobilePacketTests
|
|||
m.DefaultMobileInit();
|
||||
m.SolidHueOverride = solidHueOverride;
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges = changes;
|
||||
|
||||
var expected = new MobileUpdate(m, ns.StygianAbyss).Compile();
|
||||
ns.SendMobileUpdate(m);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(ns => new MobileUpdate(m, ns.StygianAbyss), ns => ns.SendMobileUpdate(m), changes);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -333,170 +254,82 @@ public class MobilePacketTests
|
|||
beheld.FacialHairItemID = facialHairItemId;
|
||||
beheld.FacialHairHue = facialHairHue;
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges = changes;
|
||||
|
||||
var expected = new MobileIncoming(ns, beholder, beheld).Compile();
|
||||
ns.SendMobileIncoming(beholder, beheld);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
ns => new MobileIncoming(ns, beholder, beheld),
|
||||
ns => ns.SendMobileIncoming(beholder, beheld),
|
||||
changes
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestMobileHits()
|
||||
{
|
||||
var m = new Mobile((Serial)0x1);
|
||||
m.DefaultMobileInit();
|
||||
m.Str = 100;
|
||||
m.Hits = 100;
|
||||
var m = CreateMobileWithStats();
|
||||
|
||||
var expected = new MobileHits(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMobileHits(m);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MobileHits(m), ns => ns.SendMobileHits(m));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestMobileHitsN()
|
||||
{
|
||||
var m = new Mobile((Serial)0x1);
|
||||
m.DefaultMobileInit();
|
||||
m.Str = 100;
|
||||
m.Hits = 100;
|
||||
var m = CreateMobileWithStats();
|
||||
|
||||
var expected = new MobileHitsN(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMobileHits(m, true);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MobileHitsN(m), ns => ns.SendMobileHits(m, true));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestMobileMana()
|
||||
{
|
||||
var m = new Mobile((Serial)0x1);
|
||||
m.DefaultMobileInit();
|
||||
m.Int = 75;
|
||||
m.Mana = 100;
|
||||
var m = CreateMobileWithStats();
|
||||
|
||||
var expected = new MobileMana(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMobileMana(m);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MobileMana(m), ns => ns.SendMobileMana(m));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestMobileManaN()
|
||||
{
|
||||
var m = new Mobile((Serial)0x1);
|
||||
m.DefaultMobileInit();
|
||||
m.Int = 75;
|
||||
m.Mana = 100;
|
||||
var m = CreateMobileWithStats();
|
||||
|
||||
var expected = new MobileManaN(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMobileMana(m, true);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MobileManaN(m), ns => ns.SendMobileMana(m, true));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestMobileStam()
|
||||
{
|
||||
var m = new Mobile((Serial)0x1);
|
||||
m.DefaultMobileInit();
|
||||
m.Dex = 75;
|
||||
m.Stam = 100;
|
||||
var m = CreateMobileWithStats();
|
||||
|
||||
var expected = new MobileStam(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMobileStam(m);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MobileStam(m), ns => ns.SendMobileStam(m));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestMobileStamN()
|
||||
{
|
||||
var m = new Mobile((Serial)0x1);
|
||||
m.DefaultMobileInit();
|
||||
m.Dex = 75;
|
||||
m.Stam = 100;
|
||||
var m = CreateMobileWithStats();
|
||||
|
||||
var expected = new MobileStamN(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMobileStam(m, true);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MobileStamN(m), ns => ns.SendMobileStam(m, true));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestMobileAttributes()
|
||||
{
|
||||
var m = new Mobile((Serial)0x1);
|
||||
m.DefaultMobileInit();
|
||||
m.Str = 50;
|
||||
m.Hits = 100;
|
||||
m.Int = 75;
|
||||
m.Mana = 100;
|
||||
m.Dex = 25;
|
||||
m.Stam = 100;
|
||||
var m = CreateMobileWithStats();
|
||||
|
||||
var expected = new MobileAttributes(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMobileAttributes(m);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MobileAttributes(m), ns => ns.SendMobileAttributes(m));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestMobileAttributesN()
|
||||
{
|
||||
var m = new Mobile((Serial)0x1);
|
||||
m.DefaultMobileInit();
|
||||
m.Str = 50;
|
||||
m.Hits = 100;
|
||||
m.Int = 75;
|
||||
m.Mana = 100;
|
||||
m.Dex = 25;
|
||||
m.Stam = 100;
|
||||
var m = CreateMobileWithStats();
|
||||
|
||||
var expected = new MobileAttributesN(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMobileAttributes(m, true);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MobileAttributesN(m), ns => ns.SendMobileAttributes(m, true));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestRemoveEntity()
|
||||
{
|
||||
var e = (Serial)0x1000;
|
||||
var expected = new RemoveEntity(e).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendRemoveEntity(e);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new RemoveEntity(e), ns => ns.SendRemoveEntity(e));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,26 +12,18 @@ public class MovementPacketTests
|
|||
[InlineData(2)]
|
||||
public void TestSpeedControl(byte speedControl)
|
||||
{
|
||||
var expected = new SpeedControl(speedControl).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendSpeedControl((SpeedControlSetting)speedControl);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new SpeedControl(speedControl),
|
||||
ns => ns.SendSpeedControl((SpeedControlSetting)speedControl)
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestMovePlayer()
|
||||
{
|
||||
const Direction d = Direction.Left;
|
||||
var expected = new MovePlayer(d).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMovePlayer(d);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MovePlayer(d), ns => ns.SendMovePlayer(d));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -42,13 +34,7 @@ public class MovementPacketTests
|
|||
|
||||
const byte seq = 100;
|
||||
|
||||
var expected = new MovementRej(seq, m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMovementRej(seq, m);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MovementRej(seq, m), ns => ns.SendMovementRej(seq, m));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -59,12 +45,6 @@ public class MovementPacketTests
|
|||
|
||||
const byte seq = 100;
|
||||
|
||||
var expected = MovementAck.Instantiate(seq, m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMovementAck(seq, m);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(MovementAck.Instantiate(seq, m), ns => ns.SendMovementAck(seq, m));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,23 +8,16 @@ namespace Server.Tests.Network;
|
|||
[Collection("Sequential Server Tests")]
|
||||
public class PlayerPacketTests
|
||||
{
|
||||
[Theory]
|
||||
[InlineData(StatLockType.Down, StatLockType.Up, StatLockType.Locked)]
|
||||
public void TestStatLockInfo(StatLockType str, StatLockType intel, StatLockType dex)
|
||||
[Fact]
|
||||
public void TestStatLockInfo()
|
||||
{
|
||||
var m = new Mobile((Serial)0x1);
|
||||
m.DefaultMobileInit();
|
||||
m.StrLock = str;
|
||||
m.IntLock = intel;
|
||||
m.DexLock = dex;
|
||||
m.StrLock = StatLockType.Down;
|
||||
m.IntLock = StatLockType.Up;
|
||||
m.DexLock = StatLockType.Locked;
|
||||
|
||||
var expected = new StatLockInfo(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendStatLockInfo(m);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new StatLockInfo(m), ns => ns.SendStatLockInfo(m));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -33,25 +26,13 @@ public class PlayerPacketTests
|
|||
[InlineData(200)]
|
||||
public void TestChangeUpdateRange(int range)
|
||||
{
|
||||
var expected = new ChangeUpdateRange(range).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendChangeUpdateRange((byte)range);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new ChangeUpdateRange(range), ns => ns.SendChangeUpdateRange((byte)range));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestDeathStatus()
|
||||
{
|
||||
var expected = new DeathStatus(false).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendDeathStatus();
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new DeathStatus(false), ns => ns.SendDeathStatus());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -59,13 +40,10 @@ public class PlayerPacketTests
|
|||
[InlineData(0x1000u, null, null, null)]
|
||||
public void TestDisplayProfile(uint serial, string header, string body, string footer)
|
||||
{
|
||||
var expected = new DisplayProfile((Serial)serial, header, body, footer).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendDisplayProfile((Serial)serial, header, body, footer);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new DisplayProfile((Serial)serial, header, body, footer),
|
||||
ns => ns.SendDisplayProfile((Serial)serial, header, body, footer)
|
||||
);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -73,55 +51,31 @@ public class PlayerPacketTests
|
|||
[InlineData(LRReason.TryToSteal)]
|
||||
public void TestLiftRej(LRReason reason)
|
||||
{
|
||||
var expected = new LiftRej(reason).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendLiftReject(reason);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new LiftRej(reason), ns => ns.SendLiftReject(reason));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestLogoutAck()
|
||||
{
|
||||
var expected = new LogoutAck().Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendLogoutAck();
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new LogoutAck(), ns => ns.SendLogoutAck());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(1, 2, 3)]
|
||||
[InlineData(4, 5, 6)]
|
||||
[InlineData(0x1234, 0x5678, 0x9ABC)]
|
||||
public void TestWeather(int type, int density, int temp)
|
||||
[InlineData(0xFF, 0x46, 0xEC)]
|
||||
public void TestWeather(byte type, byte density, byte temp)
|
||||
{
|
||||
var expected = new Weather(type, density, temp).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendWeather((byte)type, (byte)density, (byte)temp);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new Weather(type, density, temp), ns => ns.SendWeather(type, density, temp));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(100, 1000, 1, 0)]
|
||||
public void TestServerChange(int x, int y, int z, int mapID)
|
||||
[Fact]
|
||||
public void TestServerChange()
|
||||
{
|
||||
var p = new Point3D(x, y, z);
|
||||
var map = Map.Maps[mapID];
|
||||
var expected = new ServerChange(p, map).Compile();
|
||||
var p = new Point3D(100, 1000, 1);
|
||||
var map = Map.Maps[0];
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendServerChange(p, map);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new ServerChange(p, map), ns => ns.SendServerChange(p, map));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -130,13 +84,7 @@ public class PlayerPacketTests
|
|||
[InlineData(255)]
|
||||
public void TestSequence(byte num)
|
||||
{
|
||||
var expected = new Sequence(num).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendSequence(num);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new Sequence(num), ns => ns.SendSequence(num));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -146,37 +94,22 @@ public class PlayerPacketTests
|
|||
[InlineData("https://www.modernuo.com")]
|
||||
public void TestLaunchBrowser(string uri)
|
||||
{
|
||||
var expected = new LaunchBrowser(uri).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendLaunchBrowser(uri);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new LaunchBrowser(uri), ns => ns.SendLaunchBrowser(uri));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(0x1000u, 1000, 100, 10, 0x2000u, 1125, 125, 5, 0x384, 1024, 25)]
|
||||
public void TestDragEffect(
|
||||
uint srcSerial, int srcX, int srcY, int srcZ,
|
||||
uint trgSerial, int trgX, int trgY, int trgZ,
|
||||
int itemId, int hue, int amount
|
||||
)
|
||||
[Fact]
|
||||
public void TestDragEffect()
|
||||
{
|
||||
var src = new Entity((Serial)srcSerial, new Point3D(srcX, srcY, srcZ), null);
|
||||
var targ = new Entity((Serial)trgSerial, new Point3D(trgX, trgY, trgZ), null);
|
||||
var src = new Entity((Serial)0x1000, new Point3D(1000, 100, 10), null);
|
||||
var targ = new Entity((Serial)0x2000, new Point3D(1125, 125, 5), null);
|
||||
const int itemId = 0x384;
|
||||
const int hue = 1024;
|
||||
const int amount = 25;
|
||||
|
||||
var expected = new DragEffect(src, targ, itemId, hue, amount).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendDragEffect(
|
||||
src.Serial, src.Location,
|
||||
targ.Serial, targ.Location,
|
||||
itemId, hue, amount
|
||||
PacketAssert.Sends(
|
||||
new DragEffect(src, targ, itemId, hue, amount),
|
||||
ns => ns.SendDragEffect(src.Serial, src.Location, targ.Serial, targ.Location, itemId, hue, amount)
|
||||
);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -184,13 +117,7 @@ public class PlayerPacketTests
|
|||
[InlineData(2, true)]
|
||||
public void TestSeasonChange(int season, bool playSound)
|
||||
{
|
||||
var expected = new SeasonChange(season, playSound).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendSeasonChange((byte)season, playSound);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new SeasonChange(season, playSound), ns => ns.SendSeasonChange((byte)season, playSound));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -199,13 +126,10 @@ public class PlayerPacketTests
|
|||
[InlineData(0x1024u, "Test Title", true, false)]
|
||||
public void TestDisplayPaperdoll(uint m, string title, bool warmode, bool canLift)
|
||||
{
|
||||
var expected = new DisplayPaperdoll((Serial)m, title, warmode, canLift).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendDisplayPaperdoll((Serial)m, title, warmode, canLift);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new DisplayPaperdoll((Serial)m, title, warmode, canLift),
|
||||
ns => ns.SendDisplayPaperdoll((Serial)m, title, warmode, canLift)
|
||||
);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -214,13 +138,7 @@ public class PlayerPacketTests
|
|||
[InlineData(MusicName.ValoriaShips)]
|
||||
public void TestPlayMusic(MusicName music)
|
||||
{
|
||||
var expected = new PlayMusic(music).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendPlayMusic(music);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new PlayMusic(music), ns => ns.SendPlayMusic(music));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -228,41 +146,23 @@ public class PlayerPacketTests
|
|||
[InlineData(100, 10, "Some more text")]
|
||||
public void TestScrollMessage(int type, int tip, string text)
|
||||
{
|
||||
var expected = new ScrollMessage(type, tip, text).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendScrollMessage(type, tip ,text);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new ScrollMessage(type, tip, text), ns => ns.SendScrollMessage(type, tip, text));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(14, 10, 05)]
|
||||
public void TestCurrentTime(int hour, int minute, int second)
|
||||
[Fact]
|
||||
public void TestCurrentTime()
|
||||
{
|
||||
var date = new DateTime(2020, 1, 1, hour, minute, second);
|
||||
var expected = new CurrentTime(date).Compile();
|
||||
var date = new DateTime(2020, 1, 1, 14, 10, 5);
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendCurrentTime(date);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new CurrentTime(date), ns => ns.SendCurrentTime(date));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(1000, 10, 1)]
|
||||
public void TestPathfindMessage(int x, int y, int z)
|
||||
[Fact]
|
||||
public void TestPathfindMessage()
|
||||
{
|
||||
var p = new Point3D(x, y, z);
|
||||
var expected = new PathfindMessage(p).Compile();
|
||||
var p = new Point3D(1000, 10, 1);
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendPathfindMessage(p);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new PathfindMessage(p), ns => ns.SendPathfindMessage(p));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -271,27 +171,17 @@ public class PlayerPacketTests
|
|||
[InlineData(100)]
|
||||
public void TestPingAck(byte ping)
|
||||
{
|
||||
var expected = new PingAck(ping).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendPingAck(ping);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new PingAck(ping), ns => ns.SendPingAck(ping));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(0xFF01)]
|
||||
public void TestDisplayHuePicker(int itemID)
|
||||
[Fact]
|
||||
public void TestDisplayHuePicker()
|
||||
{
|
||||
var huePicker = new HuePicker(itemID);
|
||||
var huePicker = new HuePicker(0xFF01);
|
||||
|
||||
var expected = new DisplayHuePicker(huePicker).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendDisplayHuePicker(huePicker.Serial, huePicker.ItemID);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new DisplayHuePicker(huePicker),
|
||||
ns => ns.SendDisplayHuePicker(huePicker.Serial, huePicker.ItemID)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,13 +18,10 @@ public class SecureTradePacketTests
|
|||
var firstCont = new Container(World.NewItem);
|
||||
var secondCont = new Container(World.NewItem);
|
||||
|
||||
var expected = new DisplaySecureTrade(m, firstCont, secondCont, name).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendDisplaySecureTrade(m, firstCont, secondCont, name);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new DisplaySecureTrade(m, firstCont, secondCont, name),
|
||||
ns => ns.SendDisplaySecureTrade(m, firstCont, secondCont, name)
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -32,13 +29,7 @@ public class SecureTradePacketTests
|
|||
{
|
||||
var cont = new Container(World.NewItem);
|
||||
|
||||
var expected = new CloseSecureTrade(cont).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendCloseSecureTrade(cont);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new CloseSecureTrade(cont), ns => ns.SendCloseSecureTrade(cont));
|
||||
}
|
||||
|
||||
[Theory, InlineData(true, false), InlineData(false, true)]
|
||||
|
|
@ -50,13 +41,11 @@ public class SecureTradePacketTests
|
|||
var secondCont = new Container(World.NewItem);
|
||||
|
||||
var cont = first ? firstCont : secondCont;
|
||||
var expected = new UpdateSecureTrade(cont, first, second).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendUpdateSecureTrade(cont, first, second);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new UpdateSecureTrade(cont, first, second),
|
||||
ns => ns.SendUpdateSecureTrade(cont, first, second)
|
||||
);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -65,13 +54,11 @@ public class SecureTradePacketTests
|
|||
public void TestUpdateGoldSecureTrade(int gold, int plat, TradeFlag flag)
|
||||
{
|
||||
var cont = new Container(World.NewItem);
|
||||
var expected = new UpdateSecureTrade(cont, flag, gold, plat).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendUpdateSecureTrade(cont, flag, gold, plat);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new UpdateSecureTrade(cont, flag, gold, plat),
|
||||
ns => ns.SendUpdateSecureTrade(cont, flag, gold, plat)
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -83,13 +70,7 @@ public class SecureTradePacketTests
|
|||
var cont = new Container(World.NewItem);
|
||||
var itemInCont = new Item(World.NewItem) { Parent = cont };
|
||||
|
||||
var expected = new SecureTradeEquip(itemInCont, m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendSecureTradeEquip(itemInCont, m);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new SecureTradeEquip(itemInCont, m), ns => ns.SendSecureTradeEquip(itemInCont, m));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -101,14 +82,10 @@ public class SecureTradePacketTests
|
|||
var cont = new Container(World.NewItem);
|
||||
var itemInCont = new Item(World.NewItem) { Parent = cont };
|
||||
|
||||
var expected = new SecureTradeEquip6017(itemInCont, m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges |= ProtocolChanges.ContainerGridLines;
|
||||
|
||||
ns.SendSecureTradeEquip(itemInCont, m);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new SecureTradeEquip6017(itemInCont, m),
|
||||
ns => ns.SendSecureTradeEquip(itemInCont, m),
|
||||
ProtocolChanges.ContainerGridLines
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -38,14 +38,7 @@ public class TargetPacketsTests
|
|||
var p = new Point3D(1000, 100, 10);
|
||||
MultiTarget t = new TestMultiTarget(multiID, p);
|
||||
|
||||
var expected = new MultiTargetReqHS(t).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges |= ProtocolChanges.HighSeas;
|
||||
ns.SendMultiTargetReq(t);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MultiTargetReqHS(t), ns => ns.SendMultiTargetReq(t), ProtocolChanges.HighSeas);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -55,36 +48,20 @@ public class TargetPacketsTests
|
|||
var p = new Point3D(1000, 100, 10);
|
||||
MultiTarget t = new TestMultiTarget(multiID, p);
|
||||
|
||||
var expected = new MultiTargetReq(t).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendMultiTargetReq(t);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new MultiTargetReq(t), ns => ns.SendMultiTargetReq(t));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestCancelTarget()
|
||||
{
|
||||
var expected = new CancelTarget().Compile();
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendCancelTarget();
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new CancelTarget(), ns => ns.SendCancelTarget());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestTargetReq()
|
||||
{
|
||||
var t = new TestTarget(10, true, TargetFlags.Beneficial);
|
||||
var expected = new TargetReq(t).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendTargetReq(t);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new TargetReq(t), ns => ns.SendTargetReq(t));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -22,15 +22,11 @@ public class VendorBuyPacketTests
|
|||
new("Third Item", cont.Serial, World.NewItem, 30, 10, 0x0F, 0)
|
||||
};
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges = protocolChanges;
|
||||
|
||||
var expected = new VendorBuyContent(buyStates, ns.ContainerGridLines).Compile();
|
||||
|
||||
ns.SendVendorBuyContent(buyStates);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
ns => new VendorBuyContent(buyStates, ns.ContainerGridLines),
|
||||
ns => ns.SendVendorBuyContent(buyStates),
|
||||
protocolChanges
|
||||
);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
|
|
@ -41,15 +37,11 @@ public class VendorBuyPacketTests
|
|||
var vendor = new Mobile((Serial)0x1);
|
||||
vendor.DefaultMobileInit();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.ProtocolChanges = protocolChanges;
|
||||
|
||||
var expected = new DisplayBuyList(vendor.Serial, ns.HighSeas).Compile();
|
||||
|
||||
ns.SendDisplayBuyList(vendor.Serial);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
ns => new DisplayBuyList(vendor.Serial, ns.HighSeas),
|
||||
ns => ns.SendDisplayBuyList(vendor.Serial),
|
||||
protocolChanges
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -67,13 +59,7 @@ public class VendorBuyPacketTests
|
|||
new("Third Item", cont.Serial, World.NewItem, 30, 10, 0x0F, 0)
|
||||
};
|
||||
|
||||
var expected = new VendorBuyList(vendor, buyStates).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendVendorBuyList(vendor, buyStates);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new VendorBuyList(vendor, buyStates), ns => ns.SendVendorBuyList(vendor, buyStates));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -82,12 +68,6 @@ public class VendorBuyPacketTests
|
|||
var vendor = new Mobile((Serial)0x1);
|
||||
vendor.DefaultMobileInit();
|
||||
|
||||
var expected = new EndVendorBuy(vendor.Serial).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendEndVendorBuy(vendor.Serial);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new EndVendorBuy(vendor.Serial), ns => ns.SendEndVendorBuy(vendor.Serial));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,13 +25,10 @@ public class VendorSellPacketTests
|
|||
new(item3, 1, "Item 3")
|
||||
};
|
||||
|
||||
var expected = new VendorSellList(vendor, sellStates.ToList()).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendVendorSellList(vendor.Serial, sellStates);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new VendorSellList(vendor, sellStates.ToList()),
|
||||
ns => ns.SendVendorSellList(vendor.Serial, sellStates)
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -40,12 +37,6 @@ public class VendorSellPacketTests
|
|||
var vendor = new Mobile((Serial)0x1024u);
|
||||
vendor.DefaultMobileInit();
|
||||
|
||||
var expected = new EndVendorBuy(vendor.Serial).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendEndVendorSell(vendor.Serial);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new EndVendorSell(vendor), ns => ns.SendEndVendorSell(vendor.Serial));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,13 +15,10 @@ public class VirtualHairPacketTests
|
|||
m.HairHue = 0x1000;
|
||||
m.HairItemID = 0x2000;
|
||||
|
||||
var expected = new HairEquipUpdate(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendHairEquipUpdatePacket(m, (uint)m.HairSerial, m.HairItemID, m.HairHue, Layer.Hair);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(
|
||||
new HairEquipUpdate(m),
|
||||
ns => ns.SendHairEquipUpdatePacket(m, (uint)m.HairSerial, m.HairItemID, m.HairHue, Layer.Hair)
|
||||
);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -30,13 +27,7 @@ public class VirtualHairPacketTests
|
|||
var m = new Mobile((Serial)0x1024u);
|
||||
m.DefaultMobileInit();
|
||||
|
||||
var expected = new RemoveHair(m).Compile();
|
||||
|
||||
using var ns = PacketTestUtilities.CreateTestNetState();
|
||||
ns.SendRemoveHairPacket((uint)m.HairSerial);
|
||||
|
||||
var result = ns.SendBuffer.GetReadSpan();
|
||||
AssertThat.Equal(result, expected);
|
||||
PacketAssert.Sends(new RemoveHair(m), ns => ns.SendRemoveHairPacket((uint)m.HairSerial));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
|
|||
|
|
@ -16,22 +16,6 @@ public sealed class HairEquipUpdate : Packet
|
|||
}
|
||||
}
|
||||
|
||||
public sealed class FacialHairEquipUpdate : Packet
|
||||
{
|
||||
public FacialHairEquipUpdate(Mobile parent)
|
||||
: base(0x2E, 15)
|
||||
{
|
||||
var hue = parent.SolidHueOverride >= 0 ? parent.SolidHueOverride : parent.FacialHairHue;
|
||||
|
||||
Stream.Write(parent.FacialHairSerial);
|
||||
Stream.Write((short)parent.FacialHairItemID);
|
||||
Stream.Write((byte)0);
|
||||
Stream.Write((byte)Layer.FacialHair);
|
||||
Stream.Write(parent.Serial);
|
||||
Stream.Write((short)hue);
|
||||
}
|
||||
}
|
||||
|
||||
public sealed class RemoveHair : Packet
|
||||
{
|
||||
public RemoveHair(Mobile parent)
|
||||
|
|
@ -40,12 +24,3 @@ public sealed class RemoveHair : Packet
|
|||
Stream.Write(parent.HairSerial);
|
||||
}
|
||||
}
|
||||
|
||||
public sealed class RemoveFacialHair : Packet
|
||||
{
|
||||
public RemoveFacialHair(Mobile parent)
|
||||
: base(0x1D, 5)
|
||||
{
|
||||
Stream.Write(parent.FacialHairSerial);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -102,36 +102,31 @@ public class ObjectPropertyListHashTests
|
|||
// 6- and 8-byte blocks take xxHash3's short-input paths. They still avalanche across all 26
|
||||
// kept bits, so a counter ticking down never repeats the revision it just had.
|
||||
[Fact]
|
||||
public void ShortNumericArguments_ConsecutiveValuesDiffer()
|
||||
public void ShortPropertyBlocks_ConsecutiveValuesDifferAndStayWellDistributed()
|
||||
{
|
||||
var previous = BuildHash((1060584, "0"));
|
||||
|
||||
for (var charges = 1; charges < 20000; charges++)
|
||||
{
|
||||
var current = BuildHash((1060584, charges.ToString()));
|
||||
Assert.NotEqual(previous, current);
|
||||
previous = current;
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SmallPropertyBlocks_StayWellDistributed()
|
||||
{
|
||||
const int count = 20000;
|
||||
const int count = 5000;
|
||||
|
||||
var withArgument = new HashSet<int>();
|
||||
var withoutArgument = new HashSet<int>();
|
||||
var previous = 0;
|
||||
|
||||
for (var i = 0; i < count; i++)
|
||||
{
|
||||
withArgument.Add(BuildHash((1060584, i.ToString())));
|
||||
var current = BuildHash((1060584, i.ToString()));
|
||||
if (i > 0)
|
||||
{
|
||||
Assert.NotEqual(previous, current);
|
||||
}
|
||||
|
||||
previous = current;
|
||||
withArgument.Add(current);
|
||||
withoutArgument.Add(BuildHash((1060000 + i, null)));
|
||||
}
|
||||
|
||||
// Birthday expects ~3 collisions over a 26-bit space; allow an order of magnitude so the
|
||||
// bound holds for any seed. A hash that stopped mixing collapses far past it.
|
||||
Assert.True(withArgument.Count >= count - 30, $"8-byte blocks: {withArgument.Count}/{count}");
|
||||
Assert.True(withoutArgument.Count >= count - 30, $"6-byte blocks: {withoutArgument.Count}/{count}");
|
||||
// Birthday expects ~0.2 collisions over a 26-bit space; allow a few so the bound holds for
|
||||
// any seed. A hash that stopped mixing collapses far past it.
|
||||
Assert.True(withArgument.Count >= count - 5, $"8-byte blocks: {withArgument.Count}/{count}");
|
||||
Assert.True(withoutArgument.Count >= count - 5, $"6-byte blocks: {withoutArgument.Count}/{count}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
|
|||
|
|
@ -1,6 +1,4 @@
|
|||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using Xunit;
|
||||
|
||||
namespace Server.Tests;
|
||||
|
|
@ -107,83 +105,48 @@ public class AnchoredTimePersistenceTests
|
|||
[Fact]
|
||||
public void SaveStartAnchor_RebasesAnchoredTimestampsAtLoad()
|
||||
{
|
||||
var previousAssemblies = AssemblyHandler.Assemblies;
|
||||
AssemblyHandler.Assemblies = [.. previousAssemblies ?? [], typeof(AnchoredEntity).Assembly];
|
||||
// The scope also restores World.SaveStartTime, which this test backdates.
|
||||
using var pipeline = new PersistencePipelineScope(
|
||||
2,
|
||||
installWorkers: true,
|
||||
visibleAssembly: typeof(AnchoredEntity).Assembly,
|
||||
directoryPrefix: "muo-anchored"
|
||||
);
|
||||
var source = pipeline.Source;
|
||||
var dir = pipeline.Directory;
|
||||
|
||||
var source = new SerializationChunkSource();
|
||||
var workers = new SerializationThreadWorker[2];
|
||||
for (var i = 0; i < workers.Length; i++)
|
||||
{
|
||||
workers[i] = new SerializationThreadWorker(i, source);
|
||||
workers[i].AllocateHeap();
|
||||
}
|
||||
var persistence = pipeline.Track(new AnchoredPersistence(2100));
|
||||
|
||||
var previousWorkers = World._threadWorkers;
|
||||
World._threadWorkers = workers;
|
||||
var lastRested = Core.Now - TimeSpan.FromMinutes(10);
|
||||
var serial = (Serial)1u;
|
||||
persistence.EntitiesBySerial[serial] = new AnchoredEntity(serial) { LastRested = lastRested };
|
||||
persistence.RegisterType(typeof(AnchoredEntity));
|
||||
|
||||
var previousSaveStart = World.SaveStartTime;
|
||||
// Pretend the save started two hours ago, as if the server had been down since.
|
||||
var downtime = TimeSpan.FromHours(2);
|
||||
World.SaveStartTime = Core.Now - downtime;
|
||||
|
||||
var persistence = new AnchoredPersistence(2100);
|
||||
AnchoredPersistence loaded = null;
|
||||
pipeline.WakeWorkers();
|
||||
|
||||
var dir = Path.Combine(Path.GetTempPath(), $"muo-anchored-{Guid.NewGuid():N}");
|
||||
Directory.CreateDirectory(dir);
|
||||
source.SetOwner(persistence);
|
||||
Assert.True(persistence.TrySnapshotEntries(out var slotCount));
|
||||
source.PushSlotRanges(persistence, slotCount);
|
||||
|
||||
try
|
||||
{
|
||||
var lastRested = Core.Now - TimeSpan.FromMinutes(10);
|
||||
var serial = (Serial)1u;
|
||||
persistence.EntitiesBySerial[serial] = new AnchoredEntity(serial) { LastRested = lastRested };
|
||||
persistence.RegisterType(typeof(AnchoredEntity));
|
||||
pipeline.FlushAndSleepWorkers();
|
||||
|
||||
// Pretend the save started two hours ago, as if the server had been down since.
|
||||
var downtime = TimeSpan.FromHours(2);
|
||||
World.SaveStartTime = Core.Now - downtime;
|
||||
persistence.WriteSnapshot(dir);
|
||||
persistence.PostWorldSave();
|
||||
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Wake();
|
||||
}
|
||||
var loaded = pipeline.Track(new AnchoredPersistence(2101));
|
||||
loaded.DeserializeIndexes(dir, null);
|
||||
loaded.Deserialize(dir, null);
|
||||
|
||||
source.SetOwner(persistence);
|
||||
Assert.True(persistence.TrySnapshotEntries(out var slotCount));
|
||||
source.PushSlotRanges(persistence, slotCount);
|
||||
var entity = loaded.EntitiesBySerial[serial];
|
||||
var expected = lastRested + downtime;
|
||||
|
||||
source.Flush();
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Sleep();
|
||||
}
|
||||
|
||||
persistence.WriteSnapshot(dir);
|
||||
persistence.PostWorldSave();
|
||||
|
||||
loaded = new AnchoredPersistence(2101);
|
||||
loaded.DeserializeIndexes(dir, null);
|
||||
loaded.Deserialize(dir, null);
|
||||
|
||||
var entity = loaded.EntitiesBySerial[serial];
|
||||
var expected = lastRested + downtime;
|
||||
|
||||
Assert.True(
|
||||
(entity.LastRested - expected).Duration() <= TimeSpan.FromSeconds(30),
|
||||
$"Anchored timestamp must re-base by the downtime; expected ~{expected}, got {entity.LastRested}."
|
||||
);
|
||||
}
|
||||
finally
|
||||
{
|
||||
World.SaveStartTime = previousSaveStart;
|
||||
persistence.Unregister();
|
||||
loaded?.Unregister();
|
||||
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Exit();
|
||||
}
|
||||
|
||||
World._threadWorkers = previousWorkers;
|
||||
AssemblyHandler.Assemblies = previousAssemblies;
|
||||
Directory.Delete(dir, true);
|
||||
}
|
||||
Assert.True(
|
||||
(entity.LastRested - expected).Duration() <= TimeSpan.FromSeconds(30),
|
||||
$"Anchored timestamp must re-base by the downtime; expected ~{expected}, got {entity.LastRested}."
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,4 @@
|
|||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using Xunit;
|
||||
|
||||
namespace Server.Tests;
|
||||
|
|
@ -72,103 +70,68 @@ public class GenericEntityPersistenceRoundTripTests
|
|||
[Fact]
|
||||
public void SnapshotRoundTripsThroughWorkersAndSegmentLogs()
|
||||
{
|
||||
// The loader resolves types by hash through AssemblyHandler; make this test
|
||||
// assembly visible for the duration of the test.
|
||||
var previousAssemblies = AssemblyHandler.Assemblies;
|
||||
AssemblyHandler.Assemblies = [.. previousAssemblies ?? [], typeof(RoundTripEntity).Assembly];
|
||||
// The loader resolves types by hash through AssemblyHandler, so this test assembly must be visible.
|
||||
using var pipeline = new PersistencePipelineScope(
|
||||
3,
|
||||
installWorkers: true,
|
||||
visibleAssembly: typeof(RoundTripEntity).Assembly,
|
||||
directoryPrefix: "muo-roundtrip"
|
||||
);
|
||||
var source = pipeline.Source;
|
||||
var dir = pipeline.Directory;
|
||||
|
||||
var source = new SerializationChunkSource();
|
||||
var workers = new SerializationThreadWorker[3];
|
||||
for (var i = 0; i < workers.Length; i++)
|
||||
var persistence = pipeline.Track(new RoundTripPersistence(2000));
|
||||
|
||||
const int entityCount = 25_000;
|
||||
var rng = new System.Random(0x5EED);
|
||||
|
||||
for (var i = 1; i <= entityCount; i++)
|
||||
{
|
||||
workers[i] = new SerializationThreadWorker(i, source);
|
||||
workers[i].AllocateHeap();
|
||||
var serial = (Serial)(uint)i;
|
||||
persistence.EntitiesBySerial[serial] = new RoundTripEntity(serial)
|
||||
{
|
||||
Value = rng.Next(),
|
||||
Name = i % 5 == 0 ? null : $"entity-{i}"
|
||||
};
|
||||
}
|
||||
|
||||
var previousWorkers = World._threadWorkers;
|
||||
World._threadWorkers = workers;
|
||||
persistence.RegisterType(typeof(RoundTripEntity));
|
||||
|
||||
var persistence = new RoundTripPersistence(2000);
|
||||
RoundTripPersistence loaded = null;
|
||||
// Freeze: what Persistence.SerializeAll + GenericEntityPersistence.Serialize do,
|
||||
// against this test's chunk source instead of the world's.
|
||||
pipeline.WakeWorkers();
|
||||
|
||||
var dir = Path.Combine(Path.GetTempPath(), $"muo-roundtrip-{Guid.NewGuid():N}");
|
||||
Directory.CreateDirectory(dir);
|
||||
source.SetOwner(persistence);
|
||||
source.PushSingle(persistence);
|
||||
Assert.True(persistence.TrySnapshotEntries(out var slotCount));
|
||||
source.PushSlotRanges(persistence, slotCount);
|
||||
|
||||
try
|
||||
pipeline.FlushAndSleepWorkers();
|
||||
|
||||
// Background write phase: snapshot from the segment logs. v4 embeds the type
|
||||
// table in the idx, so no SerializedTypes.db is produced or needed.
|
||||
persistence.WriteSnapshot(dir);
|
||||
|
||||
persistence.PostWorldSave(); // releases the entries snapshot
|
||||
|
||||
// Load into a fresh persistence, like a server boot would.
|
||||
var loaded = pipeline.Track(new RoundTripPersistence(2001));
|
||||
loaded.DeserializeIndexes(dir, null);
|
||||
loaded.Deserialize(dir, null);
|
||||
|
||||
Assert.True(loaded.SelfPayloadDeserialized);
|
||||
Assert.Equal(persistence.EntitiesBySerial.Count, loaded.EntitiesBySerial.Count);
|
||||
|
||||
foreach (var (serial, original) in persistence.EntitiesBySerial)
|
||||
{
|
||||
const int entityCount = 25_000;
|
||||
var rng = new System.Random(0x5EED);
|
||||
|
||||
for (var i = 1; i <= entityCount; i++)
|
||||
{
|
||||
var serial = (Serial)(uint)i;
|
||||
persistence.EntitiesBySerial[serial] = new RoundTripEntity(serial)
|
||||
{
|
||||
Value = rng.Next(),
|
||||
Name = i % 5 == 0 ? null : $"entity-{i}"
|
||||
};
|
||||
}
|
||||
|
||||
persistence.RegisterType(typeof(RoundTripEntity));
|
||||
|
||||
// Freeze: what Persistence.SerializeAll + GenericEntityPersistence.Serialize do,
|
||||
// against this test's chunk source instead of the world's.
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Wake();
|
||||
}
|
||||
|
||||
source.SetOwner(persistence);
|
||||
source.PushSingle(persistence);
|
||||
Assert.True(persistence.TrySnapshotEntries(out var slotCount));
|
||||
source.PushSlotRanges(persistence, slotCount);
|
||||
|
||||
// Mirrors World.PauseSerializationThreads
|
||||
source.Flush();
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Sleep();
|
||||
}
|
||||
|
||||
// Background write phase: snapshot from the segment logs. v4 embeds the type
|
||||
// table in the idx, so no SerializedTypes.db is produced or needed.
|
||||
persistence.WriteSnapshot(dir);
|
||||
|
||||
persistence.PostWorldSave(); // releases the entries snapshot
|
||||
|
||||
// Load into a fresh persistence, like a server boot would.
|
||||
loaded = new RoundTripPersistence(2001);
|
||||
loaded.DeserializeIndexes(dir, null);
|
||||
loaded.Deserialize(dir, null);
|
||||
|
||||
Assert.True(loaded.SelfPayloadDeserialized);
|
||||
Assert.Equal(persistence.EntitiesBySerial.Count, loaded.EntitiesBySerial.Count);
|
||||
|
||||
foreach (var (serial, original) in persistence.EntitiesBySerial)
|
||||
{
|
||||
var entity = loaded.EntitiesBySerial[serial];
|
||||
Assert.Equal(original.Value, entity.Value);
|
||||
Assert.Equal(original.Name, entity.Name);
|
||||
Assert.Equal(original.Created.Ticks, entity.Created.Ticks);
|
||||
}
|
||||
|
||||
// Loading must hydrate the type table so the next save can write indexes.
|
||||
Assert.True(loaded.TryGetTypeIndex(typeof(RoundTripEntity), out _));
|
||||
var entity = loaded.EntitiesBySerial[serial];
|
||||
Assert.Equal(original.Value, entity.Value);
|
||||
Assert.Equal(original.Name, entity.Name);
|
||||
Assert.Equal(original.Created.Ticks, entity.Created.Ticks);
|
||||
}
|
||||
finally
|
||||
{
|
||||
persistence.Unregister();
|
||||
loaded?.Unregister();
|
||||
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Exit();
|
||||
}
|
||||
|
||||
World._threadWorkers = previousWorkers;
|
||||
AssemblyHandler.Assemblies = previousAssemblies;
|
||||
Directory.Delete(dir, true);
|
||||
}
|
||||
// Loading must hydrate the type table so the next save can write indexes.
|
||||
Assert.True(loaded.TryGetTypeIndex(typeof(RoundTripEntity), out _));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
|
@ -179,70 +142,44 @@ public class GenericEntityPersistenceRoundTripTests
|
|||
[Fact]
|
||||
public void SerializerException_IsRecordedOnTheWorker_AndTheDrainCompletes()
|
||||
{
|
||||
var source = new SerializationChunkSource();
|
||||
var workers = new SerializationThreadWorker[2];
|
||||
for (var i = 0; i < workers.Length; i++)
|
||||
using var pipeline = new PersistencePipelineScope(2);
|
||||
var source = pipeline.Source;
|
||||
var workers = pipeline.Workers;
|
||||
|
||||
var persistence = pipeline.Track(new RoundTripPersistence(2002));
|
||||
|
||||
for (var i = 1; i <= 100; i++)
|
||||
{
|
||||
workers[i] = new SerializationThreadWorker(i, source);
|
||||
workers[i].AllocateHeap();
|
||||
var serial = (Serial)(uint)i;
|
||||
persistence.EntitiesBySerial[serial] = i == 50
|
||||
? new ThrowingRoundTripEntity(serial)
|
||||
: new RoundTripEntity(serial) { Value = i, Name = $"entity-{i}" };
|
||||
}
|
||||
|
||||
var persistence = new RoundTripPersistence(2002);
|
||||
pipeline.WakeWorkers();
|
||||
|
||||
try
|
||||
source.SetOwner(persistence);
|
||||
Assert.True(persistence.TrySnapshotEntries(out var slotCount));
|
||||
source.PushSlotRanges(persistence, slotCount);
|
||||
|
||||
pipeline.FlushAndSleepWorkers();
|
||||
|
||||
Exception error = null;
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
for (var i = 1; i <= 100; i++)
|
||||
{
|
||||
var serial = (Serial)(uint)i;
|
||||
persistence.EntitiesBySerial[serial] = i == 50
|
||||
? new ThrowingRoundTripEntity(serial)
|
||||
: new RoundTripEntity(serial) { Value = i, Name = $"entity-{i}" };
|
||||
}
|
||||
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Wake();
|
||||
}
|
||||
|
||||
source.SetOwner(persistence);
|
||||
Assert.True(persistence.TrySnapshotEntries(out var slotCount));
|
||||
source.PushSlotRanges(persistence, slotCount);
|
||||
source.Flush();
|
||||
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Sleep();
|
||||
}
|
||||
|
||||
Exception error = null;
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
error ??= worker.Error;
|
||||
}
|
||||
|
||||
Assert.IsType<InvalidOperationException>(error);
|
||||
persistence.PostWorldSave();
|
||||
|
||||
// The next drain starts clean.
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Wake();
|
||||
}
|
||||
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Sleep();
|
||||
Assert.Null(worker.Error);
|
||||
}
|
||||
error ??= worker.Error;
|
||||
}
|
||||
finally
|
||||
{
|
||||
persistence.Unregister();
|
||||
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Exit();
|
||||
}
|
||||
Assert.IsType<InvalidOperationException>(error);
|
||||
persistence.PostWorldSave();
|
||||
|
||||
// The next drain starts clean.
|
||||
pipeline.WakeWorkers();
|
||||
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Sleep();
|
||||
Assert.Null(worker.Error);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -253,60 +190,28 @@ public class GenericEntityPersistenceRoundTripTests
|
|||
[Fact]
|
||||
public void WriteSnapshot_FailsTheSave_InsteadOfDroppingASegment()
|
||||
{
|
||||
var source = new SerializationChunkSource();
|
||||
var workers = new SerializationThreadWorker[2];
|
||||
for (var i = 0; i < workers.Length; i++)
|
||||
using var pipeline = new PersistencePipelineScope(2, installWorkers: true, directoryPrefix: "muo-segmentfail");
|
||||
var source = pipeline.Source;
|
||||
|
||||
var persistence = pipeline.Track(new RoundTripPersistence(2003));
|
||||
|
||||
for (var i = 1; i <= 100; i++)
|
||||
{
|
||||
workers[i] = new SerializationThreadWorker(i, source);
|
||||
workers[i].AllocateHeap();
|
||||
var serial = (Serial)(uint)i;
|
||||
persistence.EntitiesBySerial[serial] = new RoundTripEntity(serial) { Value = i, Name = $"entity-{i}" };
|
||||
}
|
||||
|
||||
var previousWorkers = World._threadWorkers;
|
||||
World._threadWorkers = workers;
|
||||
// Deliberately not registered: the writer cannot index the type.
|
||||
|
||||
var persistence = new RoundTripPersistence(2003);
|
||||
var dir = Path.Combine(Path.GetTempPath(), $"muo-segmentfail-{Guid.NewGuid():N}");
|
||||
Directory.CreateDirectory(dir);
|
||||
pipeline.WakeWorkers();
|
||||
|
||||
try
|
||||
{
|
||||
for (var i = 1; i <= 100; i++)
|
||||
{
|
||||
var serial = (Serial)(uint)i;
|
||||
persistence.EntitiesBySerial[serial] = new RoundTripEntity(serial) { Value = i, Name = $"entity-{i}" };
|
||||
}
|
||||
source.SetOwner(persistence);
|
||||
Assert.True(persistence.TrySnapshotEntries(out var slotCount));
|
||||
source.PushSlotRanges(persistence, slotCount);
|
||||
|
||||
// Deliberately not registered: the writer cannot index the type.
|
||||
pipeline.FlushAndSleepWorkers();
|
||||
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Wake();
|
||||
}
|
||||
|
||||
source.SetOwner(persistence);
|
||||
Assert.True(persistence.TrySnapshotEntries(out var slotCount));
|
||||
source.PushSlotRanges(persistence, slotCount);
|
||||
source.Flush();
|
||||
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Sleep();
|
||||
}
|
||||
|
||||
Assert.Throws<InvalidOperationException>(() => persistence.WriteSnapshot(dir));
|
||||
persistence.PostWorldSave();
|
||||
}
|
||||
finally
|
||||
{
|
||||
persistence.Unregister();
|
||||
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Exit();
|
||||
}
|
||||
|
||||
World._threadWorkers = previousWorkers;
|
||||
Directory.Delete(dir, true);
|
||||
}
|
||||
Assert.Throws<InvalidOperationException>(() => persistence.WriteSnapshot(pipeline.Directory));
|
||||
persistence.PostWorldSave();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -199,114 +199,91 @@ public class SerializationChunkSourceTests
|
|||
[Fact]
|
||||
public void WorkersDrainAllEntitiesAndLogSegments()
|
||||
{
|
||||
var source = new SerializationChunkSource();
|
||||
var owner = new TestPersistence { PayloadSize = 512 * 1024 };
|
||||
var workers = new SerializationThreadWorker[2];
|
||||
for (var i = 0; i < workers.Length; i++)
|
||||
using var pipeline = new PersistencePipelineScope(2);
|
||||
var source = pipeline.Source;
|
||||
var workers = pipeline.Workers;
|
||||
var owner = pipeline.Track(new TestPersistence { PayloadSize = 512 * 1024 });
|
||||
|
||||
var entities = new List<TestEntity>();
|
||||
for (var i = 0; i < 10_000; i++)
|
||||
{
|
||||
workers[i] = new SerializationThreadWorker(i, source);
|
||||
workers[i].AllocateHeap();
|
||||
entities.Add(new TestEntity { PayloadSize = 16 + i % 64 });
|
||||
}
|
||||
|
||||
try
|
||||
pipeline.WakeWorkers();
|
||||
|
||||
// A large payload published as a dedicated single chunk (a persistence
|
||||
// self-payload), interleaved with the bare entity stream.
|
||||
source.SetOwner(owner);
|
||||
for (var i = 0; i < entities.Count; i++)
|
||||
{
|
||||
var entities = new List<TestEntity>();
|
||||
for (var i = 0; i < 10_000; i++)
|
||||
if (i == 5000)
|
||||
{
|
||||
entities.Add(new TestEntity { PayloadSize = 16 + i % 64 });
|
||||
source.PushSingle(owner);
|
||||
}
|
||||
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Wake();
|
||||
}
|
||||
source.Push(entities[i]);
|
||||
}
|
||||
|
||||
// A large payload published as a dedicated single chunk (a persistence
|
||||
// self-payload), interleaved with the bare entity stream.
|
||||
source.SetOwner(owner);
|
||||
for (var i = 0; i < entities.Count; i++)
|
||||
pipeline.FlushAndSleepWorkers();
|
||||
|
||||
long totalEntities = 0;
|
||||
long totalBytes = 0;
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
totalEntities += worker.EntitiesSerialized;
|
||||
totalBytes += worker.BytesSerialized;
|
||||
}
|
||||
|
||||
Assert.Equal(entities.Count + 1, totalEntities);
|
||||
|
||||
// The self-payload recorded its placement on the persistence itself.
|
||||
var (selfThread, selfPosition, selfLength) = owner.Placement;
|
||||
Assert.Equal(owner.PayloadSize, selfLength);
|
||||
Assert.InRange(selfThread, (byte)0, (byte)(workers.Length - 1));
|
||||
var selfHeap = workers[selfThread].GetHeap(selfPosition, selfLength);
|
||||
Assert.Equal(0, selfHeap[0]);
|
||||
Assert.Equal((selfLength - 1) & 0xFF, selfHeap[^1]);
|
||||
|
||||
// Every entity appears exactly once in the worker segment logs, with a
|
||||
// consistent span on that worker's heap: positions are implicit (contiguous
|
||||
// writes), identity comes from the buffer-entities log.
|
||||
var seen = new HashSet<TestEntity>();
|
||||
long expectedBytes = owner.PayloadSize;
|
||||
foreach (var e in entities)
|
||||
{
|
||||
expectedBytes += e.PayloadSize;
|
||||
}
|
||||
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
var lengths = worker.Lengths;
|
||||
var bufferEntities = worker.BufferEntities;
|
||||
|
||||
foreach (var segment in worker.Segments)
|
||||
{
|
||||
if (i == 5000)
|
||||
Assert.Same(owner, segment.Owner);
|
||||
Assert.Equal(-1, segment.SlotOffset);
|
||||
|
||||
var heapPos = (int)segment.HeapStart;
|
||||
for (var i = 0; i < segment.RecordCount; i++)
|
||||
{
|
||||
source.PushSingle(owner);
|
||||
}
|
||||
var entity = (TestEntity)bufferEntities[segment.EntitiesStart + i];
|
||||
var length = lengths[segment.LengthsStart + i];
|
||||
|
||||
source.Push(entities[i]);
|
||||
}
|
||||
Assert.True(seen.Add(entity));
|
||||
Assert.Equal(entity.PayloadSize, length);
|
||||
|
||||
// Mirrors World.PauseSerializationThreads
|
||||
source.Flush();
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Sleep();
|
||||
}
|
||||
var heap = workers[Array.IndexOf(workers, worker)].GetHeap(heapPos, length);
|
||||
Assert.Equal(0, heap[0]);
|
||||
Assert.Equal((length - 1) & 0xFF, heap[^1]);
|
||||
|
||||
long totalEntities = 0;
|
||||
long totalBytes = 0;
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
totalEntities += worker.EntitiesSerialized;
|
||||
totalBytes += worker.BytesSerialized;
|
||||
}
|
||||
|
||||
Assert.Equal(entities.Count + 1, totalEntities);
|
||||
|
||||
// The self-payload recorded its placement on the persistence itself.
|
||||
var (selfThread, selfPosition, selfLength) = owner.Placement;
|
||||
Assert.Equal(owner.PayloadSize, selfLength);
|
||||
Assert.InRange(selfThread, (byte)0, (byte)(workers.Length - 1));
|
||||
var selfHeap = workers[selfThread].GetHeap(selfPosition, selfLength);
|
||||
Assert.Equal(0, selfHeap[0]);
|
||||
Assert.Equal((selfLength - 1) & 0xFF, selfHeap[^1]);
|
||||
|
||||
// Every entity appears exactly once in the worker segment logs, with a
|
||||
// consistent span on that worker's heap: positions are implicit (contiguous
|
||||
// writes), identity comes from the buffer-entities log.
|
||||
var seen = new HashSet<TestEntity>();
|
||||
long expectedBytes = owner.PayloadSize;
|
||||
foreach (var e in entities)
|
||||
{
|
||||
expectedBytes += e.PayloadSize;
|
||||
}
|
||||
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
var lengths = worker.Lengths;
|
||||
var bufferEntities = worker.BufferEntities;
|
||||
|
||||
foreach (var segment in worker.Segments)
|
||||
{
|
||||
Assert.Same(owner, segment.Owner);
|
||||
Assert.Equal(-1, segment.SlotOffset);
|
||||
|
||||
var heapPos = (int)segment.HeapStart;
|
||||
for (var i = 0; i < segment.RecordCount; i++)
|
||||
{
|
||||
var entity = (TestEntity)bufferEntities[segment.EntitiesStart + i];
|
||||
var length = lengths[segment.LengthsStart + i];
|
||||
|
||||
Assert.True(seen.Add(entity));
|
||||
Assert.Equal(entity.PayloadSize, length);
|
||||
|
||||
var heap = workers[Array.IndexOf(workers, worker)].GetHeap(heapPos, length);
|
||||
Assert.Equal(0, heap[0]);
|
||||
Assert.Equal((length - 1) & 0xFF, heap[^1]);
|
||||
|
||||
heapPos += length;
|
||||
}
|
||||
heapPos += length;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Assert.Equal(entities.Count, seen.Count);
|
||||
Assert.Equal(expectedBytes, totalBytes);
|
||||
}
|
||||
finally
|
||||
{
|
||||
owner.Unregister();
|
||||
foreach (var worker in workers)
|
||||
{
|
||||
worker.Exit();
|
||||
}
|
||||
}
|
||||
Assert.Equal(entities.Count, seen.Count);
|
||||
Assert.Equal(expectedBytes, totalBytes);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,3 +1,4 @@
|
|||
using System.Reflection;
|
||||
using Xunit;
|
||||
|
||||
namespace Server.Tests;
|
||||
|
|
@ -5,20 +6,38 @@ namespace Server.Tests;
|
|||
[Collection("Sequential Server Tests")]
|
||||
public class VirtualSerialTests
|
||||
{
|
||||
// Walking up from ResetVirtualSerial takes ~17.9 million draws; start just short of the wrap.
|
||||
private const uint DrawsBeforeMax = 1000;
|
||||
|
||||
private static readonly FieldInfo _nextVirtualSerial =
|
||||
typeof(World).GetField("_nextVirtualSerial", BindingFlags.NonPublic | BindingFlags.Static);
|
||||
|
||||
[Fact]
|
||||
public void TestNewVirtualGetsAndRollover()
|
||||
{
|
||||
// Acquire virtual serials until we hit the max
|
||||
var lastSerial = World.NewVirtual;
|
||||
do
|
||||
{
|
||||
var virtualSerial = World.NewVirtual;
|
||||
Assert.Equal(lastSerial + 1, virtualSerial);
|
||||
lastSerial = (Serial) (uint) virtualSerial;
|
||||
} while (lastSerial != World.MaxVirtualSerial);
|
||||
Assert.NotNull(_nextVirtualSerial);
|
||||
|
||||
// Next one should be MaxItemSerial (the first VirtualSerial) due to rollover
|
||||
var nextSerial = World.NewVirtual;
|
||||
Assert.Equal(nextSerial, (Serial)World.ResetVirtualSerial);
|
||||
var saved = (uint)_nextVirtualSerial.GetValue(null);
|
||||
_nextVirtualSerial.SetValue(null, World.MaxVirtualSerial - DrawsBeforeMax);
|
||||
|
||||
try
|
||||
{
|
||||
// Acquire virtual serials until we hit the max
|
||||
var lastSerial = World.NewVirtual;
|
||||
do
|
||||
{
|
||||
var virtualSerial = World.NewVirtual;
|
||||
Assert.Equal(lastSerial + 1, virtualSerial);
|
||||
lastSerial = (Serial)(uint)virtualSerial;
|
||||
} while (lastSerial != World.MaxVirtualSerial);
|
||||
|
||||
// Next one should be MaxItemSerial (the first VirtualSerial) due to rollover
|
||||
var nextSerial = World.NewVirtual;
|
||||
Assert.Equal(nextSerial, (Serial)World.ResetVirtualSerial);
|
||||
}
|
||||
finally
|
||||
{
|
||||
_nextVirtualSerial.SetValue(null, saved);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue