SMBUtil.writeInt4(12 + fileNameBytes.length, buffer, offset + 4);

        // Write notification
        int notifyOffset = 80;
        SMBUtil.writeInt4(0, buffer, notifyOffset);
        SMBUtil.writeInt4(1, buffer, notifyOffset + 4);
        SMBUtil.writeInt4(fileNameBytes.length, buffer, notifyOffset + 8);
        System.arraycopy(fileNameBytes, 0, buffer, notifyOffset + 12, fileNameBytes.length);

        // When

        }

        // Always compare full length to prevent timing leaks
        int lengthEqual = (a.length == b.length) ? 1 : 0;
        int maxLength = Math.max(a.length, b.length);

        int result = lengthEqual;
        for (int i = 0; i < maxLength; i++) {
            char charA = (i < a.length) ? a[i] : '\0';
            char charB = (i < b.length) ? b[i] : '\0';
            result &= (charA == charB) ? 1 : 0;

        val firstByte = readByte()
        val huffmanDecode = firstByte and 0x80 == 0x80 // 1NNNNNNN
        val length = readInt(firstByte, PREFIX_7_BITS).toLong()

        // If the compressed or decompressed length exceeds the limit, don't even bother.
        if (headerListByteCount + length > HEADER_LIMIT) {
          throw IOException("header byte count limit of $HEADER_LIMIT exceeded")
        }

    byte[] md5Hash = Hashing.md5().hashLong(42L).asBytes();
    byte[] murmur3Hash = Hashing.murmur3_32().hashLong(42L).asBytes();
    byte[] combined = new byte[md5Hash.length + murmur3Hash.length];
    ByteBuffer buffer = ByteBuffer.wrap(combined);
    buffer.put(md5Hash);
    buffer.put(murmur3Hash);
    HashCode expected = HashCode.fromBytes(combined);

    assertEquals(

            assertArrayEquals(hashAlgos, context.getHashAlgos());
            assertArrayEquals(salt, context.getSalt());
            assertEquals(0, context.getHashAlgos().length);
            assertEquals(0, context.getSalt().length);
        }

        @Test
        @DisplayName("Should create instance with default constructor")
        void testDefaultConstructor() {

    public Entry<Country, String>[] createArray(int length) {
      return (Entry<Country, String>[]) new Entry<?, ?>[length];
    }

    @Override
    public Iterable<Entry<Country, String>> order(List<Entry<Country, String>> insertionOrder) {
      return insertionOrder;
    }

    @Override
    public Country[] createKeyArray(int length) {
      return new Country[length];
    }

    @Override

        bais.skip(4);
        readPacket.type = buffer[0] & 0xFF;
        readPacket.length = ((buffer[1] & 0x01) << 16) + ((buffer[2] & 0xFF) << 8) + (buffer[3] & 0xFF);

        byte[] readBuffer = new byte[readPacket.length];
        bais.read(readBuffer, 0, readPacket.length);
        ByteArrayInputStream dataStream = new ByteArrayInputStream(readBuffer);

        // Should contain parent toString content
        // Note: The parent toString might include various fields
        assertNotNull(str);
        assertTrue(str.length() > "Trans2SetFileInformationResponse[]".length());
    }

    @Test
    @DisplayName("Test decode method")
    void testDecode() throws Exception {
        // Test the decode method which is inherited from ServerMessageBlock

        byte[] expected = new byte[1 + dirName.length() + 1];
        expected[0] = 0x04; // buffer format
        System.arraycopy(dirName.getBytes(), 0, expected, 1, dirName.length());
        expected[dirName.length() + 1] = 0x00; // null terminator

        byte[] dst = new byte[100];
        int len = sdd.writeBytesWireFormat(dst, 0);

        assertEquals(expected.length, len);

        byte[] result = new byte[len];

        int writeBodyWireFormat(byte[] dst, int dstIndex) {
            // For testing purposes, we can return a fixed length or mock behavior
            return 0;
        }

        @Override
        int readBodyWireFormat(byte[] src, int srcIndex) {
            // For testing purposes, we can return a fixed length or mock behavior
            return 0;
        }

        @Override