@Test
        @DisplayName("Should decode error response with correct structure size")
        void testReadErrorResponseValid() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[256];
            int bufferIndex = 0;

            // Write error response structure
            SMBUtil.writeInt2(9, buffer, bufferIndex); // structure size
            buffer[bufferIndex + 2] = 2; // error context count

### Project file structure { #project-file-structure }

Let's say your project file structure looks like this:

```
.
├── app
│   ├── __init__.py
│   ├── main.py
```

Now create a directory to store those static files.

Your new file structure could look like this:

```
.
├── app
│   ├── __init__.py
│   ├── main.py

        byte[] buffer = new byte[leaseContext.size()];
        int encoded = leaseContext.encode(buffer, 0);

        assertEquals(leaseContext.size(), encoded);

        // Verify context header structure according to MS-SMB2
        // Next field (4 bytes) - should be 0 for last/single context
        assertEquals(0, SMBUtil.readInt4(buffer, 0));

        // NameOffset field (2 bytes) - should be 16 (after header)

from functools import lru_cache
from pathlib import Path
from typing import Any, Union

import material
from mkdocs.config.defaults import MkDocsConfig
from mkdocs.structure.files import File, Files
from mkdocs.structure.nav import Link, Navigation, Section
from mkdocs.structure.pages import Page

non_translated_sections = [
    "reference/",
    "release-notes.md",
    "fastapi-people.md",
    "external-links.md",
    "newsletter.md",

        byte[] buffer = new byte[1024];

        int written = request.writeBytesWireFormat(buffer, 0);

        // Should write exactly 56 bytes (structure size without data)
        assertEquals(56, written);
        // Check structure size (first 2 bytes should be 57)
        assertEquals(57, (buffer[0] & 0xFF) | ((buffer[1] & 0xFF) << 8));
    }

    @Test

        void testReadValidOplockBreakNotification() throws Exception {
            // Create a valid buffer with structure size 24
            byte[] buffer = new byte[64];
            int bufferIndex = 0;

            // Write structure size (24)
            SMBUtil.writeInt2(24, buffer, bufferIndex);

            // Write oplock level at offset 2

### Response

If the token is valid and access is approved, the plugin must return a `200` (OK) HTTP status code.

A `200 OK` Response should have `application/json` content-type and body with the following structure:

```json
{
    "user": <string>,
    "maxValiditySeconds": <integer>,
    "claims": <key-value-pairs>
}
```

        // When
        int bytesWritten = request.writeBytesWireFormat(buffer, offset);

        // Then
        assertEquals(32, bytesWritten);

        // Verify structure size (32)
        assertEquals(32, SMBUtil.readInt2(buffer, offset));

        // Verify notify flags
        assertEquals(Smb2ChangeNotifyRequest.SMB2_WATCH_TREE, SMBUtil.readInt2(buffer, offset + 2));

	OutputToken string `json:"outputToken"`
	InputS3URL  string `json:"inputS3Url"`
}

// Event represents lambda function event, this is undocumented in AWS S3. This
// structure bases itself on this structure but there is no binding.
//
//	{
//	  "xAmzRequestId": "a2871150-1df5-4dc9-ad9f-3da283ca1bf3",
//	  "getObjectContext": {
//	    "outputRoute": "...",
//	    "outputToken": "...",

            // Execute
            int bytesWritten = request.writeBytesWireFormat(buffer, headerStart);

            // Verify structure
            assertEquals(49, SMBUtil.readInt2(buffer, headerStart)); // Structure size
            assertEquals(data.length, SMBUtil.readInt4(buffer, headerStart + 4)); // Data length
            assertEquals(1024L, SMBUtil.readInt8(buffer, headerStart + 8)); // Offset