c.Assert(response.ContentLength, int64(len([]byte("hello world"))))
	var buffer2 bytes.Buffer
	// retrieve the contents of response body.
	n, err := io.Copy(&buffer2, response.Body)
	c.Assert(err, nil)
	c.Assert(n, int64(len([]byte("hello world"))))
	// asserted the contents of the fetched object with the expected result.
	c.Assert(true, bytes.Equal(buffer2.Bytes(), []byte("hello world")))

    static void writeInt2 ( int val, byte[] dst, int dstIndex ) {
        dst[ dstIndex++ ] = (byte) ( ( val >> 8 ) & 0xFF );
        dst[ dstIndex ] = (byte) ( val & 0xFF );
    }


    static void writeInt4 ( int val, byte[] dst, int dstIndex ) {
        dst[ dstIndex++ ] = (byte) ( ( val >> 24 ) & 0xFF );
        dst[ dstIndex++ ] = (byte) ( ( val >> 16 ) & 0xFF );

  }

  @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)

		if err != nil {
			f.Fatalf("failed to read testdata: %s", err)
		}
		f.Add(b)
	}

	f.Fuzz(func(t *testing.T, b []byte) {
		r, err := NewReader(bytes.NewReader(b), int64(len(b)))
		if err != nil {
			return
		}

		type file struct {
			header  *FileHeader
			content []byte
		}
		files := []file{}

		for _, f := range r.File {
			fr, err := f.Open()
			if err != nil {
				continue
			}

import (
	"bytes"
	"testing"

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

func TestMarshalUnmarshalBatchJobExpire(t *testing.T) {
	v := BatchJobExpire{}
	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 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

import (
	"bytes"
	"testing"

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

func TestMarshalUnmarshalAccElem(t *testing.T) {
	v := AccElem{}
	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 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

            hmac.update(this.ntResponse, 0, 16); // only first 16 bytes of ntResponse
            byte[] userSessionKey = hmac.digest();

            if ( getFlag(NTLMSSP_NEGOTIATE_KEY_EXCH) ) {
                this.masterKey = new byte[16];
                tc.getConfig().getRandom().nextBytes(this.masterKey);

                byte[] encryptedKey = new byte[16];
                Cipher rc4 = Crypto.getArcfour(userSessionKey);

    };


    /*
     * Accepts key multiple of 7
     * Returns enc multiple of 8
     * Multiple is the same like: 21 byte key gives 24 byte result
     */
    static void E ( byte[] key, byte[] data, byte[] e ) throws ShortBufferException {
        byte[] key7 = new byte[7];
        byte[] e8 = new byte[8];

        for ( int i = 0; i < key.length / 7; i++ ) {

	// FlagPayloadIsErr can be used by individual ops to signify that
	// The payload is a string error converted to byte slice.
	FlagPayloadIsErr

	// FlagPayloadIsZero means that payload is 0-length slice and not nil.
	FlagPayloadIsZero

	// FlagSubroute indicates that the message has subroute.
	// Subroute will be 32 bytes long and added before any CRC.
	FlagSubroute
)

			expectedErr: errors.New("MasterKeyID contains unsupported characters"),
			shouldPass:  false,
		},
	}

	for i, tc := range testCases {
		ssec, err := ParseBucketSSEConfig(bytes.NewReader([]byte(tc.inputXML)))
		if tc.shouldPass && err != nil {
			t.Errorf("Test case %d: Expected to succeed but got %s", i+1, err)
		}

		if !tc.shouldPass {