return oi.ETag != "wrong-etag-12345"
			},
		}

		_, err := obj.NewMultipartUpload(ctx, bucket, object, opts)
		if !isErrReadQuorum(err) {
			t.Logf("Got error (as expected): %v", err)
			t.Logf("But expected read quorum error, not object-not-found error")
		}
	})

	t.Run("if-match with correct ETag and read quorum failure", func(t *testing.T) {
		// Test Case 3: if-match with CORRECT ETag but read quorum failure

// RWLocker - locker interface to introduce GetRLock, RUnlock.
type RWLocker interface {
	GetLock(ctx context.Context, timeout *dynamicTimeout) (lkCtx LockContext, timedOutErr error)
	Unlock(lkCtx LockContext)
	GetRLock(ctx context.Context, timeout *dynamicTimeout) (lkCtx LockContext, timedOutErr error)
	RUnlock(lkCtx LockContext)
}

// LockContext lock context holds the lock backed context and canceler for the context.
type LockContext struct {

					return entries, nil
				}
			} else {
				err = fmt.Errorf("invalid pool/set")
				o.pool, o.set = 0, 0
			}
		}
		if IsErr(err, []error{
			nil,
			context.Canceled,
			context.DeadlineExceeded,
			// io.EOF is expected and should be returned but no need to log it.
			io.EOF,
		}...) {
			// Expected good errors we don't need to return error.
			return entries, err
		}
		entries.truncate(0)

		t.Errorf("Write error: got %T, want testError1", err)
	}
	if _, err := rb.TryWrite(nil); err != (testError1{}) {
		t.Errorf("Write error: got %T, want testError1", err)
	}
	if _, err := rb.TryWrite([]byte{1}); err != (testError1{}) {
		t.Errorf("Write error: got %T, want testError1", err)
	}
	if err := rb.TryWriteByte(0); err != (testError1{}) {
		t.Errorf("Write error: got %T, want testError1", err)
	}

    }

    @Override
    public void error(String format, Object arg) {}

    @Override
    public void error(String format, Object arg1, Object arg2) {}

    @Override
    public void error(String format, Object... arguments) {}

    @Override
    public boolean isErrorEnabled(Marker marker) {
        return false;
    }

    @Override
    public void error(Marker marker, String msg) {}

pkg go/types, type Config struct, Error func(error)
pkg go/types, type Config struct, FakeImportC bool
pkg go/types, type Config struct, IgnoreFuncBodies bool
pkg go/types, type Config struct, Importer Importer
pkg go/types, type Config struct, Sizes Sizes
pkg go/types, type Const struct
pkg go/types, type Error struct
pkg go/types, type Error struct, Fset *token.FileSet

	}

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

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

		t.Log("WARNING: TestEncodeDecodeBatchJobKV Msgsize() is inaccurate")
	}

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

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

	}

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

func BenchmarkEncodeBatchJobKeyRotateEncryption(b *testing.B) {
	v := BatchJobKeyRotateEncryption{}
	var buf bytes.Buffer

	}

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

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