}
	}
}

// Provides a fully populated http request instance, fails otherwise.
func mustNewRequest(method string, urlStr string, contentLength int64, body io.ReadSeeker, t *testing.T) *http.Request {
	req, err := newTestRequest(method, urlStr, contentLength, body)
	if err != nil {
		t.Fatalf("Unable to initialize new http request %s", err)
	}
	return req
}

func (d *naughtyDisk) ReadFile(ctx context.Context, volume string, path string, offset int64, buf []byte, verifier *BitrotVerifier) (n int64, err error) {
	if err := d.calcError(); err != nil {
		return 0, err
	}
	return d.disk.ReadFile(ctx, volume, path, offset, buf, verifier)
}

func (d *naughtyDisk) ReadFileStream(ctx context.Context, volume, path string, offset, length int64) (io.ReadCloser, error) {
	if err := d.calcError(); err != nil {

pkg syscall (darwin-amd64), type Rusage struct, Msgsnd int64
pkg syscall (darwin-amd64), type Rusage struct, Nivcsw int64
pkg syscall (darwin-amd64), type Rusage struct, Nsignals int64
pkg syscall (darwin-amd64), type Rusage struct, Nswap int64
pkg syscall (darwin-amd64), type Rusage struct, Nvcsw int64
pkg syscall (darwin-amd64), type Rusage struct, Oublock int64

var _VersionType_index = [...]uint8{0, 18, 28, 38, 48, 63}

func (i VersionType) String() string {
	if i >= VersionType(len(_VersionType_index)-1) {
		return "VersionType(" + strconv.FormatInt(int64(i), 10) + ")"
	}
	return _VersionType_name[_VersionType_index[i]:_VersionType_index[i+1]]
}
func _() {
	// An "invalid array index" compiler error signifies that the constant values have changed.

// license that can be found in the LICENSE file.

package tar

import (
	"math"
	"strings"
	"testing"
	"time"
)

func TestFitsInBase256(t *testing.T) {
	vectors := []struct {
		in    int64
		width int
		ok    bool
	}{
		{+1, 8, true},
		{0, 8, true},
		{-1, 8, true},
		{1 << 56, 8, false},
		{(1 << 56) - 1, 8, true},
		{-1 << 56, 8, true},
		{(-1 << 56) - 1, 8, false},

			RecID1 int64 `gorm:"column:recid1;type:decimal(9,0);not null" json:"recid1"`
			RecID2 int64 `gorm:"column:recid2;type:decimal(8);not null" json:"recid2"`
			RecID3 int64 `gorm:"column:recid3;type:decimal(8,1);not null" json:"recid3"`
		}
		type MigrateDecimalColumn2 struct {
			RecID1 int64 `gorm:"column:recid1;type:decimal(8);not null" json:"recid1"`

}

// Encode reads from the reader, erasure-encodes the data and writes to the writers.
func (e *Erasure) Encode(ctx context.Context, src io.Reader, writers []io.Writer, buf []byte, quorum int) (total int64, err error) {
	writer := &multiWriter{
		writers:     writers,
		writeQuorum: quorum,
		errs:        make([]error, len(writers)),
	}

	for {
		var blocks [][]byte
		n, err := io.ReadFull(src, buf)

				i+1, test.result, got)
		}
	}
}

func TestGetCompressedOffsets(t *testing.T) {
	testCases := []struct {
		objInfo           ObjectInfo
		offset            int64
		startOffset       int64
		snappyStartOffset int64
		firstPart         int
	}{
		0: {
			objInfo: ObjectInfo{
				Parts: []ObjectPartInfo{
					{
						Size:       39235668,
						ActualSize: 67108864,
					},
					{

	s3OutputBytes        uint64
}

// Increase internode total input bytes
func (s *connStats) incInternodeInputBytes(n int64) {
	atomic.AddUint64(&s.internodeInputBytes, uint64(n))
}

// Increase internode total output bytes
func (s *connStats) incInternodeOutputBytes(n int64) {
	atomic.AddUint64(&s.internodeOutputBytes, uint64(n))
}

// Return internode total input bytes

	BeginAt      time.Time
	SQL          string
	RowsAffected int64
	Err          error
}

// New trace recorder
func (l *traceRecorder) New() *traceRecorder {
	return &traceRecorder{Interface: l.Interface, BeginAt: time.Now()}
}

// Trace implement logger interface
func (l *traceRecorder) Trace(ctx context.Context, begin time.Time, fc func() (string, int64), err error) {
	l.BeginAt = begin
	l.SQL, l.RowsAffected = fc()