tail[padLen + i] = (byte) (count * 8 >>> 8 * i);
        }

        engineUpdate(tail, 0, tail.length);

        final byte[] result = new byte[16];
        // cast this MD4's context (array of 4 ints) into an array of 16 bytes.
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                result[i * 4 + j] = (byte) (context[i] >>> 8 * j);
            }
        }

        assertEquals(0x08, ace.getFlags());
        assertEquals(0x00000001, ace.getAccessMask());
    }

    @ParameterizedTest
    @DisplayName("Test various access mask values")
    @ValueSource(ints = { 0x00000001, // FILE_READ_DATA
            0x00000002, // FILE_WRITE_DATA
            0x00000004, // FILE_APPEND_DATA
            0x00010000, // DELETE
            0x00020000, // READ_CONTROL

                    "Should throw configured exception");
        }

        @ParameterizedTest
        @ValueSource(ints = { 1, 10, 50, 100, 255 })
        @DisplayName("Should handle various data lengths")
        void testVariousDataLengths(int length) throws SMBProtocolDecodingException {

            assertEquals("Expected structureSize = 4", exception.getMessage());
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 1, 2, 3, 5, 6, 100, 65535 })
        @DisplayName("Should throw exception for various invalid structure sizes")
        void testReadBytesWireFormatVariousInvalidSizes(int structureSize) {

        assertEquals(testSessionId, decodedHeader.getSessionId());
    }

    // Duplicate testFlags method removed - keeping the first one

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 64, 1024, 4096, 65536 })
    @DisplayName("Should handle various message sizes")
    void testVariousMessageSizes(int messageSize) {
        // When
        transformHeader.setOriginalMessageSize(messageSize);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @ParameterizedTest
    @DisplayName("Test writeBytesWireFormat with different info sizes")
    @ValueSource(ints = { 0, 10, 50, 100, 255 })
    void testWriteBytesWireFormatWithDifferentSizes(int infoSize) {
        request = new Smb2SetInfoRequest(mockConfig, testFileId);

        Encodable mockInfo = mock(Encodable.class);

        assertTrue(output.contains(" AB~"));
        // High bytes should be dots
        assertTrue(output.contains("..."));
    }

    @ParameterizedTest
    @ValueSource(ints = { 1, 15, 16, 17, 31, 32, 33, 64, 128 })
    @DisplayName("Should handle various data sizes in hexdump")
    void testHexdumpVariousSizes(int size) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        assertEquals("file3", notifications.get(2).getFileName());
    }

    @DisplayName("Should throw exception for invalid structure size")
    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 2, 4, 8, 10, 16, 32, 255 })
    void testInvalidStructureSize(int structureSize) {
        // Given
        byte[] buffer = new byte[256];
        SMBUtil.writeInt2(structureSize, buffer, 0);

 *
 * <h3>Common ways to use</h3>
 *
 * <p>Getting a converter:
 *
 * <ul>
 *   <li>Use a provided converter implementation, such as {@link Enums#stringConverter}, {@link
 *       com.google.common.primitives.Ints#stringConverter Ints.stringConverter} or the {@linkplain
 *       #reverse reverse} views of these.
 *   <li>Convert between specific preset values using {@link

    List<Integer> ints = Arrays.asList(0, 1, 2);
    List<Float> floats = Arrays.asList(0.0f, 1.0f, 2.0f);
    List<Long> longs = Arrays.asList(0L, 1L, 2L);
    List<Double> doubles = Arrays.asList(0.0, 1.0, 2.0);

    assertThat(Shorts.toArray(bytes)).isEqualTo(array);
    assertThat(Shorts.toArray(shorts)).isEqualTo(array);
    assertThat(Shorts.toArray(ints)).isEqualTo(array);