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

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

	vn := BucketReplicationStat{}
	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)

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

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

	vn := ChecksumInfo{}
	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)
	}

     * </p>
     *
     * @param inData
     *            The data to decode
     * @return The decoded data, or null if the input is null or empty
     */
    public static byte[] decode(final String inData) {
        if (StringUtil.isEmpty(inData)) {
            return null;
        }
        return Base64.getDecoder().decode(inData);
    }

      decodingInputs[i] = encoding.encoding.encode(encodingInputs[i]);
    }
  }

  @Benchmark
  public int encode(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      tmp += System.identityHashCode(encoding.encoding.encode(encodingInputs[i & INPUTS_MASK]));
    }
    return tmp;
  }

  @Benchmark
  public int decode(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {

        assertFalse(nic.isRdmaCapable());
        assertEquals(address, nic.getAddress());

        // Test scoring
        int score = nic.getScore();
        assertEquals(11000, score); // 10000 (link speed) + 1000 (RSS bonus)

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

    /**
     * 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

        int decodedValue = 200;
        when(mockNdrBuffer.dec_ndr_small()).thenReturn(decodedValue);

        // Create an NdrSmall object (initial value doesn't matter for decode)
        NdrSmall ndrSmall = new NdrSmall(0);

        // Call the decode method
        ndrSmall.decode(mockNdrBuffer);

        // Verify that dec_ndr_small was called
        verify(mockNdrBuffer, times(1)).dec_ndr_small();

 * 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

  /**

        return src[si] & 0xFF | (src[si + 1] & 0xFF) << 8 | (src[si + 2] & 0xFF) << 16 | (src[si + 3] & 0xFF) << 24;
    }

    /* Encode and decode 64 bit integers
     */

    /**
     * Encodes a 64-bit unsigned integer in big-endian byte order.
     *
     * @param l the long value to encode
     * @param dst the destination byte array
     * @param di the starting index in the destination array

        /** The low field of the clock sequence */
        public byte clock_seq_low;
        /** The spatially unique node identifier */
        public byte[] node;

        @Override
        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(this.time_low);
            _dst.enc_ndr_short(this.time_mid);
            _dst.enc_ndr_short(this.time_hi_and_version);