// Encode multiple times
        byte[] buffer1 = new byte[100];
        byte[] buffer2 = new byte[100];
        byte[] buffer3 = new byte[100];

        int encoded1 = request.encode(buffer1, 0);
        int encoded2 = request.encode(buffer2, 0);
        int encoded3 = request.encode(buffer3, 0);

        // All should produce same result
        assertEquals(encoded1, encoded2);

import okio.ByteString.Companion.encode

/** Factory for HTTP authorization credentials. */
object Credentials {
  /** Returns an auth credential for the Basic scheme. */
  @JvmStatic @JvmOverloads
  fun basic(
    username: String,
    password: String,
    charset: Charset = ISO_8859_1,
  ): String {
    val usernameAndPassword = "$username:$password"
    val encoded = usernameAndPassword.encode(charset).base64()

        decoded.decode(buf);
        assertEquals(val, decoded.value, "Decoded value should match encoded value for " + Long.toHexString(val));
    }

    /**
     * Ensure encode throws NPE when passed a null buffer.
     */
    @Test
    @DisplayName("Encode with null buffer throws NullPointerException")
    public void testEncodeNullBuffer() throws NdrException {
        NdrHyper hyper = new NdrHyper(5L);

        vector.add(new DERTaggedObject(10, new DERSequence(authDataVector)));

        DERSequence sequence = new DERSequence(vector);
        byte[] encoded = new DERTaggedObject(false, BERTags.APPLICATION, 1, sequence).getEncoded();

        KerberosEncData encData = new KerberosEncData(encoded, Collections.emptyMap());

        assertEquals("TEST.REALM", encData.getUserRealm());
        assertEquals("testuser", encData.getUserPrincipalName());

        @DisplayName("Various flag combinations encode and parse correctly")
        void testFlagCombinations(int flags) throws Exception {
            NegTokenInit init = new NegTokenInit(new ASN1ObjectIdentifier[] { OID_KRB }, flags, null, null);

            byte[] encoded = init.toByteArray();
            NegTokenInit parsed = new NegTokenInit(encoded);

            assertEquals(flags, parsed.getContextFlags());

 UsesDataDir = 1 << 1
 InlineData  = 1 << 2
)
```

The "Metadata" section contains a single version, encoded in similar fashion as each version in the `Versions` array
of the previous version.

## Inline Data

Inline data is optional. If no inline data is present, it is encoded as 0 bytes.

| Entry               | Encoding                    | Content

            byte[] buffer = new byte[8];
            int encoded = original.encode(buffer, 0);

            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

  }
}

/**
 * Returns the certificate encoded in [PEM format][rfc_7468].
 *
 * [rfc_7468]: https://tools.ietf.org/html/rfc7468
 */
fun X509Certificate.certificatePem(): String =
  buildString {
    append("-----BEGIN CERTIFICATE-----\n")
    encodeBase64Lines(encoded.toByteString())
    append("-----END CERTIFICATE-----\n")
  }

	}
	return map[string]string{
		c.Type.String():       c.Encoded,
		xhttp.AmzChecksumType: c.Type.ObjType(),
	}
}

// Equal returns whether two checksum structs are equal in all their fields.
func (c *Checksum) Equal(s *Checksum) bool {
	if c == nil || s == nil {
		return c == s
	}
	return c.Type == s.Type &&
		c.Encoded == s.Encoded &&
		bytes.Equal(c.Raw, s.Raw) &&
		c.WantParts == s.WantParts
}

        // Test encoding/decoding
        byte[] encoded = nic.encode();
        assertNotNull(encoded);
        assertEquals(Smb2ChannelCapabilities.NETWORK_INTERFACE_INFO_SIZE, encoded.length);

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