erik/acdream
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 2
acdream/tests/AcDream.Runtime.Tests/Session/LiveSessionControllerCharacterCreationTests.cs
Erik 3a6b7e3115 fix(runtime)+docs: CC3 re-review CLOSED — R1 second-create wire slot, risk-8 measured LATENT 
The CC3 narrow re-review returned CLOSED (both lenses PASS, merge
recommended) with residual R1: the post-create wire-slot assignment read
the cached wire CharacterList count, which ACE never refreshes after a
create — correct for the first create, off by one for a second create in
the same session (reachable via create Ok -> server-rejected guid enter
-> ReturnToSelection -> create again), the same wire-contract failure
class F2 fixed. Root fix now rather than carried: a
creates-since-CharacterList counter (the equivalent of retail's own
CharacterSet growing via AddIdentity per create), reset on every fresh
wire CharacterList apply and at generation reset, applied only to the
cached-wire branch since the display-roster fallback already contains
prior appends. Regression test drives the full
create->Ok->rejected-enter->create-again flow and pins wire slots
0/1/2/3.

Docs: CC3 ledger row flipped to REVIEW-CLOSED with real shas (re-review
R2); CC7 risk item 8 downgraded to LATENT with measured installed-DAT
data (user-prompted): every heritage's single cost override is Arcane
Lore at NormalCost=0/PrimaryCost=2 vs global 4/6, so ACE's over-deduction
(= NormalCost = 0) cannot fire with end-of-retail data — the earlier
"may be rejected" claim was inferred from code without measuring.

Runtime 1707/0 Release.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-08-15 15:20:03 +02:00

516 lines
24 KiB
C#
Raw Blame History

using System.Buffers.Binary;
using System.Net;
using System.Reflection;
using System.Text;
using AcDream.Core.CharGen;
using AcDream.Core.Net;
using AcDream.Core.Net.Messages;
using AcDream.Core.Net.Packets;
using AcDream.Runtime;
using AcDream.Runtime.Session;
using AcDream.Runtime.Tests.CharGen;
namespace AcDream.Runtime.Tests.Session;
/// <summary>
/// Campaign CC slice CC3: <see cref="LiveSessionController"/>'s
/// character-creation integration — the wire send (via a REAL
/// <see cref="WorldSession"/> + <c>GameMessageCapture</c>, the same seam
/// <c>WorldSessionCharacterCreationTests</c> uses in Core.Net) and the
/// Ok-response round trip (roster append reusing
/// <see cref="RuntimeCharacterSelectionState.ApplyRoster"/>, the reused
/// <c>EnterSelectedCore</c> log-straight-in, and the new
/// <see cref="ILiveSessionLifecycleHost.ApplyCharacterCreated"/>/
/// <see cref="ILiveSessionLifecycleHost.ApplyCreationFailed"/> hooks) via a
/// real inbound <c>0xF643</c> packet through <c>WorldSession.ProcessDatagram</c>
/// (reflection — the same private test seam Core.Net's own creation tests
/// use).
/// </summary>
public sealed class LiveSessionControllerCharacterCreationTests
{
private sealed class TestTransport : IWorldSessionTransport
{
public void Send(ReadOnlySpan<byte> datagram) { }
public void Send(IPEndPoint remote, ReadOnlySpan<byte> datagram) { }
public int Receive(Span<byte> destination, TimeSpan timeout, out IPEndPoint? from)
{
from = null;
return -1;
}
public ValueTask<NetReceiveResult> ReceiveAsync(
Memory<byte> destination,
CancellationToken cancellationToken) =>
throw new OperationCanceledException(cancellationToken);
public void Dispose() { }
}
private sealed class TestOperations : ILiveSessionOperations
{
public List<WorldSession> Sessions { get; } = [];
public int EnterWorldCount { get; private set; }
/// <summary>F1/F11: captures every guid-based enter call so the
/// post-create log-straight-in can be asserted against the EXACT
/// identity sent, instead of a bare counter that cannot tell an
/// index-based call from a guid-based one, or a right character
/// from a wrong one.</summary>
public List<(uint Guid, string AccountName)> EnterWorldByGuidCalls { get; } = [];
public IPEndPoint ResolveEndpoint(string host, int port) =>
new(IPAddress.Loopback, port);
public WorldSession CreateSession(IPEndPoint endpoint)
{
var session = new WorldSession(endpoint, new TestTransport());
Sessions.Add(session);
return session;
}
public void Connect(WorldSession session, string user, string password) { }
public void StartCharacterSelectionReceive(WorldSession session) { }
/// <summary>Two pre-existing characters whose WIRE order (array
/// position — "Zed" slot 0, "Amy" slot 1) deliberately differs from
/// their ALPHABETICAL display order ("Amy" &lt; "Zed") — F2's
/// regression gate. A single-character roster cannot distinguish a
/// correct wire-index-preserving append from a buggy
/// re-sort-and-renumber, because with only one entry the two orders
/// coincide.</summary>
public CharacterList.Parsed? GetCharacters(WorldSession session) => new(
0u,
[
new CharacterList.Character(0x50000002u, "Zed", 0u),
new CharacterList.Character(0x50000003u, "Amy", 0u),
],
[],
SlotCount: 11,
AccountName: "testaccount",
true,
true);
public void EnterWorld(WorldSession session, int activeCharacterIndex) =>
EnterWorldCount++;
/// <summary>R1: when positive, the next guid-enter throws retail's
/// server-rejection shape (the transport-valid path that returns
/// the controller to selection), decrementing per call — lets a
/// test reach the create-again-after-rejected-enter flow.</summary>
public int EnterWorldByGuidRejectionsRemaining { get; set; }
public void EnterWorldByGuid(
WorldSession session,
uint characterGuid,
string accountName)
{
EnterWorldByGuidCalls.Add((characterGuid, accountName));
if (EnterWorldByGuidRejectionsRemaining > 0)
{
EnterWorldByGuidRejectionsRemaining--;
throw new CharacterSelectionRejectedException(
new CharacterError.Parsed(0x0000000Bu));
}
}
public void Tick(WorldSession session) { }
public void DisposeSession(WorldSession session) { }
}
private sealed class TestHost : ILiveSessionLifecycleHost
{
public List<LiveSessionRosterReport> Rosters { get; } = [];
public List<LiveSessionCharacterSelection> EnteredWorld { get; } = [];
public List<RuntimeCharacterCreationIdentity> Created { get; } = [];
public List<RuntimeCharacterCreationRejection> Failed { get; } = [];
public LiveSessionBinding BindSession(WorldSession session) =>
new(session, activateCommands: () => { }, deactivateCommands: () => { }, detachEvents: () => { });
public void ResetSessionState(RuntimeGenerationToken retiringGeneration) { }
public void ReportConnecting(string host, int port, string user) { }
public void ReportConnected() { }
public void ReportRoster(LiveSessionRosterReport roster) => Rosters.Add(roster);
public void ApplySelectedCharacter(LiveSessionCharacterSelection selection) { }
public void ApplyEnteredWorld(LiveSessionCharacterSelection selection) =>
EnteredWorld.Add(selection);
public void DetachSession(WorldSession session) { }
public void ApplyCharacterCreated(RuntimeCharacterCreationIdentity identity) =>
Created.Add(identity);
public void ApplyCreationFailed(RuntimeCharacterCreationRejection rejection) =>
Failed.Add(rejection);
}
private static LiveSessionConnectOptions LiveOptions() => new(
Enabled: true,
"127.0.0.1",
9000,
"testaccount",
"password",
Character: null,
Probe: false,
AwaitCharacterSelection: true);
private static (LiveSessionController Controller, TestOperations Operations, TestHost Host, RuntimeGenerationToken Generation)
StartAwaitingSelection()
{
var operations = new TestOperations();
var host = new TestHost();
var controller = new LiveSessionController(
operations,
timeProvider: null,
RuntimeCharacterCreationStateFixture.Build());
LiveSessionStartResult result = controller.Start(LiveOptions(), host);
Assert.Equal(LiveSessionStartStatus.AwaitingCharacterSelection, result.Status);
return (controller, operations, host, controller.Generation);
}
private static void BuildReadyCharacter(LiveSessionController controller, RuntimeGenerationToken generation)
{
Assert.True(controller.SelectHeritage(generation, RuntimeCharacterCreationStateFixture.AluvianId).Accepted);
Assert.True(controller.SelectGender(generation, RuntimeCharacterCreationStateFixture.MaleGenderKey).Accepted);
Assert.True(controller.SelectTemplate(generation, RuntimeCharacterCreationStateFixture.PresetTemplateIndex).Accepted);
Assert.True(controller.SetName(generation, "NewChar").Accepted);
}
[Fact]
public void Finish_SendsExactly55SkillSlotsAndTheCorrectAttributesAndName()
{
(LiveSessionController controller, TestOperations operations, _, RuntimeGenerationToken generation) =
StartAwaitingSelection();
BuildReadyCharacter(controller, generation);
WorldSession session = operations.Sessions[0];
byte[]? captured = null;
GameMessageGroup? capturedGroup = null;
session.GameMessageCapture = (body, group) =>
{
captured = body;
capturedGroup = group;
};
RuntimeCommandResult result = controller.Finish(generation);
Assert.True(result.Accepted);
Assert.NotNull(captured);
Assert.Equal(GameMessageGroup.LoginQueue, capturedGroup);
CapturedCreateRequest decoded = DecodeCreateRequest(captured!);
Assert.Equal("testaccount", decoded.AccountName);
Assert.Equal(RuntimeCharacterCreationStateFixture.AluvianId, decoded.Heritage);
Assert.Equal(RuntimeCharacterCreationStateFixture.MaleGenderKey, decoded.Gender);
Assert.Equal(RuntimeCharacterCreationStateFixture.PresetTemplateIndex, decoded.Template);
Assert.Equal(16u, decoded.Strength);
Assert.Equal("NewChar", decoded.Name);
Assert.Equal((uint)CharacterCreate.SkillAdvancementClassCount, decoded.NumSkills);
Assert.Equal(CharacterCreate.SkillAdvancementClassCount, decoded.SkillAdvancementClasses.Length);
Assert.Equal(
(uint)ChargenSkillAdvancementClass.Trained,
decoded.SkillAdvancementClasses[RuntimeCharacterCreationStateFixture.SkillTrainSpecialize]);
Assert.Equal(
(uint)ChargenSkillAdvancementClass.Specialized,
decoded.SkillAdvancementClasses[RuntimeCharacterCreationStateFixture.SkillPresetPrimary]);
}
[Fact]
public void Finish_ThenOkResponse_AppendsToRosterAndLogsStraightIn()
{
(LiveSessionController controller, TestOperations operations, TestHost host, RuntimeGenerationToken generation) =
StartAwaitingSelection();
BuildReadyCharacter(controller, generation);
WorldSession session = operations.Sessions[0];
session.GameMessageCapture = (_, _) => { };
Assert.True(controller.Finish(generation).Accepted);
InvokeProcessDatagram(session, BuildResponsePacket(
(uint)CharGenVerificationResponse.Code.Ok, 0x50001234u, "NewChar"));
Assert.Single(host.Created);
Assert.Equal(0x50001234u, host.Created[0].Guid);
Assert.Equal("NewChar", host.Created[0].Name);
Assert.Empty(host.Failed);
// The roster report following the Ok reply has EVERY pre-existing
// character and the newly created one.
LiveSessionRosterReport lastReport = host.Rosters[^1];
Assert.Contains(lastReport.Entries, e => e.Id == 0x50001234u && e.Name == "NewChar");
Assert.Contains(lastReport.Entries, e => e.Id == 0x50000002u && e.Name == "Zed");
Assert.Contains(lastReport.Entries, e => e.Id == 0x50000003u && e.Name == "Amy");
// F2 acceptance gate: the append preserves every PRE-EXISTING
// character's original wire ActiveIndex ("Zed" slot 0, "Amy" slot
// 1 — deliberately NOT alphabetical order) and assigns the NEW
// character the true wire count (2, 0-based, after Zed and Amy). A
// round-trip through ApplyRoster's name-sort-and-renumber would
// have swapped Zed/Amy to 1/0 instead.
Assert.True(controller.CharacterSelectionState.View.TryGet(0x50000002u, out RuntimeCharacterSelectionEntry zed));
Assert.Equal(0, zed.ActiveIndex);
Assert.True(controller.CharacterSelectionState.View.TryGet(0x50000003u, out RuntimeCharacterSelectionEntry amy));
Assert.Equal(1, amy.ActiveIndex);
Assert.True(controller.CharacterSelectionState.View.TryGet(0x50001234u, out RuntimeCharacterSelectionEntry newChar));
Assert.Equal(2, newChar.ActiveIndex);
// F1 acceptance gate: gmCharGenMainUI::Update @ 0x004E8460's
// log-straight-in, reused via EnterCreatedCharacterCore — the
// controller is now in-world as the new character, entered by the
// EXACT guid the Ok reply carried (NOT the roster-index path, which
// the cached wire roster is by-design stale for post-create).
Assert.True(controller.IsInWorld);
Assert.Equal(0, operations.EnterWorldCount);
Assert.Single(operations.EnterWorldByGuidCalls);
Assert.Equal(0x50001234u, operations.EnterWorldByGuidCalls[0].Guid);
Assert.Equal("testaccount", operations.EnterWorldByGuidCalls[0].AccountName);
Assert.Single(host.EnteredWorld);
Assert.Equal(0x50001234u, host.EnteredWorld[0].CharacterId);
}
/// <summary>
/// CC3 re-review R1: a SECOND create in the same session must get wire
/// slot N+1, not N. ACE never resends CharacterList post-create, so the
/// cached wire count alone under-counts by the creates it hasn't seen;
/// the controller's creates-since-list counter (reset on every fresh
/// wire CharacterList) supplies the difference — the equivalent of
/// retail's own CharacterSet growing via AddIdentity per create. The
/// create-again path is reached exactly as the re-review described:
/// first create Ok, guid-enter rejected by the server
/// (CharacterSelectionRejectedException → ReturnToSelection), then a
/// second create.
/// </summary>
[Fact]
public void SecondCreate_AfterRejectedEnter_GetsTheNextWireSlot()
{
(LiveSessionController controller, TestOperations operations, TestHost host, RuntimeGenerationToken generation) =
StartAwaitingSelection();
BuildReadyCharacter(controller, generation);
WorldSession session = operations.Sessions[0];
session.GameMessageCapture = (_, _) => { };
operations.EnterWorldByGuidRejectionsRemaining = 1;
Assert.True(controller.Finish(generation).Accepted);
InvokeProcessDatagram(session, BuildResponsePacket(
(uint)CharGenVerificationResponse.Code.Ok, 0x50001234u, "NewChar"));
// The rejected enter left us back at selection with the first
// created character appended at the true wire slot 2.
Assert.False(controller.IsInWorld);
Assert.Single(operations.EnterWorldByGuidCalls);
Assert.True(controller.CharacterSelectionState.View.TryGet(0x50001234u, out RuntimeCharacterSelectionEntry firstCreated));
Assert.Equal(2, firstCreated.ActiveIndex);
// Second create in the same session: ACE's own list now holds
// Zed(0), Amy(1), NewChar(2) — the cached wire list still only
// holds Zed and Amy. The second character's slot must be 3.
Assert.True(controller.SetName(generation, "SecondChar").Accepted);
Assert.True(controller.Finish(generation).Accepted);
InvokeProcessDatagram(session, BuildResponsePacket(
(uint)CharGenVerificationResponse.Code.Ok, 0x50005678u, "SecondChar"));
Assert.True(controller.CharacterSelectionState.View.TryGet(0x50005678u, out RuntimeCharacterSelectionEntry secondCreated));
Assert.Equal(3, secondCreated.ActiveIndex);
// Pre-existing wire indices still intact after both appends.
Assert.True(controller.CharacterSelectionState.View.TryGet(0x50000002u, out RuntimeCharacterSelectionEntry zed));
Assert.Equal(0, zed.ActiveIndex);
Assert.True(controller.CharacterSelectionState.View.TryGet(0x50000003u, out RuntimeCharacterSelectionEntry amy));
Assert.Equal(1, amy.ActiveIndex);
Assert.Equal(2, host.Created.Count);
}
[Fact]
public void Finish_ThenNameInUseResponse_SurfacesRejectionAndStaysAwaitingSelection()
{
(LiveSessionController controller, TestOperations operations, TestHost host, RuntimeGenerationToken generation) =
StartAwaitingSelection();
BuildReadyCharacter(controller, generation);
WorldSession session = operations.Sessions[0];
session.GameMessageCapture = (_, _) => { };
Assert.True(controller.Finish(generation).Accepted);
InvokeProcessDatagram(session, BuildResponsePacket(
(uint)CharGenVerificationResponse.Code.NameInUse, 0u, string.Empty));
Assert.Single(host.Failed);
Assert.Equal(CharGenVerificationResponse.Code.NameInUse, host.Failed[0].Code);
Assert.Equal("NewChar", host.Failed[0].AttemptedName);
Assert.Empty(host.Created);
Assert.False(controller.IsInWorld);
Assert.Equal(0, operations.EnterWorldCount);
Assert.Empty(operations.EnterWorldByGuidCalls);
Assert.Empty(host.EnteredWorld);
// No roster append on a rejection.
Assert.DoesNotContain(host.Rosters, r => r.Entries.Any(e => e.Name == "NewChar"));
}
[Fact]
public void Finish_RefusedLocallyWithUnspentAttributeCredits_NeverTouchesTheWire()
{
(LiveSessionController controller, TestOperations operations, _, RuntimeGenerationToken generation) =
StartAwaitingSelection();
Assert.True(controller.SelectHeritage(generation, RuntimeCharacterCreationStateFixture.AluvianId).Accepted);
Assert.True(controller.SelectGender(generation, RuntimeCharacterCreationStateFixture.MaleGenderKey).Accepted);
Assert.True(controller.SelectTemplate(generation, RuntimeCharacterCreationStateFixture.CustomTemplateIndex).Accepted);
Assert.True(controller.SetName(generation, "NewChar").Accepted);
WorldSession session = operations.Sessions[0];
bool sent = false;
session.GameMessageCapture = (_, _) => sent = true;
RuntimeCommandResult result = controller.Finish(generation);
Assert.False(result.Accepted);
Assert.False(sent);
}
/// <summary>
/// F3 acceptance gate: retail does NOT force a full attribute spend —
/// <c>gmCharGenMainUI::DoFinish(this, arg2) @ 0x004E9170</c> only warns
/// (<c>arg2 != 0 &amp;&amp; remainingAtrbCredits &gt; 0</c>) and the
/// credit-warning dialog's own confirm handler re-invokes
/// <c>DoFinish(this, 0)</c> (@0x004E98BB), which skips the check
/// entirely and sends. <see cref="LiveSessionController.Finish"/>'s
/// <c>confirmUnspentCredits</c> parameter is that <c>arg2 == 0</c> case.
/// </summary>
[Fact]
public void Finish_WithUnspentCreditsAndConfirmed_SendsAnyway()
{
(LiveSessionController controller, TestOperations operations, _, RuntimeGenerationToken generation) =
StartAwaitingSelection();
Assert.True(controller.SelectHeritage(generation, RuntimeCharacterCreationStateFixture.AluvianId).Accepted);
Assert.True(controller.SelectGender(generation, RuntimeCharacterCreationStateFixture.MaleGenderKey).Accepted);
Assert.True(controller.SelectTemplate(generation, RuntimeCharacterCreationStateFixture.CustomTemplateIndex).Accepted);
Assert.True(controller.SetName(generation, "NewChar").Accepted);
WorldSession session = operations.Sessions[0];
byte[]? captured = null;
session.GameMessageCapture = (body, _) => captured = body;
// Unconfirmed: refused, matching the sibling test above — the
// warning-dialog gate.
Assert.False(controller.Finish(generation).Accepted);
Assert.Null(captured);
// Confirmed: sends anyway with the credits still unspent.
RuntimeCommandResult confirmed = controller.Finish(generation, confirmUnspentCredits: true);
Assert.True(confirmed.Accepted);
Assert.NotNull(captured);
CapturedCreateRequest decoded = DecodeCreateRequest(captured!);
Assert.Equal("NewChar", decoded.Name);
Assert.Equal(10u, decoded.Strength); // Custom template sits at the floor — unspent, unchanged.
}
private static void InvokeProcessDatagram(WorldSession session, byte[] datagram)
{
MethodInfo method = typeof(WorldSession).GetMethod(
"ProcessDatagram",
BindingFlags.NonPublic | BindingFlags.Instance)!;
method.Invoke(session, [new ReadOnlyMemory<byte>(datagram), null, true]);
}
private static byte[] BuildResponseBody(uint code, uint guid, string name)
{
var w = new PacketWriter();
w.WriteUInt32(CharGenVerificationResponse.ResponseOpcode);
w.WriteUInt32(code);
if (code == (uint)CharGenVerificationResponse.Code.Ok)
{
w.WriteUInt32(guid);
w.WriteString16L(name);
w.WriteUInt32(0u);
}
return w.ToArray();
}
private static byte[] BuildResponsePacket(uint code, uint guid, string name)
{
byte[] message = BuildResponseBody(code, guid, name);
var fragments = new byte[MessageFragmentHeader.Size + message.Length];
GameMessageFragment.WriteSingleFragment(fragments.AsSpan(), fragmentSequence: 1u, GameMessageGroup.UIQueue, message);
return PacketCodec.Encode(
new PacketHeader { Sequence = 1u, Flags = PacketHeaderFlags.BlobFragments },
fragments,
outboundIsaac: null);
}
private readonly record struct CapturedCreateRequest(
string AccountName,
uint Heritage,
uint Gender,
uint Template,
uint Strength,
string Name,
uint NumSkills,
uint[] SkillAdvancementClasses);
/// <summary>Manual mirror of <see cref="CharacterCreate.BuildRequestBody"/>'s
/// exact field order — see that class's doc comment for the full
/// layout.</summary>
private static CapturedCreateRequest DecodeCreateRequest(ReadOnlySpan<byte> body)
{
int pos = 0;
uint opcode = ReadU32(body, ref pos);
Assert.Equal(CharacterCreate.Opcode, opcode);
string accountName = ReadString16L(body, ref pos);
uint constant = ReadU32(body, ref pos);
Assert.Equal(1u, constant);
uint heritage = ReadU32(body, ref pos);
uint gender = ReadU32(body, ref pos);
_ = ReadU32(body, ref pos); // eyesStrip
_ = ReadU32(body, ref pos); // noseStrip
_ = ReadU32(body, ref pos); // mouthStrip
_ = ReadU32(body, ref pos); // hairColor
_ = ReadU32(body, ref pos); // eyeColor
_ = ReadU32(body, ref pos); // hairStyle
_ = ReadU32(body, ref pos); // headgearStyle
_ = ReadU32(body, ref pos); // headgearColor
_ = ReadU32(body, ref pos); // shirtStyle
_ = ReadU32(body, ref pos); // shirtColor
_ = ReadU32(body, ref pos); // trousersStyle
_ = ReadU32(body, ref pos); // trousersColor
_ = ReadU32(body, ref pos); // footwearStyle
_ = ReadU32(body, ref pos); // footwearColor
for (int i = 0; i < 6; i++)
_ = ReadF64(body, ref pos); // six shades
uint template = ReadU32(body, ref pos);
uint strength = ReadU32(body, ref pos);
_ = ReadU32(body, ref pos); // endurance
_ = ReadU32(body, ref pos); // coordination
_ = ReadU32(body, ref pos); // quickness
_ = ReadU32(body, ref pos); // focus
_ = ReadU32(body, ref pos); // self
_ = ReadU32(body, ref pos); // slot
_ = ReadU32(body, ref pos); // classId
uint numSkills = ReadU32(body, ref pos);
var skills = new uint[numSkills];
for (int i = 0; i < numSkills; i++)
skills[i] = ReadU32(body, ref pos);
string name = ReadString16L(body, ref pos);
// startArea, isAdmin, isEnvoy, checksum follow — not needed here.
return new CapturedCreateRequest(
accountName, heritage, gender, template, strength, name, numSkills, skills);
}
private static uint ReadU32(ReadOnlySpan<byte> body, ref int pos)
{
uint value = BinaryPrimitives.ReadUInt32LittleEndian(body.Slice(pos));
pos += 4;
return value;
}
private static double ReadF64(ReadOnlySpan<byte> body, ref int pos)
{
double value = BinaryPrimitives.ReadDoubleLittleEndian(body.Slice(pos));
pos += 8;
return value;
}
private static string ReadString16L(ReadOnlySpan<byte> body, ref int pos)
{
ushort len = BinaryPrimitives.ReadUInt16LittleEndian(body.Slice(pos));
string value = Encoding.ASCII.GetString(body.Slice(pos + 2, len));
int recordSize = 2 + len;
int padding = (4 - (recordSize & 3)) & 3;
pos += recordSize + padding;
return value;
}
}
Reference in a new issue View git blame Copy permalink