* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.tls.internal.der

import okio.Buffer
import okio.ByteString

/**
 * Encode and decode a model object like a [Long] or [Certificate] as DER bytes.
 */
internal interface DerAdapter<T> {
  /** Returns true if this adapter can read [header] in a choice. */
  fun matches(header: DerHeader): Boolean

  /**

            dstIndex += this.salt.length;
        }

        return dstIndex - start;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        final int nalgos = SMBUtil.readInt2(buffer, bufferIndex);

     */
    public long getLengthInBytes() {
        return this.lengthInBytes;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, final int bufferIndex, final int len) throws SMBProtocolDecodingException {
        if (this.largeFile) {
            this.pid = SMBUtil.readInt2(buffer, bufferIndex);

        return dstIndex - start;
    }

    /**
     * Decode a transform header from byte array
     *
     * @param buffer
     *            buffer to decode from
     * @param bufferIndex
     *            offset in buffer
     * @return new transform header instance
     */
    public static Smb2TransformHeader decode(final byte[] buffer, int bufferIndex) {

	public fun <init> (Ljava/security/KeyPair;Ljava/security/cert/X509Certificate;)V
	public final fun certificate ()Ljava/security/cert/X509Certificate;
	public final fun certificatePem ()Ljava/lang/String;
	public static final fun decode (Ljava/lang/String;)Lokhttp3/tls/HeldCertificate;
	public final fun keyPair ()Ljava/security/KeyPair;
	public final fun privateKeyPkcs1Pem ()Ljava/lang/String;
	public final fun privateKeyPkcs8Pem ()Ljava/lang/String;
}

    /**
     * Encode the input parameters for this DCERPC message.
     * @param buf the buffer to encode into
     * @throws NdrException if encoding fails
     */
    public abstract void encode_in(NdrBuffer buf) throws NdrException;

    /**
     * Decode the output parameters from this DCERPC message.
     * @param buf the buffer to decode from
     * @throws NdrException if decoding fails

        // Body starts at bufferIndex + 64
        // Structure size = 2
        SMBUtil.writeInt2(2, buffer, bufferIndex + 64);

        // Decode the response
        int result = response.decode(buffer, bufferIndex);

        assertEquals(66, result);
        assertEquals(0, response.getStatus()); // Should be STATUS_SUCCESS
    }

    @Test

    }

    @Override
    public long getSize() {
        return 0L;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.createTime = SMBUtil.readTime(buffer, bufferIndex);

        // Test decode method
        byte[] buffer = new byte[512];
        int bufferIndex = 0;
        int expectedDecodeLength = 128;
        when(response.decode(buffer, bufferIndex)).thenReturn(expectedDecodeLength);
        assertEquals(expectedDecodeLength, response.decode(buffer, bufferIndex));

        // Test encode method
        byte[] dst = new byte[512];

	v := BaseOptions{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeBaseOptions Msgsize() is inaccurate")
	}

	vn := BaseOptions{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}