TASK-039-006: Split + Renumber TurboHttp.Tests/RFC9113/

Split 9 oversized test files (>500 lines) into 20 files and renumbered
all RFC9113 test files consecutively 01–39 with no gaps.

Splits:
- 01_ConnectionPrefaceTests (965 lines) → 3 parts
- 02_FrameParsingTests (562 lines) → 2 parts
- 06_HeadersTests (621 lines) → 2 parts
- 09_ContinuationFrameTests (574 lines) → 2 parts
- 21_FuzzHarnessTests (574 lines) → 2 parts
- 22_SettingsMaxConcurrentTests (801 lines) → 3 parts
- 23_ResourceExhaustionTests (597 lines) → 2 parts
- 24_HighConcurrencyTests (553 lines) → 2 parts
- 25_CrossComponentValidationTests (571 lines) → 2 parts

All 39 files ≤ 500 lines. Build: 0 errors, 0 warnings. Tests: 567 passed, 0 failed.

Author: st0o0

.maggus/features/feature_039.md

@@ -310,11 +310,11 @@ rmdir src/TurboHttp.Tests/Configuration
 **Renumbering:** After all splits, renumber the entire `RFC9113/` folder consecutively starting at `01_`.
 
 **Acceptance Criteria:**
-- [ ] All files in `src/TurboHttp.Tests/RFC9113/` are ≤ 500 lines
-- [ ] Files are numbered consecutively with no gaps
-- [ ] `dotnet build --configuration Release ./src/TurboHttp.sln` succeeds
-- [ ] `dotnet test --project src/TurboHttp.Tests/TurboHttp.Tests.csproj -- --filter-namespace "TurboHttp.Tests.RFC9113"` passes with same test count
-- [ ] Unit tests are written and successful
+- [x] All files in `src/TurboHttp.Tests/RFC9113/` are ≤ 500 lines
+- [x] Files are numbered consecutively with no gaps (01–39)
+- [x] `dotnet build --configuration Release ./src/TurboHttp.sln` succeeds (0 warnings, 0 errors)
+- [x] `dotnet test --project src/TurboHttp.Tests/TurboHttp.Tests.csproj -- --filter-namespace "TurboHttp.Tests.RFC9113"` passes with same test count (567)
+- [x] Unit tests are written and successful
 
 ---
 

src/TurboHttp.Tests/RFC9113/01_ConnectionPrefacePart1Tests.cs

@@ -0,0 +1,356 @@
+using System.Net;
+using TurboHttp.Protocol.RFC7541;
+using TurboHttp.Protocol.RFC9113;
+
+namespace TurboHttp.Tests.RFC9113;
+
+/// <summary>
+/// Tests HTTP/2 connection preface encoding and decoding per RFC 9113 §3.4/3.5.
+/// Part 3: HEADERS frame, CONTINUATION frame.
+/// </summary>
+/// <remarks>
+/// Class under test: <see cref="Http2FrameDecoder"/>.
+/// </remarks>
+public sealed class Http2ConnectionPrefacePart3Tests
+{
+    // RFC 9113 §3.4: client connection preface = magic octets + SETTINGS frame
+    private static readonly byte[] Magic = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"u8.ToArray();
+    private const int MagicLength = 24; // "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
+    private const int FrameHeaderLength = 9;
+
+    // Helper: Decode server responses from frame bytes (replaces Http2ProtocolSession.Responses)
+    private static List<(int StreamId, HttpResponseMessage Response)> DecodeResponses(ReadOnlyMemory<byte> data)
+    {
+        var decoder = new Http2FrameDecoder();
+        var hpack = new HpackDecoder();
+        var frames = decoder.Decode(data);
+        var responses = new List<(int, HttpResponseMessage)>();
+        var pending = new Dictionary<int, (HttpResponseMessage Response, List<byte> Body)>();
+
+        foreach (var frame in frames)
+        {
+            switch (frame)
+            {
+                case HeadersFrame { EndHeaders: true } h:
+                {
+                    var hdrs = hpack.Decode(h.HeaderBlockFragment.Span);
+                    var resp = BuildResponseFromHpack(hdrs);
+                    if (resp == null) break;
+                    if (h.EndStream) responses.Add((h.StreamId, resp));
+                    else pending[h.StreamId] = (resp, []);
+                    break;
+                }
+                case DataFrame d:
+                    if (pending.TryGetValue(d.StreamId, out var p))
+                        p.Body.AddRange(d.Data.ToArray());
+                    if (d.EndStream && pending.TryGetValue(d.StreamId, out var completed))
+                    {
+                        completed.Response.Content = new ByteArrayContent(completed.Body.ToArray());
+                        responses.Add((d.StreamId, completed.Response));
+                        pending.Remove(d.StreamId);
+                    }
+
+                    break;
+            }
+        }
+
+        return responses;
+    }
+
+    private static HttpResponseMessage? BuildResponseFromHpack(IReadOnlyList<HpackHeader> headers)
+    {
+        var statusHeader = headers.FirstOrDefault(h => h.Name == ":status");
+        if (statusHeader == default || !int.TryParse(statusHeader.Value, out var code)) return null;
+        var response = new HttpResponseMessage((HttpStatusCode)code);
+        foreach (var h in headers.Where(h => !h.Name.StartsWith(':')))
+        {
+            if (!response.Headers.TryAddWithoutValidation(h.Name, h.Value))
+            {
+                response.Content.Headers.TryAddWithoutValidation(h.Name, h.Value);
+            }
+        }
+
+        return response;
+    }
+
+    // HEADERS frame tests (migrated from 12_DecoderConnectionPrefaceTests — Phase 6)
+
+    [Fact(DisplayName = "RFC9113-6.2-001: HEADERS frame decoded into response headers")]
+    public void Should_DecodeResponseHeaders_When_HeadersFrameReceived()
+    {
+        var hpack = new HpackEncoder(useHuffman: false);
+        var headerBlock = hpack.Encode([(":status", "200"), ("x-custom", "value")]);
+        var frame = new HeadersFrame(1, headerBlock, endStream: true, endHeaders: true).Serialize();
+
+        var responses = DecodeResponses(frame.AsMemory());
+
+        Assert.Single(responses);
+        var response = responses[0].Response;
+        Assert.Equal(200, (int)response.StatusCode);
+        Assert.True(response.Headers.Contains("x-custom"));
+    }
+
+    [Fact(DisplayName = "RFC9113-6.2-002: END_STREAM on HEADERS closes stream immediately")]
+    public void Should_CloseStreamImmediately_When_HeadersFrameHasEndStream()
+    {
+        var hpack = new HpackEncoder(useHuffman: false);
+        var headerBlock = hpack.Encode([(":status", "204")]);
+        var frame = new HeadersFrame(1, headerBlock, endStream: true, endHeaders: true).Serialize();
+
+        var responses = DecodeResponses(frame.AsMemory());
+
+        Assert.Single(responses);
+        Assert.Equal(204, (int)responses[0].Response.StatusCode);
+    }
+
+    [Fact(DisplayName = "RFC9113-6.2-003: END_HEADERS on HEADERS marks complete block")]
+    public void Should_CompleteHeaderBlock_When_HeadersFrameHasEndHeaders()
+    {
+        var hpack = new HpackEncoder(useHuffman: false);
+        var headerBlock = hpack.Encode([(":status", "200")]);
+        var frame = new HeadersFrame(1, headerBlock, endStream: false, endHeaders: true).Serialize();
+
+        var decoder = new Http2FrameDecoder();
+        decoder.Decode(frame);
+
+        // If END_HEADERS was respected, a subsequent non-CONTINUATION frame must not throw.
+        var pingFrame = new PingFrame(new byte[8]).Serialize();
+        var frames = decoder.Decode(pingFrame);
+        Assert.Single(frames); // no exception — END_HEADERS was recognised
+    }
+
+    [Fact(DisplayName = "RFC9113-6.2-004: Padded HEADERS padding stripped")]
+    public void Should_StripPadding_When_HeadersFrameIsPadded()
+    {
+        var hpack = new HpackEncoder(useHuffman: false);
+        var headerBlock = hpack.Encode([(":status", "200")]);
+
+        // Build PADDED HEADERS: PADDED flag=0x08, pad_length=2, header block, 2 bytes padding.
+        const int padLength = 2;
+        var payload = new byte[1 + headerBlock.Length + padLength];
+        payload[0] = padLength; // Pad Length
+        headerBlock.CopyTo(payload.AsMemory(1));
+        // last 2 bytes remain zero (padding)
+
+        var frame = new byte[9 + payload.Length];
+        frame[0] = 0;
+        frame[1] = 0;
+        frame[2] = (byte)payload.Length;
+        frame[3] = 0x01; // HEADERS
+        frame[4] = 0x0D; // END_STREAM(0x1) | END_HEADERS(0x4) | PADDED(0x8)
+        frame[5] = 0;
+        frame[6] = 0;
+        frame[7] = 0;
+        frame[8] = 1; // stream=1
+        payload.CopyTo(frame, 9);
+
+        var responses = DecodeResponses(frame.AsMemory());
+
+        Assert.Single(responses);
+        Assert.Equal(200, (int)responses[0].Response.StatusCode);
+    }
+
+    [Fact(DisplayName = "RFC9113-6.2-005: PRIORITY flag in HEADERS consumed correctly")]
+    public void Should_ConsumePriorityFlagCorrectly_When_HeadersFrameHasPriorityFlag()
+    {
+        var hpack = new HpackEncoder(useHuffman: false);
+        var headerBlock = hpack.Encode([(":status", "200")]);
+
+        // Build HEADERS with PRIORITY flag: 5 extra bytes (4 stream dep + 1 weight).
+        var priorityBytes = new byte[] { 0x00, 0x00, 0x00, 0x03, 0x0F }; // dep=3, weight=15
+        var payload = priorityBytes.Concat(headerBlock.ToArray()).ToArray();
+
+        var frame = new byte[9 + payload.Length];
+        frame[0] = 0;
+        frame[1] = 0;
+        frame[2] = (byte)payload.Length;
+        frame[3] = 0x01; // HEADERS
+        frame[4] = 0x25; // END_STREAM(0x1) | END_HEADERS(0x4) | PRIORITY(0x20)
+        frame[5] = 0;
+        frame[6] = 0;
+        frame[7] = 0;
+        frame[8] = 1; // stream=1
+        payload.CopyTo(frame, 9);
+
+        var responses = DecodeResponses(frame.AsMemory());
+
+        Assert.Single(responses);
+        Assert.Equal(200, (int)responses[0].Response.StatusCode);
+    }
+
+    [Fact(DisplayName = "RFC9113-6.2-006: HEADERS without END_HEADERS waits for CONTINUATION")]
+    public void Should_WaitForContinuation_When_HeadersFrameLacksEndHeaders()
+    {
+        var hpack = new HpackEncoder(useHuffman: false);
+        var headerBlock = hpack.Encode([(":status", "200")]);
+        var split1 = headerBlock[..(headerBlock.Length / 2)];
+        var split2 = headerBlock[(headerBlock.Length / 2)..];
+
+        var headersFrame = new HeadersFrame(1, split1, endStream: true, endHeaders: false).Serialize();
+        var contFrame = new ContinuationFrame(1, split2, endHeaders: true).Serialize();
+
+        // Use same decoder instance to maintain state
+        var decoder = new Http2FrameDecoder();
+        var frames1 = decoder.Decode(headersFrame);
+        Assert.Single(frames1); // HEADERS frame is decoded
+
+        // Decoder is now awaiting CONTINUATION (continuation state maintained by decoder)
+        var frames2 = decoder.Decode(contFrame);
+        Assert.Single(frames2); // CONTINUATION frame is decoded
+    }
+
+    [Fact(DisplayName = "RFC9113-6.2-007: HEADERS on stream 0 is PROTOCOL_ERROR")]
+    public void Should_ThrowProtocolError_When_HeadersFrameOnStream0()
+    {
+        // RFC 9113 §6.2: HEADERS on stream 0 is a connection error.
+        // Http2FrameDecoder parses the frame; stream=0 validation happens at session layer.
+        var frame = new byte[]
+        {
+            0x00, 0x00, 0x01,
+            0x01, 0x05,
+            0x00, 0x00, 0x00, 0x00, // stream=0
+            0x88
+        };
+        var decoder = new Http2FrameDecoder();
+        // Decoder parses the frame itself without validation of stream ID constraints
+        var frames = decoder.Decode(frame);
+        var headersFrame = Assert.IsType<HeadersFrame>(Assert.Single(frames));
+        Assert.Equal(0, headersFrame.StreamId);
+    }
+
+    // CONTINUATION frame tests (migrated from 12_DecoderConnectionPrefaceTests — Phase 6)
+
+    [Fact(DisplayName = "RFC9113-6.9-001: CONTINUATION appended to HEADERS block")]
+    public void Should_MergeHeaderBlock_When_ContinuationFrameAppendedToHeaders()
+    {
+        var hpack = new HpackEncoder(useHuffman: false);
+        var headerBlock = hpack.Encode([(":status", "200"), ("x-test", "cont")]);
+        var split = headerBlock.Length / 2;
+
+        var headersFrame = new HeadersFrame(1, headerBlock[..split], endStream: true, endHeaders: false).Serialize();
+        var contFrame = new ContinuationFrame(1, headerBlock[split..], endHeaders: true).Serialize();
+
+        // Use same decoder instance to maintain continuation state
+        var decoder = new Http2FrameDecoder();
+        decoder.Decode(headersFrame);
+
+        var frames = decoder.Decode(contFrame);
+        Assert.Single(frames);
+        var cont = Assert.IsType<ContinuationFrame>(frames[0]);
+        Assert.True(cont.EndHeaders);
+    }
+
+    [Fact(DisplayName = "RFC9113-6.9-dec-002: END_HEADERS on final CONTINUATION completes block")]
+    public void Should_CompleteBlock_When_ContinuationFrameHasEndHeaders()
+    {
+        var hpack = new HpackEncoder(useHuffman: false);
+        var headerBlock = hpack.Encode([(":status", "200")]);
+
+        var headersFrame = new HeadersFrame(1, headerBlock[..1], endStream: true, endHeaders: false).Serialize();
+        var contFrame = new ContinuationFrame(1, headerBlock[1..], endHeaders: true).Serialize();
+
+        var decoder = new Http2FrameDecoder();
+        decoder.Decode(headersFrame);
+        var frames = decoder.Decode(contFrame);
+
+        Assert.Single(frames);
+        var cont = Assert.IsType<ContinuationFrame>(frames[0]);
+        Assert.True(cont.EndHeaders);
+    }
+
+    [Fact(DisplayName = "RFC9113-6.9-003: Multiple CONTINUATION frames all merged")]
+    public void Should_MergeAll_When_MultipleContinuationFrames()
+    {
+        var hpack = new HpackEncoder(useHuffman: false);
+        var headerBlock = hpack.Encode([(":status", "200"), ("a", "1"), ("b", "2"), ("c", "3")]);
+        var third = headerBlock.Length / 3;
+
+        var headersFrame = new HeadersFrame(1, headerBlock[..third], endStream: true, endHeaders: false).Serialize();
+        var cont1 = new ContinuationFrame(1, headerBlock[third..(2 * third)], endHeaders: false).Serialize();
+        var cont2 = new ContinuationFrame(1, headerBlock[(2 * third)..], endHeaders: true).Serialize();
+
+        var decoder = new Http2FrameDecoder();
+        decoder.Decode(headersFrame);
+        decoder.Decode(cont1);
+        var frames = decoder.Decode(cont2);
+
+        Assert.Single(frames);
+        var cont = Assert.IsType<ContinuationFrame>(frames[0]);
+        Assert.True(cont.EndHeaders);
+    }
+
+    [Fact(DisplayName = "RFC9113-6.9-004: CONTINUATION on wrong stream is PROTOCOL_ERROR")]
+    public void Should_ThrowProtocolError_When_ContinuationFrameOnWrongStream()
+    {
+        var headersFrame = new byte[]
+        {
+            0x00, 0x00, 0x01,
+            0x01, 0x00,
+            0x00, 0x00, 0x00, 0x01, // stream=1
+            0x82
+        };
+        var contFrame = new byte[]
+        {
+            0x00, 0x00, 0x01,
+            0x09, 0x04,
+            0x00, 0x00, 0x00, 0x03, // stream=3 (wrong)
+            0x84
+        };
+
+        var combined = headersFrame.Concat(contFrame).ToArray();
+        var decoder = new Http2FrameDecoder();
+        var ex = Assert.Throws<Http2Exception>(() => decoder.Decode(combined));
+        Assert.Equal(Http2ErrorCode.ProtocolError, ex.ErrorCode);
+    }
+
+    [Fact(DisplayName = "RFC9113-6.9-005: Non-CONTINUATION after HEADERS is PROTOCOL_ERROR")]
+    public void Should_ThrowProtocolError_When_NonContinuationFollowsHeadersWithoutEndHeaders()
+    {
+        // RFC 9113 §6.9: After HEADERS without END_HEADERS, next frame MUST be CONTINUATION.
+        // Http2FrameDecoder enforces this and throws PROTOCOL_ERROR if violated.
+        var hpack = new HpackEncoder(useHuffman: false);
+        var headerBlock = hpack.Encode([(":status", "200")]);
+        var headersFrame = new HeadersFrame(1, headerBlock, endStream: false, endHeaders: false).Serialize();
+        var pingFrame = new PingFrame(new byte[8]).Serialize();
+
+        var decoder = new Http2FrameDecoder();
+        decoder.Decode(headersFrame);
+
+        // PING while awaiting CONTINUATION must be PROTOCOL_ERROR.
+        var ex = Assert.Throws<Http2Exception>(() => decoder.Decode(pingFrame));
+        Assert.Equal(Http2ErrorCode.ProtocolError, ex.ErrorCode);
+    }
+
+    [Fact(DisplayName = "RFC9113-6.9-006: CONTINUATION on stream 0 is PROTOCOL_ERROR")]
+    public void Should_ThrowProtocolError_When_ContinuationFrameOnStream0()
+    {
+        var headersOnStream1 = new byte[]
+        {
+            0x00, 0x00, 0x01,
+            0x01, 0x00,
+            0x00, 0x00, 0x00, 0x01, // stream=1
+            0x82
+        };
+        var contOnStream0 = new byte[]
+        {
+            0x00, 0x00, 0x01,
+            0x09, 0x04,
+            0x00, 0x00, 0x00, 0x00, // stream=0
+            0x84
+        };
+
+        var combined = headersOnStream1.Concat(contOnStream0).ToArray();
+        var decoder = new Http2FrameDecoder();
+        var ex = Assert.Throws<Http2Exception>(() => decoder.Decode(combined));
+        Assert.Equal(Http2ErrorCode.ProtocolError, ex.ErrorCode);
+    }
+
+    [Fact(DisplayName = "RFC9113-6.10-CONT-001: CONTINUATION without HEADERS is PROTOCOL_ERROR")]
+    public void Should_ThrowProtocolError_When_ContinuationFrameHasNoPrecedingHeaders()
+    {
+        var contFrame = new ContinuationFrame(1, new byte[] { 0x88 }, endHeaders: true).Serialize();
+        var decoder = new Http2FrameDecoder();
+        var ex = Assert.Throws<Http2Exception>(() => decoder.Decode(contFrame));
+        Assert.Equal(Http2ErrorCode.ProtocolError, ex.ErrorCode);
+    }
+}