{
			desc:       "Correct sha256, truncated",
			src:        bytes.NewReader([]byte("abcd-morethan-4-bytes")),
			size:       4,
			actualSize: 4,
			sha256hex:  "88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589",
			err:        ioutil.ErrOverread,
		},
		{
			desc:       "Correct MD5, nested",
			src:        mustReader(t, bytes.NewReader([]byte("abcd")), 4, "", "", 4),
			size:       4,
			actualSize: 4,

                new byte[] {(byte) 2, (byte) 3, (byte) 4}))
        .isEqualTo(2);
    assertThat(
            Bytes.indexOf(
                new byte[] {(byte) 2, (byte) 2, (byte) 3, (byte) 4, (byte) 2, (byte) 3, (byte) 4},
                new byte[] {(byte) 2, (byte) 3, (byte) 4}))
        .isEqualTo(1);
    assertThat(
            Bytes.indexOf(
                new byte[] {(byte) 4, (byte) 3, (byte) 2},

		errExpected bool
	}{
		{"bytes=0-", false},
		{"bytes=1-", false},

		{"bytes=0-9", false},
		{"bytes=1-10", false},
		{"bytes=1-1", false},
		{"bytes=2-5", false},

		{"bytes=-5", false},
		{"bytes=-1", false},
		{"bytes=-1000", false},
		{"bytes=", true},
		{"bytes= ", true},
		{"byte=", true},
		{"bytes=A-B", true},
		{"bytes=1-B", true},
		{"bytes=B-1", true},

	v := BucketReplicationResyncStatus{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodeBucketReplicationResyncStatus(b *testing.B) {
	v := BucketReplicationResyncStatus{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

  }

  @Test fun `five byte integer`() {
    val bytes = "02058000000001".decodeHex()
    assertThat(Adapters.INTEGER_AS_LONG.fromDer(bytes)).isEqualTo(-549755813887L)
    assertThat(Adapters.INTEGER_AS_LONG.toDer(-549755813887L)).isEqualTo(bytes)
  }

  @Test fun `eight zeros`() {
    val bytes = "020200ff".decodeHex()
    assertThat(Adapters.INTEGER_AS_LONG.fromDer(bytes)).isEqualTo(255)

import (
	"bytes"
	"testing"

	"github.com/tinylib/msgp/msgp"
)

func TestMarshalUnmarshalBatchJobKeyRotateEncryption(t *testing.T) {
	v := BatchJobKeyRotateEncryption{}
	bts, err := v.MarshalMsg(nil)
	if err != nil {
		t.Fatal(err)
	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {

      }
      remaining -= read;
    }

    // bytes is now full
    int b = in.read();
    if (b == -1) {
      return bytes;
    }

    // the stream was longer, so read the rest normally
    Queue<byte[]> bufs = new ArrayDeque<>(TO_BYTE_ARRAY_DEQUE_SIZE + 2);
    bufs.add(bytes);
    bufs.add(new byte[] {(byte) b});
    return toByteArrayInternal(in, bufs, bytes.length + 1);
  }

    Random rng = new Random(0L);
    byte[] bytes = new byte[rng.nextInt(256) + 1];
    rng.nextBytes(bytes);
    assertEquals(hashFunction.hashBytes(bytes), hashFunction.hashBytes(ByteBuffer.wrap(bytes)));
  }

  static void assertHashByteBufferExhaustsBuffer(HashFunction hashFunction) {
    Random rng = new Random(0L);
    byte[] bytes = new byte[rng.nextInt(256) + 1];
    rng.nextBytes(bytes);

    }

    private /* static */ long lowerEight(byte[] bytes) {
      return Longs.fromBytes(
          bytes[7], bytes[6], bytes[5], bytes[4], bytes[3], bytes[2], bytes[1], bytes[0]);
    }

    private /* static */ long upperEight(byte[] bytes) {
      return Longs.fromBytes(
          bytes[15], bytes[14], bytes[13], bytes[12], bytes[11], bytes[10], bytes[9], bytes[8]);
    }
  };

  /**

	}{
		{
			SQL:           "create table users (name, age, height, actived, bytes, create_at, update_at, deleted_at, email, role, pass) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
			NumericRegexp: nil,
			Vars:          []interface{}{"jinzhu", 1, 999.99, true, []byte("12345"), tt, &tt, nil, "w@g.\"com", myrole, pwd},