9a25054809
## Summary Many tests proved a specific change when it landed but don't need to run on every CI build forever. This removes **202 test methods and 9 files: 313 test cases, 2,247 → 1,934**. UOContent.Tests drops from about 14s to about 5s locally. Removed: - **Tautologies.** Asserting a constant, a constructor readback or a trivial getter, or testing BCL behavior. - **Exact duplicates** of a surviving test on the same code path. - **Obsolete regressions** whose failure can no longer be expressed. - **Game-content values** shard owners customize (era drop rates, loot and skill tables, single-creature tuning). Each customization would otherwise force a test fix. ## How it was decided 1. Every test was classified, with a reason, by a per-shard sweep over all 287 test files. 2. Each proposed deletion was then checked by a second, adversarial reviewer against the surviving tests and the production code. 3. Anything that was the only coverage of a separate code path was **kept**, even where it looked like a duplicate. Examples: the unsigned `SpanReader`/`SpanWriter` methods, the at-location versus bounds enumerators, null-map enumerables, the security filters, archive-journal state transitions. About 130 proposed deletions were rejected this way. Whole files removed: - `FishingTests`, apart from 3 tests: the map-edge scan, serpent cleanup, and SOS chest consumption. The SOS test now stops at the first chest instead of measuring a catch rate. The multi-million-cast rate simulations are gone. - `LordOaksTests` and `MeerEnragedTests` (single-creature tests). - `AutoArchiveHelperTests`, `JsonDiscoverableTypeAttributeTests`, `DecimalSerializationTests` and `EnumConversionTests` (tautologies, or tests of their own local helpers). - `NetworkStatsTests`. - `MigratedDataLoadTests` (a subset of `AllSpawnFilesLoadTests`). - `SpawnerFixtureCapture`: a capture tool, not a test, and its `version == 12` assert can no longer pass. The `.bin` fixtures it produced stay. ## Tests - Server.Tests: 811 pass. - UOContent.Tests: 1,123 pass. A follow-up PR, stacked on this one, fixes how the remaining tests behave: shared state, CI-vacuous tests, harness duplication.
519 lines
13 KiB
C#
519 lines
13 KiB
C#
using System;
|
|
using System.Buffers;
|
|
using System.IO;
|
|
using Xunit;
|
|
|
|
namespace Server.Tests.Buffers;
|
|
|
|
public class SpanWriterTests
|
|
{
|
|
[Fact]
|
|
public unsafe void TestSpanWriterResizes()
|
|
{
|
|
Span<byte> smallStack = stackalloc byte[8];
|
|
var writer = new SpanWriter(smallStack, true);
|
|
writer.Write(0x1024L);
|
|
writer.Write(0x1024L);
|
|
|
|
var span = writer.RawBuffer;
|
|
fixed (byte* spanPtr = span)
|
|
{
|
|
fixed (byte* stackPtr = smallStack)
|
|
{
|
|
Assert.True(spanPtr != stackPtr);
|
|
}
|
|
}
|
|
|
|
Assert.True(span.Length > smallStack.Length);
|
|
writer.Dispose();
|
|
}
|
|
|
|
[Fact]
|
|
public unsafe void TestSpanWriterOnlyStackAlloc()
|
|
{
|
|
Span<byte> smallStack = stackalloc byte[8];
|
|
var writer = new SpanWriter(smallStack, true);
|
|
writer.Write(0x1024L);
|
|
|
|
var span = writer.RawBuffer;
|
|
fixed (byte* spanPtr = span)
|
|
{
|
|
fixed (byte* stackPtr = smallStack)
|
|
{
|
|
Assert.True(spanPtr == stackPtr);
|
|
}
|
|
}
|
|
|
|
Assert.Equal(8, span.Length);
|
|
AssertThat.Equal(smallStack, [0, 0, 0, 0, 0, 0, 0x10, 0x24]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestSpanWriterNoResizeThrows()
|
|
{
|
|
Assert.Throws<InvalidOperationException>(
|
|
() =>
|
|
{
|
|
Span<byte> smallStack = stackalloc byte[8];
|
|
var writer = new SpanWriter(smallStack);
|
|
writer.Write(0x1024L);
|
|
writer.Write(0x1024L);
|
|
}
|
|
);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteBool()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[2];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.Write(true);
|
|
writer.Write(false);
|
|
|
|
Assert.Equal(2, writer.Position);
|
|
AssertThat.Equal(writer.Span, [1, 0]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteSByte()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[2];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.Write((sbyte)-1);
|
|
writer.Write((sbyte)127);
|
|
|
|
Assert.Equal(2, writer.Position);
|
|
AssertThat.Equal(writer.Span, [0xFF, 0x7F]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteInt16BigEndian()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[2];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.Write((short)0x1234);
|
|
|
|
Assert.Equal(2, writer.Position);
|
|
AssertThat.Equal(writer.Span, [0x12, 0x34]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteInt16LittleEndian()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[2];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.WriteLE((short)0x1234);
|
|
|
|
Assert.Equal(2, writer.Position);
|
|
AssertThat.Equal(writer.Span, [0x34, 0x12]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteUInt16BigEndian()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[2];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.Write((ushort)0x1234);
|
|
|
|
Assert.Equal(2, writer.Position);
|
|
AssertThat.Equal(writer.Span, [0x12, 0x34]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteUInt16LittleEndian()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[2];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.WriteLE((ushort)0x1234);
|
|
|
|
Assert.Equal(2, writer.Position);
|
|
AssertThat.Equal(writer.Span, [0x34, 0x12]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteInt32BigEndian()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[4];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.Write(0x12345678);
|
|
|
|
Assert.Equal(4, writer.Position);
|
|
AssertThat.Equal(writer.Span, [0x12, 0x34, 0x56, 0x78]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteInt32LittleEndian()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[4];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.WriteLE(0x12345678);
|
|
|
|
Assert.Equal(4, writer.Position);
|
|
AssertThat.Equal(writer.Span, [0x78, 0x56, 0x34, 0x12]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteUInt32BigEndian()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[4];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.Write(0x12345678u);
|
|
|
|
Assert.Equal(4, writer.Position);
|
|
AssertThat.Equal(writer.Span, [0x12, 0x34, 0x56, 0x78]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteUInt32LittleEndian()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[4];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.WriteLE(0x12345678u);
|
|
|
|
Assert.Equal(4, writer.Position);
|
|
AssertThat.Equal(writer.Span, [0x78, 0x56, 0x34, 0x12]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteInt64BigEndian()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[8];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.Write(0x123456789ABCDEF0L);
|
|
|
|
Assert.Equal(8, writer.Position);
|
|
AssertThat.Equal(writer.Span, [0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteUInt64BigEndian()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[8];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.Write(0x123456789ABCDEF0UL);
|
|
|
|
Assert.Equal(8, writer.Position);
|
|
AssertThat.Equal(writer.Span, [0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteSpan()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[6];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
ReadOnlySpan<byte> data = [0x01, 0x02, 0x03];
|
|
writer.Write(data);
|
|
writer.Write(data);
|
|
|
|
Assert.Equal(6, writer.Position);
|
|
AssertThat.Equal(writer.Span, [0x01, 0x02, 0x03, 0x01, 0x02, 0x03]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteAsciiString()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[5];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.WriteAscii("Hello");
|
|
|
|
Assert.Equal(5, writer.Position);
|
|
AssertThat.Equal(writer.Span, "Hello"u8);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteAsciiStringNull()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[6];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.WriteAsciiNull("Hello");
|
|
|
|
Assert.Equal(6, writer.Position);
|
|
AssertThat.Equal(writer.Span, "Hello\0"u8);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteAsciiStringFixedLength()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[10];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.WriteAscii("Hello", 10);
|
|
|
|
Assert.Equal(10, writer.Position);
|
|
AssertThat.Equal(writer.Span, "Hello\0\0\0\0\0"u8);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteUTF8String()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[5];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.WriteUTF8("Hello");
|
|
|
|
Assert.Equal(5, writer.Position);
|
|
AssertThat.Equal(writer.Span, "Hello"u8);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteUTF8StringNull()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[6];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.WriteUTF8Null("Hello");
|
|
|
|
Assert.Equal(6, writer.Position);
|
|
AssertThat.Equal(writer.Span, "Hello\0"u8);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteLittleUniString()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[10];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.WriteLittleUni("Hello");
|
|
|
|
Assert.Equal(10, writer.Position);
|
|
AssertThat.Equal(writer.Span, "H\0e\0l\0l\0o\0"u8);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteLittleUniStringNull()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[12];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.WriteLittleUniNull("Hello");
|
|
|
|
Assert.Equal(12, writer.Position);
|
|
AssertThat.Equal(writer.Span, "H\0e\0l\0l\0o\0\0\0"u8);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteBigUniString()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[10];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.WriteBigUni("Hello");
|
|
|
|
Assert.Equal(10, writer.Position);
|
|
AssertThat.Equal(writer.Span, "\0H\0e\0l\0l\0o"u8);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestWriteBigUniStringNull()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[12];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.WriteBigUniNull("Hello");
|
|
|
|
Assert.Equal(12, writer.Position);
|
|
AssertThat.Equal(writer.Span, "\0H\0e\0l\0l\0o\0\0"u8);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestClear()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[10];
|
|
buffer.Fill(0xFF);
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.Write((byte)0x01);
|
|
writer.Clear(5);
|
|
writer.Write((byte)0x02);
|
|
|
|
Assert.Equal(7, writer.Position);
|
|
AssertThat.Equal(writer.Span, [0x01, 0, 0, 0, 0, 0, 0x02]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestSeekBegin()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[10];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.Write((byte)0x01);
|
|
writer.Write((byte)0x02);
|
|
writer.Write((byte)0x03);
|
|
|
|
var pos = writer.Seek(1, SeekOrigin.Begin);
|
|
|
|
Assert.Equal(1, pos);
|
|
Assert.Equal(1, writer.Position);
|
|
Assert.Equal(3, writer.BytesWritten);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestSeekCurrent()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[10];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.Write((byte)0x01);
|
|
writer.Write((byte)0x02);
|
|
|
|
var pos = writer.Seek(2, SeekOrigin.Current);
|
|
|
|
Assert.Equal(4, pos);
|
|
Assert.Equal(4, writer.Position);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestSeekEnd()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[10];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.Write((byte)0x01);
|
|
writer.Write((byte)0x02);
|
|
writer.Write((byte)0x03);
|
|
|
|
var pos = writer.Seek(-1, SeekOrigin.End);
|
|
|
|
Assert.Equal(2, pos);
|
|
Assert.Equal(2, writer.Position);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestSeekNegativeThrows()
|
|
{
|
|
Assert.Throws<ArgumentOutOfRangeException>(
|
|
() =>
|
|
{
|
|
Span<byte> buffer = stackalloc byte[10];
|
|
var writer = new SpanWriter(buffer);
|
|
writer.Seek(-1, SeekOrigin.Begin);
|
|
}
|
|
);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestSeekBeyondCapacityNoResizeThrows()
|
|
{
|
|
Assert.Throws<InvalidOperationException>(
|
|
() =>
|
|
{
|
|
Span<byte> buffer = stackalloc byte[10];
|
|
var writer = new SpanWriter(buffer);
|
|
writer.Seek(20, SeekOrigin.Begin);
|
|
}
|
|
);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestSeekBeyondCapacityWithResize()
|
|
{
|
|
var writer = new SpanWriter(10, true);
|
|
|
|
var pos = writer.Seek(20, SeekOrigin.Begin);
|
|
|
|
Assert.Equal(20, pos);
|
|
Assert.True(writer.Capacity >= 20);
|
|
writer.Dispose();
|
|
}
|
|
|
|
[Fact]
|
|
public void TestEnsureCapacityNoResizeThrows()
|
|
{
|
|
Assert.Throws<InvalidOperationException>(
|
|
() =>
|
|
{
|
|
Span<byte> buffer = stackalloc byte[10];
|
|
var writer = new SpanWriter(buffer);
|
|
writer.EnsureCapacity(20);
|
|
}
|
|
);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestEnsureCapacityWithResize()
|
|
{
|
|
var writer = new SpanWriter(10, true);
|
|
|
|
writer.EnsureCapacity(50);
|
|
|
|
Assert.True(writer.Capacity >= 50);
|
|
writer.Dispose();
|
|
}
|
|
|
|
[Fact]
|
|
public void TestToSpanWithStackAlloc()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[10];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
writer.Write((byte)0x01);
|
|
writer.Write((byte)0x02);
|
|
writer.Write((byte)0x03);
|
|
|
|
using var owner = writer.ToSpan();
|
|
|
|
Assert.Equal(3, owner.Span.Length);
|
|
AssertThat.Equal(owner.Span, [0x01, 0x02, 0x03]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestToSpanWithRentedBuffer()
|
|
{
|
|
var writer = new SpanWriter(10);
|
|
|
|
writer.Write((byte)0x01);
|
|
writer.Write((byte)0x02);
|
|
writer.Write((byte)0x03);
|
|
|
|
using var owner = writer.ToSpan();
|
|
|
|
Assert.Equal(3, owner.Span.Length);
|
|
AssertThat.Equal(owner.Span, [0x01, 0x02, 0x03]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestToSpanEmpty()
|
|
{
|
|
var writer = new SpanWriter(10);
|
|
|
|
using var owner = writer.ToSpan();
|
|
|
|
Assert.Equal(0, owner.Span.Length);
|
|
}
|
|
|
|
[Fact]
|
|
public void TestBytesWritten()
|
|
{
|
|
Span<byte> buffer = stackalloc byte[10];
|
|
var writer = new SpanWriter(buffer);
|
|
|
|
Assert.Equal(0, writer.BytesWritten);
|
|
|
|
writer.Write((byte)0x01);
|
|
Assert.Equal(1, writer.BytesWritten);
|
|
|
|
writer.Write((ushort)0x0203);
|
|
Assert.Equal(3, writer.BytesWritten);
|
|
|
|
writer.Seek(1, SeekOrigin.Begin);
|
|
Assert.Equal(3, writer.BytesWritten);
|
|
|
|
writer.Write((byte)0xFF);
|
|
Assert.Equal(3, writer.BytesWritten);
|
|
}
|
|
}
|