"login":  fmt.Sprintf("%t", s.Sess.IsLogin()),
			"source": source,
		},
	}
}

func (m *ftpMetrics) log(s *ftp.Context, paths ...string) func(sz int64, err error) {
	startTime := time.Now()
	source := getSource(2)
	return func(sz int64, err error) {
		globalTrace.Publish(ftpTrace(s, startTime, source, strings.Join(paths, " "), err, sz))
	}
}

// Stat implements ftpDriver

			}
			sizes[i] = int64(partSize)
			decObjSize += int64(partSize)
		}
	} else {
		var partSize uint64
		partSize, err = sio.DecryptedSize(uint64(o.Size))
		if err != nil {
			err = errObjectTampered
			return encOff, encLength, skipLen, seqNumber, partStart, err
		}
		sizes = []int64{int64(partSize)}
		decObjSize = sizes[0]
	}

	var off, length int64

	{
		var zb0001 int64
		zb0001, err = dc.ReadInt64()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = BatchJobSize(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z BatchJobSize) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteInt64(int64(z))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}

)

func TestSizeHistogramToMap(t *testing.T) {
	tests := []struct {
		sizes []int64
		want  map[string]uint64
	}{
		{
			sizes: []int64{100, 1000, 72_000, 100_000},
			want: map[string]uint64{
				"LESS_THAN_1024_B":         2,
				"BETWEEN_64_KB_AND_256_KB": 2,
				"BETWEEN_1024B_AND_1_MB":   2,
			},
		},
		{
			sizes: []int64{100, 1000, 2000, 100_000, 13 * humanize.MiByte},
			want: map[string]uint64{

func HardLimitReader(r io.Reader, n int64) io.Reader { return &HardLimitedReader{r, n} }

// A HardLimitedReader reads from R but limits the amount of
// data returned to just N bytes. Each call to Read
// updates N to reflect the new amount remaining.
// Read returns EOF when N <= 0 or when the underlying R returns EOF.
type HardLimitedReader struct {
	R io.Reader // underlying reader
	N int64     // max bytes remaining
}

	// Name of the object.
	Name string

	// Date and time when the object was last modified.
	ModTime time.Time

	// Total object size.
	Size int64

	// Actual size is the real size of the object uploaded by client.
	ActualSize *int64

	// IsDir indicates if the object is prefix.
	IsDir bool

	// Hex encoded unique entity tag of the object.
	ETag string

	// Version ID of this object.

pkg database/sql, func Named(string, interface{}) NamedArg
pkg database/sql, method (*ColumnType) DatabaseTypeName() string
pkg database/sql, method (*ColumnType) DecimalSize() (int64, int64, bool)
pkg database/sql, method (*ColumnType) Length() (int64, bool)
pkg database/sql, method (*ColumnType) Name() string
pkg database/sql, method (*ColumnType) Nullable() (bool, bool)
pkg database/sql, method (*ColumnType) ScanType() reflect.Type

	src rand.Source
}

// Int63 returns a non-negative pseudo-random 63-bit integer as an int64.
func (r *lockedRandSource) Int63() (n int64) {
	r.lk.Lock()
	n = r.src.Int63()
	r.lk.Unlock()
	return n
}

// Seed uses the provided seed value to initialize the generator to a
// deterministic state.
func (r *lockedRandSource) Seed(seed int64) {
	r.lk.Lock()
	r.src.Seed(seed)
	r.lk.Unlock()

		t.Fatalf("failed to create from map, got error %v", err)
	}

	var idVal int64
	_, ok := mapValue1["id"].(uint)
	if ok {
		t.Skipf("This test case skipped, because the db supports returning")
	}

	idVal, ok = mapValue1["id"].(int64)
	if !ok {
		t.Fatal("ret result missing id")
	}

	if int64(result1.ID) != idVal {
		t.Fatal("failed to create data from map with table, @id != id")
	}

	}

	for key, value := range map[string]int64{"Account": 1, "Pets": 2, "Toys": 4, "Company": 1, "Manager": 1, "Team": 1, "Languages": 0, "Friends": 0} {
		if count := DB.Unscoped().Model(&user).Association(key).Count(); count != value {
			t.Errorf("user's %v expects: %v, got %v", key, value, count)
		}
	}