}

    /**
     * Decodes a base64 encoded ID back to the original object name.
     *
     * @param id the encoded ID to decode
     * @return the decoded object name
     */
    protected static String decodeId(final String id) {
        if (id == null) {
            return StringUtil.EMPTY;
        }

        dst[di] = (byte) (i >> 24 & 0xFF);
        return 4;
    }

    /*
     * Decode integers
     */

    /**
     * Decodes a 16-bit unsigned integer from big-endian byte order.
     *
     * @param src the source byte array
     * @param si the starting index in the source array
     * @return the decoded short value
     */
    public static short dec_uint16be(final byte[] src, final int si) {

        dst[di] = (byte) (i >> 24 & 0xFF);
        return 4;
    }

    /* Decode integers
     */

    /**
     * Decodes a 16-bit unsigned integer from big-endian byte order.
     *
     * @param src the source byte array
     * @param si the starting index in the source array
     * @return the decoded short value
     */
    public static short dec_uint16be(final byte[] src, final int si) {

        assertEquals(40, bytesWritten);

        // Decode to verify encoding
        FileBasicInfo decoded = new FileBasicInfo();
        decoded.decode(buffer, offset, 36);

        assertEquals(TEST_CREATE_TIME, decoded.getCreateTime());
        assertEquals(TEST_LAST_ACCESS_TIME, decoded.getLastAccessTime());
        assertEquals(TEST_LAST_WRITE_TIME, decoded.getLastWriteTime());

        // Decode
        FileEndOfFileInformation decoded = new FileEndOfFileInformation();
        int decodedBytes = decoded.decode(buffer, 0, 8);
        assertEquals(8, decodedBytes);

        // Verify the round trip preserves the value
        // Note: We can't directly access endOfFile field, but toString contains it
        assertEquals(original.toString(), decoded.toString());
    }

    /**

            int decoded = decodedContext.decode(buffer, 0, encoded);

            assertEquals(encoded, decoded);
            assertArrayEquals(originalCiphers, decodedContext.getCiphers());
        }

        @Test
        @DisplayName("Should encode and decode correctly with multiple ciphers")

            // Decode
            PreauthIntegrityNegotiateContext decoded = new PreauthIntegrityNegotiateContext();
            int decodedSize = decoded.decode(buffer, 0, encodedSize);

            // Verify
            assertEquals(encodedSize, decodedSize);
            assertArrayEquals(hashAlgos, decoded.getHashAlgos());
            assertArrayEquals(salt, decoded.getSalt());

                notifications.add(notification);
            }
        }
    }

    /**
     * Decodes a single notification from the NDR buffer.
     *
     * @param buf the NDR buffer
     * @return the decoded notification
     * @throws NdrException if decoding fails
     */
    private WitnessNotificationResponse decodeNotification(NdrBuffer buf) throws NdrException {

        List<AvPair> pairs = AvPairs.decode(fullData);

        assertNotNull(pairs, "Decoded pairs should not be null");
        assertEquals(1, pairs.size(), "Should have decoded one pair");

        AvPair pair = pairs.get(0);
        assertEquals(AvPair.MsvAvFlags, pair.getType(), "Pair type should be MsvAvFlags");
        assertTrue(pair instanceof AvFlags, "Should be decoded as AvFlags");

        // Decode
        FileRenameInformation2 decoded = new FileRenameInformation2();
        int bytesRead = decoded.decode(buffer, 0, bytesWritten);

        // Verify round trip
        assertEquals(bytesWritten, bytesRead);
        assertEquals(original.size(), decoded.size());
        assertEquals(original.getFileInformationLevel(), decoded.getFileInformationLevel());
    }

    @Test