setFieldValue(response, "wordCount", 10);

        byte[] buffer = new byte[256];
        SMBUtil.writeInt2(fileAttribute, buffer, 0);
        SMBUtil.writeUTime(0, buffer, 2);
        SMBUtil.writeInt4(0, buffer, 6);

        response.readParameterWordsWireFormat(buffer, 0);

        assertEquals(fileAttribute, response.getAttributes());
    }

    @ParameterizedTest

        byte[] buffer = new byte[context.size()];
        int bytesWritten = context.encode(buffer, 0);

        assertEquals(context.size(), bytesWritten);

        // Verify context header
        assertEquals(0, SMBUtil.readInt4(buffer, 0)); // Next
        assertEquals(16, SMBUtil.readInt2(buffer, 4)); // NameOffset
        assertEquals(4, SMBUtil.readInt2(buffer, 6)); // NameLength

            byte[] innerDigest = "inner_digest".getBytes();
            byte[] expectedOutput = "output_data".getBytes();
            byte[] buffer = new byte[expectedOutput.length + 10]; // Buffer with extra space

            when(mockMd5.digest()).thenReturn(innerDigest);
            when(mockMd5.digest(buffer, 0, expectedOutput.length)).thenAnswer(invocation -> {
                byte[] b = invocation.getArgument(0);

        case SMB_QUERY_FS_SIZE_INFO -> readSmbQueryFSSizeInfoWireFormat(buffer, bufferIndex);
        case SMB_FS_FULL_SIZE_INFORMATION -> readFsFullSizeInformationWireFormat(buffer, bufferIndex);
        default -> 0;
        };
    }

    int readSmbInfoAllocationWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

                    result.getMissingArtifacts(),
                    request.getRemoteRepositories());
        }

        // this should never happen since we checked all possible error sources before but better be sure
        if (result.hasExceptions()) {
            throw new ArtifactResolutionException(
                    "Unknown error during artifact resolution, " + request + ", " + result.getExceptions(),

        void testEncodeIdempotency() {
            String path = "\\\\server\\share";
            buffer = new DfsReferralRequestBuffer(path, 3);

            byte[] dst1 = new byte[buffer.size()];
            byte[] dst2 = new byte[buffer.size()];

            int bytesEncoded1 = buffer.encode(dst1, 0);
            int bytesEncoded2 = buffer.encode(dst2, 0);

            assertEquals(bytesEncoded1, bytesEncoded2);

        offset += 4;
        SMBUtil.writeInt4((int) alloc, buffer, offset);
        offset += 4;
        SMBUtil.writeInt4((int) free, buffer, offset);
        offset += 4;
        SMBUtil.writeInt2(bytesPerSect, buffer, offset);
        offset += 2;

        // Decode
        int bytesDecoded = smbInfoAllocation.decode(buffer, 0, buffer.length);

        buffer[33] = 0x00;
        buffer[34] = 0x00;
        buffer[35] = 0x00;

        return buffer;
    }

    private byte[] createMockFileStandardInfoBuffer() {
        // Create a buffer that represents FileStandardInfo data
        byte[] buffer = new byte[24];

        // Mock allocation size (8 bytes)
        for (int i = 0; i < 8; i++) {
            buffer[i] = (byte) i;
        }

        byte[] buffer = new byte[256];
        int written = trans2FindNext2.writeParametersWireFormat(buffer, 0);

        assertEquals(0, SMBUtil.readInt2(buffer, 0)); // sid
        assertEquals(0, SMBUtil.readInt2(buffer, 2)); // maxItems
        assertEquals(0, SMBUtil.readInt4(buffer, 6)); // resumeKey
    }

    // Helper method to read string from buffer

            buffer.append(ALPHABET.charAt(block >>> 6 & 0x3f));
            buffer.append(ALPHABET.charAt(block & 0x3f));
        }
        if (remainder == 0) {
            return buffer.toString();
        }
        if (remainder == 1) {
            block = (bytes[i] & 0xff) << 4;
            buffer.append(ALPHABET.charAt(block >>> 6));
            buffer.append(ALPHABET.charAt(block & 0x3f));
            buffer.append("==");