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

            assertEquals(encoded, decoded);
            assertArrayEquals(originalHashAlgos, decodedContext.getHashAlgos());
            assertArrayEquals(originalSalt, decodedContext.getSalt());
        }

        @Test
        @DisplayName("Should encode and decode correctly with multiple hash algorithms and large salt")

    }
  }

  private static void testEncoding(BaseEncoding encoding, String decoded, String encoded) {
    testEncodes(encoding, decoded, encoded);
    testDecodes(encoding, encoded, decoded);
  }

  private static void testEncodes(BaseEncoding encoding, String decoded, String encoded) {
    assertThat(encoding.encode(decoded.getBytes(UTF_8))).isEqualTo(encoded);
  }

  private static void testEncodesWithOffset(

     */
    public void enc_ndr_small(final int s) {
        buf[index] = (byte) (s & 0xFF);
        advance(1);
    }

    /**
     * Decodes a small integer (1 byte) from NDR format.
     *
     * @return the decoded small integer value
     */
    public int dec_ndr_small() {
        final int val = buf[index] & 0xFF;
        advance(1);
        return val;
    }

    /**

     *            The encoding scheme. Must not be {@literal null} or empty.
     * @return The decoded string.
     */
    public static String decode(final String s, final String enc) {
        assertArgumentNotEmpty("s", s);
        assertArgumentNotEmpty("enc", enc);

        try {
            return URLDecoder.decode(s, enc);
        } catch (final UnsupportedEncodingException e) {

            assertEquals(8, encoded);

            // Decode into new instance
            FileEndOfFileInformation decoded = new FileEndOfFileInformation();
            int decodedBytes = decoded.decode(buffer, 0, buffer.length);

            assertEquals(8, decodedBytes);

            // Verify values match
            assertEquals(original.toString(), decoded.toString());
        }
    }

    @Test

    protected Decodable createInputDecodable() {
        return null;
    }

    /**
     * Gets the output data decoded as the specified response type.
     *
     * @param <T> the type of the decoded response data
     * @param responseType the class of the expected response type
     * @return decoded data
     * @throws SmbException if decoding fails or the response type is incompatible
     */

            }
        }
        return u;
    }

    /**
     * Decodes a URL as a name using appropriate character encoding.
     * Handles encoding detection from parent URLs and configuration settings.
     *
     * @param url the URL to decode
     * @param escapePlus whether to escape plus signs before decoding
     * @return the decoded URL name, or original URL if decoding fails
     */

      ).decodeBase64()!!

    val decoded = CertificateAdapters.privateKeyInfo.fromDer(privateKeyInfoByteString)

    assertThat(decoded.version).isEqualTo(0L)
    assertThat(decoded.algorithmIdentifier).isEqualTo(AlgorithmIdentifier(RSA_ENCRYPTION, null))
    assertThat(decoded.privateKey.size).isEqualTo(607)

    val encoded = CertificateAdapters.privateKeyInfo.toDer(decoded)

    }
  }

  private static void testEncoding(BaseEncoding encoding, String decoded, String encoded) {
    testEncodes(encoding, decoded, encoded);
    testDecodes(encoding, encoded, decoded);
  }

  private static void testEncodes(BaseEncoding encoding, String decoded, String encoded) {
    assertThat(encoding.encode(decoded.getBytes(UTF_8))).isEqualTo(encoded);
  }

  private static void testEncodesWithOffset(

        return permission;
    }

    /**
     * Decodes a search role format string back to a permission string.
     * Reverses the encoding process to restore original permission format.
     *
     * @param value the encoded permission string to decode
     * @return the decoded permission string, or null if the input is blank or invalid
     */
    public String decode(final String value) {
        if (StringUtil.isBlank(value)) {