import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableTable;
import com.google.common.collect.Table.Cell;
import com.google.common.primitives.Ints;
import com.google.common.testing.EqualsTester;
import com.google.common.testing.NullPointerTester;
import com.google.common.util.concurrent.AtomicLongMap;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

                assertEquals(0, encodedSize % 8, "Encoded size should be 8-byte aligned for name length " + nameLen);
            }
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 10, 50, 100, 200 })
        @DisplayName("Should handle various buffer offsets")
        void testVariousBufferOffsets(int offset) {
            byte[] largeBuffer = new byte[512];

        // Act
        int actual = req.size();

        // Assert
        assertEquals(expected, actual, "size() must be 8-byte aligned");
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 5 })
    @DisplayName("writeBytesWireFormat writes StructureSize=4 and Reserved=0 at given offset")
    void writeBytesWireFormat_writesExpectedValuesAtOffset(int offset) {
        // Arrange

        assertEquals(0x34, buffer[1] & 0xFF);
        assertEquals(0x56, buffer[2] & 0xFF);
        assertEquals(0x78, buffer[3] & 0xFF);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 255, 256, 65535, 65536, Integer.MAX_VALUE })
    @DisplayName("Should handle boundary values")
    void testBoundaryValues(int value) {
        // Given
        byte[] buffer = new byte[4];

        // When

import com.google.common.annotations.J2ktIncompatible;
import com.google.common.collect.SortedLists.KeyAbsentBehavior;
import com.google.common.collect.SortedLists.KeyPresentBehavior;
import com.google.common.primitives.Ints;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.DoNotCall;
import com.google.errorprone.annotations.concurrent.LazyInit;
import com.google.j2objc.annotations.RetainedWith;

import com.google.common.base.Supplier;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.MapMaker;
import com.google.common.math.IntMath;
import com.google.common.primitives.Ints;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

            0x00001040, 0x00001040, 0x00040040, 0x10000000, 0x10041000 };

    /// Squash bytes down to ints.
    /**
     * Converts bytes to integers for internal DES processing
     * @param inBytes the input byte array
     * @param inOff the offset into the input array
     * @param outInts the output integer array

    void testDefaultFlags() {
        assertEquals(0, msg.getFlags(), "Initial flags should be 0");
    }

    @ParameterizedTest(name = "setFlags({0}) ➜ getFlags() == {0}")
    @ValueSource(ints = { 0x0, 0x1, 0x2, 0xFFFFFFFF, -123456 })
    void testSetAndGetFlags(int value) {
        msg.setFlags(value);
        assertEquals(value, msg.getFlags(), "getFlags should return the value set");
    }

    @Test

        assertEquals("Payload exceeds buffer size", exception.getMessage());
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 10, 100, 500, 1024 })
    void testReadDataWireFormatVariousSizes(int dataSize) throws SMBProtocolDecodingException {
        // Test with various data sizes within buffer limit

        // Valid inputs: each known code must map to its documented message
        assertEquals(expectedMessage, lookupMessage(code).orElse(null));
    }

    @ParameterizedTest
    @ValueSource(ints = { -1, Integer.MIN_VALUE, Integer.MAX_VALUE })
    @DisplayName("Unknown codes: lookup returns empty Optional")
    void lookup_returns_empty_for_unknown_codes(int unknownCode) {