NetworkInterfaceInfo decoded = NetworkInterfaceInfo.decode(encoded, 0);
        assertEquals(nic.getInterfaceIndex(), decoded.getInterfaceIndex());
        assertEquals(nic.getLinkSpeed(), decoded.getLinkSpeed());
        assertEquals(nic.isRssCapable(), decoded.isRssCapable());
    }

    @Test
    void testChannelInfoCreation() throws Exception {

     */
    public OpenSearchAccessResultData(final Map<String, Object> src) {
        setTransformerName((String) src.get(TRANSFORMER_NAME));
        setEncoding((String) src.get(ENCODING));
        final String dataStr = (String) src.get(DATA);
        if (dataStr != null) {
            try {
                setData(Base64Util.decode(dataStr));
            } catch (final Exception e) {

	errMalformedJWKECKey  = errors.New("malformed JWK EC key")
)

// DecodePublicKey - decodes JSON Web Key (JWK) as public key
func (key *JWKS) DecodePublicKey() (crypto.PublicKey, error) {
	switch key.Kty {
	case "RSA":
		if key.N == "" || key.E == "" {
			return nil, errMalformedJWKRSAKey
		}

		// decode exponent
		ebuf, err := base64.RawURLEncoding.DecodeString(key.E)
		if err != nil {

    bytesIn.writeByte(0x40) // Literal indexed
    bytesIn.writeByte(0x88) // Literal name Huffman encoded 8 bytes
    // decodes to custom-key which is length 10
    bytesIn.write("25a849e95ba97d7f".decodeHex())
    bytesIn.writeByte(0x89) // Literal value Huffman encoded 9 bytes
    // decodes to custom-value which is length 12
    bytesIn.write("25a849e95bb8e8b4bf".decodeHex())
  }

        // Byte count (2 bytes)
        buffer[53] = 0x00;
        buffer[54] = 0x00;

        // Test decode
        int bytesDecoded = response.decode(buffer, 0);

        // Should decode at least the header
        assertTrue(bytesDecoded > 0);

        // Verify the command was decoded correctly
        assertEquals(ServerMessageBlock.SMB_COM_TRANSACTION2, response.getCommand());
    }

    @Test

        AvTargetName avTargetName = new AvTargetName(rawBytes);

        // Verify that getTargetName correctly decodes the raw bytes
        assertEquals(originalString, avTargetName.getTargetName(), "Retrieved target name should correctly decode raw bytes");
    }

    /**
     * Test with an empty string for both constructors.
     */
    @Test
    void testEmptyString() {

    }

    @Test
    @DisplayName("Test decode with owner SID only")
    void testDecodeWithOwnerSidOnly() throws SMBProtocolDecodingException {
        // Prepare buffer with owner SID only
        prepareMinimalSecurityDescriptorBuffer(testBuffer, 0, true, false, false);

        int size = securityDescriptor.decode(testBuffer, 0, testBuffer.length);

        // decode returns 0 when no DACL is present (falls through)

		Result bool `json:"result"`
	}

	respBody := bytes.NewReader(opaRespBytes)

	var result opaResult
	if err = json.NewDecoder(respBody).Decode(&result); err != nil {
		respBody.Seek(0, 0)
		var resultAllow opaResultAllow
		if err = json.NewDecoder(respBody).Decode(&resultAllow); err != nil {
			return false, err
		}
		return resultAllow.Result.Allow, nil
	}

	return result.Result, nil

  /**
   * Returns {@code true} if {@code bytes} is a <i>well-formed</i> UTF-8 byte sequence according to
   * Unicode 6.0. Note that this is a stronger criterion than simply whether the bytes can be
   * decoded. For example, some versions of the JDK decoder will accept "non-shortest form" byte
   * sequences, but encoding never reproduces these. Such byte sequences are <i>not</i> considered
   * well-formed.
   *

  /**
   * Returns {@code true} if {@code bytes} is a <i>well-formed</i> UTF-8 byte sequence according to
   * Unicode 6.0. Note that this is a stronger criterion than simply whether the bytes can be
   * decoded. For example, some versions of the JDK decoder will accept "non-shortest form" byte
   * sequences, but encoding never reproduces these. Such byte sequences are <i>not</i> considered
   * well-formed.
   *