smart-search-back/internal/mocks/user_service_mock.go

// Code generated by http://github.com/gojuno/minimock (v3.4.7). DO NOT EDIT.

package mocks

//go:generate minimock -i git.techease.ru/Smart-search/smart-search-back/internal/service.UserService -o user_service_mock.go -n UserServiceMock -p mocks

import (
	"context"
	"sync"
	mm_atomic "sync/atomic"
	mm_time "time"

	mm_service "git.techease.ru/Smart-search/smart-search-back/internal/service"
	"github.com/gojuno/minimock/v3"
)

// UserServiceMock implements mm_service.UserService
type UserServiceMock struct {
	t          minimock.Tester
	finishOnce sync.Once

	funcGetBalance          func(ctx context.Context, userID int) (f1 float64, err error)
	funcGetBalanceOrigin    string
	inspectFuncGetBalance   func(ctx context.Context, userID int)
	afterGetBalanceCounter  uint64
	beforeGetBalanceCounter uint64
	GetBalanceMock          mUserServiceMockGetBalance

	funcGetBalanceStatistics          func(ctx context.Context, userID int) (bp1 *mm_service.BalanceStatistics, err error)
	funcGetBalanceStatisticsOrigin    string
	inspectFuncGetBalanceStatistics   func(ctx context.Context, userID int)
	afterGetBalanceStatisticsCounter  uint64
	beforeGetBalanceStatisticsCounter uint64
	GetBalanceStatisticsMock          mUserServiceMockGetBalanceStatistics

	funcGetInfo          func(ctx context.Context, userID int) (up1 *mm_service.UserInfo, err error)
	funcGetInfoOrigin    string
	inspectFuncGetInfo   func(ctx context.Context, userID int)
	afterGetInfoCounter  uint64
	beforeGetInfoCounter uint64
	GetInfoMock          mUserServiceMockGetInfo

	funcGetStatistics          func(ctx context.Context, userID int) (sp1 *mm_service.Statistics, err error)
	funcGetStatisticsOrigin    string
	inspectFuncGetStatistics   func(ctx context.Context, userID int)
	afterGetStatisticsCounter  uint64
	beforeGetStatisticsCounter uint64
	GetStatisticsMock          mUserServiceMockGetStatistics
}

// NewUserServiceMock returns a mock for mm_service.UserService
func NewUserServiceMock(t minimock.Tester) *UserServiceMock {
	m := &UserServiceMock{t: t}

	if controller, ok := t.(minimock.MockController); ok {
		controller.RegisterMocker(m)
	}

	m.GetBalanceMock = mUserServiceMockGetBalance{mock: m}
	m.GetBalanceMock.callArgs = []*UserServiceMockGetBalanceParams{}

	m.GetBalanceStatisticsMock = mUserServiceMockGetBalanceStatistics{mock: m}
	m.GetBalanceStatisticsMock.callArgs = []*UserServiceMockGetBalanceStatisticsParams{}

	m.GetInfoMock = mUserServiceMockGetInfo{mock: m}
	m.GetInfoMock.callArgs = []*UserServiceMockGetInfoParams{}

	m.GetStatisticsMock = mUserServiceMockGetStatistics{mock: m}
	m.GetStatisticsMock.callArgs = []*UserServiceMockGetStatisticsParams{}

	t.Cleanup(m.MinimockFinish)

	return m
}

type mUserServiceMockGetBalance struct {
	optional           bool
	mock               *UserServiceMock
	defaultExpectation *UserServiceMockGetBalanceExpectation
	expectations       []*UserServiceMockGetBalanceExpectation

	callArgs []*UserServiceMockGetBalanceParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserServiceMockGetBalanceExpectation specifies expectation struct of the UserService.GetBalance
type UserServiceMockGetBalanceExpectation struct {
	mock               *UserServiceMock
	params             *UserServiceMockGetBalanceParams
	paramPtrs          *UserServiceMockGetBalanceParamPtrs
	expectationOrigins UserServiceMockGetBalanceExpectationOrigins
	results            *UserServiceMockGetBalanceResults
	returnOrigin       string
	Counter            uint64
}

// UserServiceMockGetBalanceParams contains parameters of the UserService.GetBalance
type UserServiceMockGetBalanceParams struct {
	ctx    context.Context
	userID int
}

// UserServiceMockGetBalanceParamPtrs contains pointers to parameters of the UserService.GetBalance
type UserServiceMockGetBalanceParamPtrs struct {
	ctx    *context.Context
	userID *int
}

// UserServiceMockGetBalanceResults contains results of the UserService.GetBalance
type UserServiceMockGetBalanceResults struct {
	f1  float64
	err error
}

// UserServiceMockGetBalanceOrigins contains origins of expectations of the UserService.GetBalance
type UserServiceMockGetBalanceExpectationOrigins struct {
	origin       string
	originCtx    string
	originUserID string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmGetBalance *mUserServiceMockGetBalance) Optional() *mUserServiceMockGetBalance {
	mmGetBalance.optional = true
	return mmGetBalance
}

// Expect sets up expected params for UserService.GetBalance
func (mmGetBalance *mUserServiceMockGetBalance) Expect(ctx context.Context, userID int) *mUserServiceMockGetBalance {
	if mmGetBalance.mock.funcGetBalance != nil {
		mmGetBalance.mock.t.Fatalf("UserServiceMock.GetBalance mock is already set by Set")
	}

	if mmGetBalance.defaultExpectation == nil {
		mmGetBalance.defaultExpectation = &UserServiceMockGetBalanceExpectation{}
	}

	if mmGetBalance.defaultExpectation.paramPtrs != nil {
		mmGetBalance.mock.t.Fatalf("UserServiceMock.GetBalance mock is already set by ExpectParams functions")
	}

	mmGetBalance.defaultExpectation.params = &UserServiceMockGetBalanceParams{ctx, userID}
	mmGetBalance.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmGetBalance.expectations {
		if minimock.Equal(e.params, mmGetBalance.defaultExpectation.params) {
			mmGetBalance.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetBalance.defaultExpectation.params)
		}
	}

	return mmGetBalance
}

// ExpectCtxParam1 sets up expected param ctx for UserService.GetBalance
func (mmGetBalance *mUserServiceMockGetBalance) ExpectCtxParam1(ctx context.Context) *mUserServiceMockGetBalance {
	if mmGetBalance.mock.funcGetBalance != nil {
		mmGetBalance.mock.t.Fatalf("UserServiceMock.GetBalance mock is already set by Set")
	}

	if mmGetBalance.defaultExpectation == nil {
		mmGetBalance.defaultExpectation = &UserServiceMockGetBalanceExpectation{}
	}

	if mmGetBalance.defaultExpectation.params != nil {
		mmGetBalance.mock.t.Fatalf("UserServiceMock.GetBalance mock is already set by Expect")
	}

	if mmGetBalance.defaultExpectation.paramPtrs == nil {
		mmGetBalance.defaultExpectation.paramPtrs = &UserServiceMockGetBalanceParamPtrs{}
	}
	mmGetBalance.defaultExpectation.paramPtrs.ctx = &ctx
	mmGetBalance.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmGetBalance
}

// ExpectUserIDParam2 sets up expected param userID for UserService.GetBalance
func (mmGetBalance *mUserServiceMockGetBalance) ExpectUserIDParam2(userID int) *mUserServiceMockGetBalance {
	if mmGetBalance.mock.funcGetBalance != nil {
		mmGetBalance.mock.t.Fatalf("UserServiceMock.GetBalance mock is already set by Set")
	}

	if mmGetBalance.defaultExpectation == nil {
		mmGetBalance.defaultExpectation = &UserServiceMockGetBalanceExpectation{}
	}

	if mmGetBalance.defaultExpectation.params != nil {
		mmGetBalance.mock.t.Fatalf("UserServiceMock.GetBalance mock is already set by Expect")
	}

	if mmGetBalance.defaultExpectation.paramPtrs == nil {
		mmGetBalance.defaultExpectation.paramPtrs = &UserServiceMockGetBalanceParamPtrs{}
	}
	mmGetBalance.defaultExpectation.paramPtrs.userID = &userID
	mmGetBalance.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)

	return mmGetBalance
}

// Inspect accepts an inspector function that has same arguments as the UserService.GetBalance
func (mmGetBalance *mUserServiceMockGetBalance) Inspect(f func(ctx context.Context, userID int)) *mUserServiceMockGetBalance {
	if mmGetBalance.mock.inspectFuncGetBalance != nil {
		mmGetBalance.mock.t.Fatalf("Inspect function is already set for UserServiceMock.GetBalance")
	}

	mmGetBalance.mock.inspectFuncGetBalance = f

	return mmGetBalance
}

// Return sets up results that will be returned by UserService.GetBalance
func (mmGetBalance *mUserServiceMockGetBalance) Return(f1 float64, err error) *UserServiceMock {
	if mmGetBalance.mock.funcGetBalance != nil {
		mmGetBalance.mock.t.Fatalf("UserServiceMock.GetBalance mock is already set by Set")
	}

	if mmGetBalance.defaultExpectation == nil {
		mmGetBalance.defaultExpectation = &UserServiceMockGetBalanceExpectation{mock: mmGetBalance.mock}
	}
	mmGetBalance.defaultExpectation.results = &UserServiceMockGetBalanceResults{f1, err}
	mmGetBalance.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmGetBalance.mock
}

// Set uses given function f to mock the UserService.GetBalance method
func (mmGetBalance *mUserServiceMockGetBalance) Set(f func(ctx context.Context, userID int) (f1 float64, err error)) *UserServiceMock {
	if mmGetBalance.defaultExpectation != nil {
		mmGetBalance.mock.t.Fatalf("Default expectation is already set for the UserService.GetBalance method")
	}

	if len(mmGetBalance.expectations) > 0 {
		mmGetBalance.mock.t.Fatalf("Some expectations are already set for the UserService.GetBalance method")
	}

	mmGetBalance.mock.funcGetBalance = f
	mmGetBalance.mock.funcGetBalanceOrigin = minimock.CallerInfo(1)
	return mmGetBalance.mock
}

// When sets expectation for the UserService.GetBalance which will trigger the result defined by the following
// Then helper
func (mmGetBalance *mUserServiceMockGetBalance) When(ctx context.Context, userID int) *UserServiceMockGetBalanceExpectation {
	if mmGetBalance.mock.funcGetBalance != nil {
		mmGetBalance.mock.t.Fatalf("UserServiceMock.GetBalance mock is already set by Set")
	}

	expectation := &UserServiceMockGetBalanceExpectation{
		mock:               mmGetBalance.mock,
		params:             &UserServiceMockGetBalanceParams{ctx, userID},
		expectationOrigins: UserServiceMockGetBalanceExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmGetBalance.expectations = append(mmGetBalance.expectations, expectation)
	return expectation
}

// Then sets up UserService.GetBalance return parameters for the expectation previously defined by the When method
func (e *UserServiceMockGetBalanceExpectation) Then(f1 float64, err error) *UserServiceMock {
	e.results = &UserServiceMockGetBalanceResults{f1, err}
	return e.mock
}

// Times sets number of times UserService.GetBalance should be invoked
func (mmGetBalance *mUserServiceMockGetBalance) Times(n uint64) *mUserServiceMockGetBalance {
	if n == 0 {
		mmGetBalance.mock.t.Fatalf("Times of UserServiceMock.GetBalance mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmGetBalance.expectedInvocations, n)
	mmGetBalance.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmGetBalance
}

func (mmGetBalance *mUserServiceMockGetBalance) invocationsDone() bool {
	if len(mmGetBalance.expectations) == 0 && mmGetBalance.defaultExpectation == nil && mmGetBalance.mock.funcGetBalance == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmGetBalance.mock.afterGetBalanceCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmGetBalance.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// GetBalance implements mm_service.UserService
func (mmGetBalance *UserServiceMock) GetBalance(ctx context.Context, userID int) (f1 float64, err error) {
	mm_atomic.AddUint64(&mmGetBalance.beforeGetBalanceCounter, 1)
	defer mm_atomic.AddUint64(&mmGetBalance.afterGetBalanceCounter, 1)

	mmGetBalance.t.Helper()

	if mmGetBalance.inspectFuncGetBalance != nil {
		mmGetBalance.inspectFuncGetBalance(ctx, userID)
	}

	mm_params := UserServiceMockGetBalanceParams{ctx, userID}

	// Record call args
	mmGetBalance.GetBalanceMock.mutex.Lock()
	mmGetBalance.GetBalanceMock.callArgs = append(mmGetBalance.GetBalanceMock.callArgs, &mm_params)
	mmGetBalance.GetBalanceMock.mutex.Unlock()

	for _, e := range mmGetBalance.GetBalanceMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.f1, e.results.err
		}
	}

	if mmGetBalance.GetBalanceMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmGetBalance.GetBalanceMock.defaultExpectation.Counter, 1)
		mm_want := mmGetBalance.GetBalanceMock.defaultExpectation.params
		mm_want_ptrs := mmGetBalance.GetBalanceMock.defaultExpectation.paramPtrs

		mm_got := UserServiceMockGetBalanceParams{ctx, userID}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmGetBalance.t.Errorf("UserServiceMock.GetBalance got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmGetBalance.GetBalanceMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
				mmGetBalance.t.Errorf("UserServiceMock.GetBalance got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmGetBalance.GetBalanceMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmGetBalance.t.Errorf("UserServiceMock.GetBalance got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmGetBalance.GetBalanceMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmGetBalance.GetBalanceMock.defaultExpectation.results
		if mm_results == nil {
			mmGetBalance.t.Fatal("No results are set for the UserServiceMock.GetBalance")
		}
		return (*mm_results).f1, (*mm_results).err
	}
	if mmGetBalance.funcGetBalance != nil {
		return mmGetBalance.funcGetBalance(ctx, userID)
	}
	mmGetBalance.t.Fatalf("Unexpected call to UserServiceMock.GetBalance. %v %v", ctx, userID)
	return
}

// GetBalanceAfterCounter returns a count of finished UserServiceMock.GetBalance invocations
func (mmGetBalance *UserServiceMock) GetBalanceAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetBalance.afterGetBalanceCounter)
}

// GetBalanceBeforeCounter returns a count of UserServiceMock.GetBalance invocations
func (mmGetBalance *UserServiceMock) GetBalanceBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetBalance.beforeGetBalanceCounter)
}

// Calls returns a list of arguments used in each call to UserServiceMock.GetBalance.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmGetBalance *mUserServiceMockGetBalance) Calls() []*UserServiceMockGetBalanceParams {
	mmGetBalance.mutex.RLock()

	argCopy := make([]*UserServiceMockGetBalanceParams, len(mmGetBalance.callArgs))
	copy(argCopy, mmGetBalance.callArgs)

	mmGetBalance.mutex.RUnlock()

	return argCopy
}

// MinimockGetBalanceDone returns true if the count of the GetBalance invocations corresponds
// the number of defined expectations
func (m *UserServiceMock) MinimockGetBalanceDone() bool {
	if m.GetBalanceMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.GetBalanceMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.GetBalanceMock.invocationsDone()
}

// MinimockGetBalanceInspect logs each unmet expectation
func (m *UserServiceMock) MinimockGetBalanceInspect() {
	for _, e := range m.GetBalanceMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserServiceMock.GetBalance at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterGetBalanceCounter := mm_atomic.LoadUint64(&m.afterGetBalanceCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.GetBalanceMock.defaultExpectation != nil && afterGetBalanceCounter < 1 {
		if m.GetBalanceMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserServiceMock.GetBalance at\n%s", m.GetBalanceMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserServiceMock.GetBalance at\n%s with params: %#v", m.GetBalanceMock.defaultExpectation.expectationOrigins.origin, *m.GetBalanceMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcGetBalance != nil && afterGetBalanceCounter < 1 {
		m.t.Errorf("Expected call to UserServiceMock.GetBalance at\n%s", m.funcGetBalanceOrigin)
	}

	if !m.GetBalanceMock.invocationsDone() && afterGetBalanceCounter > 0 {
		m.t.Errorf("Expected %d calls to UserServiceMock.GetBalance at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.GetBalanceMock.expectedInvocations), m.GetBalanceMock.expectedInvocationsOrigin, afterGetBalanceCounter)
	}
}

type mUserServiceMockGetBalanceStatistics struct {
	optional           bool
	mock               *UserServiceMock
	defaultExpectation *UserServiceMockGetBalanceStatisticsExpectation
	expectations       []*UserServiceMockGetBalanceStatisticsExpectation

	callArgs []*UserServiceMockGetBalanceStatisticsParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserServiceMockGetBalanceStatisticsExpectation specifies expectation struct of the UserService.GetBalanceStatistics
type UserServiceMockGetBalanceStatisticsExpectation struct {
	mock               *UserServiceMock
	params             *UserServiceMockGetBalanceStatisticsParams
	paramPtrs          *UserServiceMockGetBalanceStatisticsParamPtrs
	expectationOrigins UserServiceMockGetBalanceStatisticsExpectationOrigins
	results            *UserServiceMockGetBalanceStatisticsResults
	returnOrigin       string
	Counter            uint64
}

// UserServiceMockGetBalanceStatisticsParams contains parameters of the UserService.GetBalanceStatistics
type UserServiceMockGetBalanceStatisticsParams struct {
	ctx    context.Context
	userID int
}

// UserServiceMockGetBalanceStatisticsParamPtrs contains pointers to parameters of the UserService.GetBalanceStatistics
type UserServiceMockGetBalanceStatisticsParamPtrs struct {
	ctx    *context.Context
	userID *int
}

// UserServiceMockGetBalanceStatisticsResults contains results of the UserService.GetBalanceStatistics
type UserServiceMockGetBalanceStatisticsResults struct {
	bp1 *mm_service.BalanceStatistics
	err error
}

// UserServiceMockGetBalanceStatisticsOrigins contains origins of expectations of the UserService.GetBalanceStatistics
type UserServiceMockGetBalanceStatisticsExpectationOrigins struct {
	origin       string
	originCtx    string
	originUserID string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmGetBalanceStatistics *mUserServiceMockGetBalanceStatistics) Optional() *mUserServiceMockGetBalanceStatistics {
	mmGetBalanceStatistics.optional = true
	return mmGetBalanceStatistics
}

// Expect sets up expected params for UserService.GetBalanceStatistics
func (mmGetBalanceStatistics *mUserServiceMockGetBalanceStatistics) Expect(ctx context.Context, userID int) *mUserServiceMockGetBalanceStatistics {
	if mmGetBalanceStatistics.mock.funcGetBalanceStatistics != nil {
		mmGetBalanceStatistics.mock.t.Fatalf("UserServiceMock.GetBalanceStatistics mock is already set by Set")
	}

	if mmGetBalanceStatistics.defaultExpectation == nil {
		mmGetBalanceStatistics.defaultExpectation = &UserServiceMockGetBalanceStatisticsExpectation{}
	}

	if mmGetBalanceStatistics.defaultExpectation.paramPtrs != nil {
		mmGetBalanceStatistics.mock.t.Fatalf("UserServiceMock.GetBalanceStatistics mock is already set by ExpectParams functions")
	}

	mmGetBalanceStatistics.defaultExpectation.params = &UserServiceMockGetBalanceStatisticsParams{ctx, userID}
	mmGetBalanceStatistics.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmGetBalanceStatistics.expectations {
		if minimock.Equal(e.params, mmGetBalanceStatistics.defaultExpectation.params) {
			mmGetBalanceStatistics.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetBalanceStatistics.defaultExpectation.params)
		}
	}

	return mmGetBalanceStatistics
}

// ExpectCtxParam1 sets up expected param ctx for UserService.GetBalanceStatistics
func (mmGetBalanceStatistics *mUserServiceMockGetBalanceStatistics) ExpectCtxParam1(ctx context.Context) *mUserServiceMockGetBalanceStatistics {
	if mmGetBalanceStatistics.mock.funcGetBalanceStatistics != nil {
		mmGetBalanceStatistics.mock.t.Fatalf("UserServiceMock.GetBalanceStatistics mock is already set by Set")
	}

	if mmGetBalanceStatistics.defaultExpectation == nil {
		mmGetBalanceStatistics.defaultExpectation = &UserServiceMockGetBalanceStatisticsExpectation{}
	}

	if mmGetBalanceStatistics.defaultExpectation.params != nil {
		mmGetBalanceStatistics.mock.t.Fatalf("UserServiceMock.GetBalanceStatistics mock is already set by Expect")
	}

	if mmGetBalanceStatistics.defaultExpectation.paramPtrs == nil {
		mmGetBalanceStatistics.defaultExpectation.paramPtrs = &UserServiceMockGetBalanceStatisticsParamPtrs{}
	}
	mmGetBalanceStatistics.defaultExpectation.paramPtrs.ctx = &ctx
	mmGetBalanceStatistics.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmGetBalanceStatistics
}

// ExpectUserIDParam2 sets up expected param userID for UserService.GetBalanceStatistics
func (mmGetBalanceStatistics *mUserServiceMockGetBalanceStatistics) ExpectUserIDParam2(userID int) *mUserServiceMockGetBalanceStatistics {
	if mmGetBalanceStatistics.mock.funcGetBalanceStatistics != nil {
		mmGetBalanceStatistics.mock.t.Fatalf("UserServiceMock.GetBalanceStatistics mock is already set by Set")
	}

	if mmGetBalanceStatistics.defaultExpectation == nil {
		mmGetBalanceStatistics.defaultExpectation = &UserServiceMockGetBalanceStatisticsExpectation{}
	}

	if mmGetBalanceStatistics.defaultExpectation.params != nil {
		mmGetBalanceStatistics.mock.t.Fatalf("UserServiceMock.GetBalanceStatistics mock is already set by Expect")
	}

	if mmGetBalanceStatistics.defaultExpectation.paramPtrs == nil {
		mmGetBalanceStatistics.defaultExpectation.paramPtrs = &UserServiceMockGetBalanceStatisticsParamPtrs{}
	}
	mmGetBalanceStatistics.defaultExpectation.paramPtrs.userID = &userID
	mmGetBalanceStatistics.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)

	return mmGetBalanceStatistics
}

// Inspect accepts an inspector function that has same arguments as the UserService.GetBalanceStatistics
func (mmGetBalanceStatistics *mUserServiceMockGetBalanceStatistics) Inspect(f func(ctx context.Context, userID int)) *mUserServiceMockGetBalanceStatistics {
	if mmGetBalanceStatistics.mock.inspectFuncGetBalanceStatistics != nil {
		mmGetBalanceStatistics.mock.t.Fatalf("Inspect function is already set for UserServiceMock.GetBalanceStatistics")
	}

	mmGetBalanceStatistics.mock.inspectFuncGetBalanceStatistics = f

	return mmGetBalanceStatistics
}

// Return sets up results that will be returned by UserService.GetBalanceStatistics
func (mmGetBalanceStatistics *mUserServiceMockGetBalanceStatistics) Return(bp1 *mm_service.BalanceStatistics, err error) *UserServiceMock {
	if mmGetBalanceStatistics.mock.funcGetBalanceStatistics != nil {
		mmGetBalanceStatistics.mock.t.Fatalf("UserServiceMock.GetBalanceStatistics mock is already set by Set")
	}

	if mmGetBalanceStatistics.defaultExpectation == nil {
		mmGetBalanceStatistics.defaultExpectation = &UserServiceMockGetBalanceStatisticsExpectation{mock: mmGetBalanceStatistics.mock}
	}
	mmGetBalanceStatistics.defaultExpectation.results = &UserServiceMockGetBalanceStatisticsResults{bp1, err}
	mmGetBalanceStatistics.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmGetBalanceStatistics.mock
}

// Set uses given function f to mock the UserService.GetBalanceStatistics method
func (mmGetBalanceStatistics *mUserServiceMockGetBalanceStatistics) Set(f func(ctx context.Context, userID int) (bp1 *mm_service.BalanceStatistics, err error)) *UserServiceMock {
	if mmGetBalanceStatistics.defaultExpectation != nil {
		mmGetBalanceStatistics.mock.t.Fatalf("Default expectation is already set for the UserService.GetBalanceStatistics method")
	}

	if len(mmGetBalanceStatistics.expectations) > 0 {
		mmGetBalanceStatistics.mock.t.Fatalf("Some expectations are already set for the UserService.GetBalanceStatistics method")
	}

	mmGetBalanceStatistics.mock.funcGetBalanceStatistics = f
	mmGetBalanceStatistics.mock.funcGetBalanceStatisticsOrigin = minimock.CallerInfo(1)
	return mmGetBalanceStatistics.mock
}

// When sets expectation for the UserService.GetBalanceStatistics which will trigger the result defined by the following
// Then helper
func (mmGetBalanceStatistics *mUserServiceMockGetBalanceStatistics) When(ctx context.Context, userID int) *UserServiceMockGetBalanceStatisticsExpectation {
	if mmGetBalanceStatistics.mock.funcGetBalanceStatistics != nil {
		mmGetBalanceStatistics.mock.t.Fatalf("UserServiceMock.GetBalanceStatistics mock is already set by Set")
	}

	expectation := &UserServiceMockGetBalanceStatisticsExpectation{
		mock:               mmGetBalanceStatistics.mock,
		params:             &UserServiceMockGetBalanceStatisticsParams{ctx, userID},
		expectationOrigins: UserServiceMockGetBalanceStatisticsExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmGetBalanceStatistics.expectations = append(mmGetBalanceStatistics.expectations, expectation)
	return expectation
}

// Then sets up UserService.GetBalanceStatistics return parameters for the expectation previously defined by the When method
func (e *UserServiceMockGetBalanceStatisticsExpectation) Then(bp1 *mm_service.BalanceStatistics, err error) *UserServiceMock {
	e.results = &UserServiceMockGetBalanceStatisticsResults{bp1, err}
	return e.mock
}

// Times sets number of times UserService.GetBalanceStatistics should be invoked
func (mmGetBalanceStatistics *mUserServiceMockGetBalanceStatistics) Times(n uint64) *mUserServiceMockGetBalanceStatistics {
	if n == 0 {
		mmGetBalanceStatistics.mock.t.Fatalf("Times of UserServiceMock.GetBalanceStatistics mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmGetBalanceStatistics.expectedInvocations, n)
	mmGetBalanceStatistics.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmGetBalanceStatistics
}

func (mmGetBalanceStatistics *mUserServiceMockGetBalanceStatistics) invocationsDone() bool {
	if len(mmGetBalanceStatistics.expectations) == 0 && mmGetBalanceStatistics.defaultExpectation == nil && mmGetBalanceStatistics.mock.funcGetBalanceStatistics == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmGetBalanceStatistics.mock.afterGetBalanceStatisticsCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmGetBalanceStatistics.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// GetBalanceStatistics implements mm_service.UserService
func (mmGetBalanceStatistics *UserServiceMock) GetBalanceStatistics(ctx context.Context, userID int) (bp1 *mm_service.BalanceStatistics, err error) {
	mm_atomic.AddUint64(&mmGetBalanceStatistics.beforeGetBalanceStatisticsCounter, 1)
	defer mm_atomic.AddUint64(&mmGetBalanceStatistics.afterGetBalanceStatisticsCounter, 1)

	mmGetBalanceStatistics.t.Helper()

	if mmGetBalanceStatistics.inspectFuncGetBalanceStatistics != nil {
		mmGetBalanceStatistics.inspectFuncGetBalanceStatistics(ctx, userID)
	}

	mm_params := UserServiceMockGetBalanceStatisticsParams{ctx, userID}

	// Record call args
	mmGetBalanceStatistics.GetBalanceStatisticsMock.mutex.Lock()
	mmGetBalanceStatistics.GetBalanceStatisticsMock.callArgs = append(mmGetBalanceStatistics.GetBalanceStatisticsMock.callArgs, &mm_params)
	mmGetBalanceStatistics.GetBalanceStatisticsMock.mutex.Unlock()

	for _, e := range mmGetBalanceStatistics.GetBalanceStatisticsMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.bp1, e.results.err
		}
	}

	if mmGetBalanceStatistics.GetBalanceStatisticsMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmGetBalanceStatistics.GetBalanceStatisticsMock.defaultExpectation.Counter, 1)
		mm_want := mmGetBalanceStatistics.GetBalanceStatisticsMock.defaultExpectation.params
		mm_want_ptrs := mmGetBalanceStatistics.GetBalanceStatisticsMock.defaultExpectation.paramPtrs

		mm_got := UserServiceMockGetBalanceStatisticsParams{ctx, userID}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmGetBalanceStatistics.t.Errorf("UserServiceMock.GetBalanceStatistics got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmGetBalanceStatistics.GetBalanceStatisticsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
				mmGetBalanceStatistics.t.Errorf("UserServiceMock.GetBalanceStatistics got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmGetBalanceStatistics.GetBalanceStatisticsMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmGetBalanceStatistics.t.Errorf("UserServiceMock.GetBalanceStatistics got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmGetBalanceStatistics.GetBalanceStatisticsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmGetBalanceStatistics.GetBalanceStatisticsMock.defaultExpectation.results
		if mm_results == nil {
			mmGetBalanceStatistics.t.Fatal("No results are set for the UserServiceMock.GetBalanceStatistics")
		}
		return (*mm_results).bp1, (*mm_results).err
	}
	if mmGetBalanceStatistics.funcGetBalanceStatistics != nil {
		return mmGetBalanceStatistics.funcGetBalanceStatistics(ctx, userID)
	}
	mmGetBalanceStatistics.t.Fatalf("Unexpected call to UserServiceMock.GetBalanceStatistics. %v %v", ctx, userID)
	return
}

// GetBalanceStatisticsAfterCounter returns a count of finished UserServiceMock.GetBalanceStatistics invocations
func (mmGetBalanceStatistics *UserServiceMock) GetBalanceStatisticsAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetBalanceStatistics.afterGetBalanceStatisticsCounter)
}

// GetBalanceStatisticsBeforeCounter returns a count of UserServiceMock.GetBalanceStatistics invocations
func (mmGetBalanceStatistics *UserServiceMock) GetBalanceStatisticsBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetBalanceStatistics.beforeGetBalanceStatisticsCounter)
}

// Calls returns a list of arguments used in each call to UserServiceMock.GetBalanceStatistics.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmGetBalanceStatistics *mUserServiceMockGetBalanceStatistics) Calls() []*UserServiceMockGetBalanceStatisticsParams {
	mmGetBalanceStatistics.mutex.RLock()

	argCopy := make([]*UserServiceMockGetBalanceStatisticsParams, len(mmGetBalanceStatistics.callArgs))
	copy(argCopy, mmGetBalanceStatistics.callArgs)

	mmGetBalanceStatistics.mutex.RUnlock()

	return argCopy
}

// MinimockGetBalanceStatisticsDone returns true if the count of the GetBalanceStatistics invocations corresponds
// the number of defined expectations
func (m *UserServiceMock) MinimockGetBalanceStatisticsDone() bool {
	if m.GetBalanceStatisticsMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.GetBalanceStatisticsMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.GetBalanceStatisticsMock.invocationsDone()
}

// MinimockGetBalanceStatisticsInspect logs each unmet expectation
func (m *UserServiceMock) MinimockGetBalanceStatisticsInspect() {
	for _, e := range m.GetBalanceStatisticsMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserServiceMock.GetBalanceStatistics at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterGetBalanceStatisticsCounter := mm_atomic.LoadUint64(&m.afterGetBalanceStatisticsCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.GetBalanceStatisticsMock.defaultExpectation != nil && afterGetBalanceStatisticsCounter < 1 {
		if m.GetBalanceStatisticsMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserServiceMock.GetBalanceStatistics at\n%s", m.GetBalanceStatisticsMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserServiceMock.GetBalanceStatistics at\n%s with params: %#v", m.GetBalanceStatisticsMock.defaultExpectation.expectationOrigins.origin, *m.GetBalanceStatisticsMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcGetBalanceStatistics != nil && afterGetBalanceStatisticsCounter < 1 {
		m.t.Errorf("Expected call to UserServiceMock.GetBalanceStatistics at\n%s", m.funcGetBalanceStatisticsOrigin)
	}

	if !m.GetBalanceStatisticsMock.invocationsDone() && afterGetBalanceStatisticsCounter > 0 {
		m.t.Errorf("Expected %d calls to UserServiceMock.GetBalanceStatistics at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.GetBalanceStatisticsMock.expectedInvocations), m.GetBalanceStatisticsMock.expectedInvocationsOrigin, afterGetBalanceStatisticsCounter)
	}
}

type mUserServiceMockGetInfo struct {
	optional           bool
	mock               *UserServiceMock
	defaultExpectation *UserServiceMockGetInfoExpectation
	expectations       []*UserServiceMockGetInfoExpectation

	callArgs []*UserServiceMockGetInfoParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserServiceMockGetInfoExpectation specifies expectation struct of the UserService.GetInfo
type UserServiceMockGetInfoExpectation struct {
	mock               *UserServiceMock
	params             *UserServiceMockGetInfoParams
	paramPtrs          *UserServiceMockGetInfoParamPtrs
	expectationOrigins UserServiceMockGetInfoExpectationOrigins
	results            *UserServiceMockGetInfoResults
	returnOrigin       string
	Counter            uint64
}

// UserServiceMockGetInfoParams contains parameters of the UserService.GetInfo
type UserServiceMockGetInfoParams struct {
	ctx    context.Context
	userID int
}

// UserServiceMockGetInfoParamPtrs contains pointers to parameters of the UserService.GetInfo
type UserServiceMockGetInfoParamPtrs struct {
	ctx    *context.Context
	userID *int
}

// UserServiceMockGetInfoResults contains results of the UserService.GetInfo
type UserServiceMockGetInfoResults struct {
	up1 *mm_service.UserInfo
	err error
}

// UserServiceMockGetInfoOrigins contains origins of expectations of the UserService.GetInfo
type UserServiceMockGetInfoExpectationOrigins struct {
	origin       string
	originCtx    string
	originUserID string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmGetInfo *mUserServiceMockGetInfo) Optional() *mUserServiceMockGetInfo {
	mmGetInfo.optional = true
	return mmGetInfo
}

// Expect sets up expected params for UserService.GetInfo
func (mmGetInfo *mUserServiceMockGetInfo) Expect(ctx context.Context, userID int) *mUserServiceMockGetInfo {
	if mmGetInfo.mock.funcGetInfo != nil {
		mmGetInfo.mock.t.Fatalf("UserServiceMock.GetInfo mock is already set by Set")
	}

	if mmGetInfo.defaultExpectation == nil {
		mmGetInfo.defaultExpectation = &UserServiceMockGetInfoExpectation{}
	}

	if mmGetInfo.defaultExpectation.paramPtrs != nil {
		mmGetInfo.mock.t.Fatalf("UserServiceMock.GetInfo mock is already set by ExpectParams functions")
	}

	mmGetInfo.defaultExpectation.params = &UserServiceMockGetInfoParams{ctx, userID}
	mmGetInfo.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmGetInfo.expectations {
		if minimock.Equal(e.params, mmGetInfo.defaultExpectation.params) {
			mmGetInfo.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetInfo.defaultExpectation.params)
		}
	}

	return mmGetInfo
}

// ExpectCtxParam1 sets up expected param ctx for UserService.GetInfo
func (mmGetInfo *mUserServiceMockGetInfo) ExpectCtxParam1(ctx context.Context) *mUserServiceMockGetInfo {
	if mmGetInfo.mock.funcGetInfo != nil {
		mmGetInfo.mock.t.Fatalf("UserServiceMock.GetInfo mock is already set by Set")
	}

	if mmGetInfo.defaultExpectation == nil {
		mmGetInfo.defaultExpectation = &UserServiceMockGetInfoExpectation{}
	}

	if mmGetInfo.defaultExpectation.params != nil {
		mmGetInfo.mock.t.Fatalf("UserServiceMock.GetInfo mock is already set by Expect")
	}

	if mmGetInfo.defaultExpectation.paramPtrs == nil {
		mmGetInfo.defaultExpectation.paramPtrs = &UserServiceMockGetInfoParamPtrs{}
	}
	mmGetInfo.defaultExpectation.paramPtrs.ctx = &ctx
	mmGetInfo.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmGetInfo
}

// ExpectUserIDParam2 sets up expected param userID for UserService.GetInfo
func (mmGetInfo *mUserServiceMockGetInfo) ExpectUserIDParam2(userID int) *mUserServiceMockGetInfo {
	if mmGetInfo.mock.funcGetInfo != nil {
		mmGetInfo.mock.t.Fatalf("UserServiceMock.GetInfo mock is already set by Set")
	}

	if mmGetInfo.defaultExpectation == nil {
		mmGetInfo.defaultExpectation = &UserServiceMockGetInfoExpectation{}
	}

	if mmGetInfo.defaultExpectation.params != nil {
		mmGetInfo.mock.t.Fatalf("UserServiceMock.GetInfo mock is already set by Expect")
	}

	if mmGetInfo.defaultExpectation.paramPtrs == nil {
		mmGetInfo.defaultExpectation.paramPtrs = &UserServiceMockGetInfoParamPtrs{}
	}
	mmGetInfo.defaultExpectation.paramPtrs.userID = &userID
	mmGetInfo.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)

	return mmGetInfo
}

// Inspect accepts an inspector function that has same arguments as the UserService.GetInfo
func (mmGetInfo *mUserServiceMockGetInfo) Inspect(f func(ctx context.Context, userID int)) *mUserServiceMockGetInfo {
	if mmGetInfo.mock.inspectFuncGetInfo != nil {
		mmGetInfo.mock.t.Fatalf("Inspect function is already set for UserServiceMock.GetInfo")
	}

	mmGetInfo.mock.inspectFuncGetInfo = f

	return mmGetInfo
}

// Return sets up results that will be returned by UserService.GetInfo
func (mmGetInfo *mUserServiceMockGetInfo) Return(up1 *mm_service.UserInfo, err error) *UserServiceMock {
	if mmGetInfo.mock.funcGetInfo != nil {
		mmGetInfo.mock.t.Fatalf("UserServiceMock.GetInfo mock is already set by Set")
	}

	if mmGetInfo.defaultExpectation == nil {
		mmGetInfo.defaultExpectation = &UserServiceMockGetInfoExpectation{mock: mmGetInfo.mock}
	}
	mmGetInfo.defaultExpectation.results = &UserServiceMockGetInfoResults{up1, err}
	mmGetInfo.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmGetInfo.mock
}

// Set uses given function f to mock the UserService.GetInfo method
func (mmGetInfo *mUserServiceMockGetInfo) Set(f func(ctx context.Context, userID int) (up1 *mm_service.UserInfo, err error)) *UserServiceMock {
	if mmGetInfo.defaultExpectation != nil {
		mmGetInfo.mock.t.Fatalf("Default expectation is already set for the UserService.GetInfo method")
	}

	if len(mmGetInfo.expectations) > 0 {
		mmGetInfo.mock.t.Fatalf("Some expectations are already set for the UserService.GetInfo method")
	}

	mmGetInfo.mock.funcGetInfo = f
	mmGetInfo.mock.funcGetInfoOrigin = minimock.CallerInfo(1)
	return mmGetInfo.mock
}

// When sets expectation for the UserService.GetInfo which will trigger the result defined by the following
// Then helper
func (mmGetInfo *mUserServiceMockGetInfo) When(ctx context.Context, userID int) *UserServiceMockGetInfoExpectation {
	if mmGetInfo.mock.funcGetInfo != nil {
		mmGetInfo.mock.t.Fatalf("UserServiceMock.GetInfo mock is already set by Set")
	}

	expectation := &UserServiceMockGetInfoExpectation{
		mock:               mmGetInfo.mock,
		params:             &UserServiceMockGetInfoParams{ctx, userID},
		expectationOrigins: UserServiceMockGetInfoExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmGetInfo.expectations = append(mmGetInfo.expectations, expectation)
	return expectation
}

// Then sets up UserService.GetInfo return parameters for the expectation previously defined by the When method
func (e *UserServiceMockGetInfoExpectation) Then(up1 *mm_service.UserInfo, err error) *UserServiceMock {
	e.results = &UserServiceMockGetInfoResults{up1, err}
	return e.mock
}

// Times sets number of times UserService.GetInfo should be invoked
func (mmGetInfo *mUserServiceMockGetInfo) Times(n uint64) *mUserServiceMockGetInfo {
	if n == 0 {
		mmGetInfo.mock.t.Fatalf("Times of UserServiceMock.GetInfo mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmGetInfo.expectedInvocations, n)
	mmGetInfo.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmGetInfo
}

func (mmGetInfo *mUserServiceMockGetInfo) invocationsDone() bool {
	if len(mmGetInfo.expectations) == 0 && mmGetInfo.defaultExpectation == nil && mmGetInfo.mock.funcGetInfo == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmGetInfo.mock.afterGetInfoCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmGetInfo.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// GetInfo implements mm_service.UserService
func (mmGetInfo *UserServiceMock) GetInfo(ctx context.Context, userID int) (up1 *mm_service.UserInfo, err error) {
	mm_atomic.AddUint64(&mmGetInfo.beforeGetInfoCounter, 1)
	defer mm_atomic.AddUint64(&mmGetInfo.afterGetInfoCounter, 1)

	mmGetInfo.t.Helper()

	if mmGetInfo.inspectFuncGetInfo != nil {
		mmGetInfo.inspectFuncGetInfo(ctx, userID)
	}

	mm_params := UserServiceMockGetInfoParams{ctx, userID}

	// Record call args
	mmGetInfo.GetInfoMock.mutex.Lock()
	mmGetInfo.GetInfoMock.callArgs = append(mmGetInfo.GetInfoMock.callArgs, &mm_params)
	mmGetInfo.GetInfoMock.mutex.Unlock()

	for _, e := range mmGetInfo.GetInfoMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.up1, e.results.err
		}
	}

	if mmGetInfo.GetInfoMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmGetInfo.GetInfoMock.defaultExpectation.Counter, 1)
		mm_want := mmGetInfo.GetInfoMock.defaultExpectation.params
		mm_want_ptrs := mmGetInfo.GetInfoMock.defaultExpectation.paramPtrs

		mm_got := UserServiceMockGetInfoParams{ctx, userID}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmGetInfo.t.Errorf("UserServiceMock.GetInfo got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmGetInfo.GetInfoMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
				mmGetInfo.t.Errorf("UserServiceMock.GetInfo got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmGetInfo.GetInfoMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmGetInfo.t.Errorf("UserServiceMock.GetInfo got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmGetInfo.GetInfoMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmGetInfo.GetInfoMock.defaultExpectation.results
		if mm_results == nil {
			mmGetInfo.t.Fatal("No results are set for the UserServiceMock.GetInfo")
		}
		return (*mm_results).up1, (*mm_results).err
	}
	if mmGetInfo.funcGetInfo != nil {
		return mmGetInfo.funcGetInfo(ctx, userID)
	}
	mmGetInfo.t.Fatalf("Unexpected call to UserServiceMock.GetInfo. %v %v", ctx, userID)
	return
}

// GetInfoAfterCounter returns a count of finished UserServiceMock.GetInfo invocations
func (mmGetInfo *UserServiceMock) GetInfoAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetInfo.afterGetInfoCounter)
}

// GetInfoBeforeCounter returns a count of UserServiceMock.GetInfo invocations
func (mmGetInfo *UserServiceMock) GetInfoBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetInfo.beforeGetInfoCounter)
}

// Calls returns a list of arguments used in each call to UserServiceMock.GetInfo.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmGetInfo *mUserServiceMockGetInfo) Calls() []*UserServiceMockGetInfoParams {
	mmGetInfo.mutex.RLock()

	argCopy := make([]*UserServiceMockGetInfoParams, len(mmGetInfo.callArgs))
	copy(argCopy, mmGetInfo.callArgs)

	mmGetInfo.mutex.RUnlock()

	return argCopy
}

// MinimockGetInfoDone returns true if the count of the GetInfo invocations corresponds
// the number of defined expectations
func (m *UserServiceMock) MinimockGetInfoDone() bool {
	if m.GetInfoMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.GetInfoMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.GetInfoMock.invocationsDone()
}

// MinimockGetInfoInspect logs each unmet expectation
func (m *UserServiceMock) MinimockGetInfoInspect() {
	for _, e := range m.GetInfoMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserServiceMock.GetInfo at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterGetInfoCounter := mm_atomic.LoadUint64(&m.afterGetInfoCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.GetInfoMock.defaultExpectation != nil && afterGetInfoCounter < 1 {
		if m.GetInfoMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserServiceMock.GetInfo at\n%s", m.GetInfoMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserServiceMock.GetInfo at\n%s with params: %#v", m.GetInfoMock.defaultExpectation.expectationOrigins.origin, *m.GetInfoMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcGetInfo != nil && afterGetInfoCounter < 1 {
		m.t.Errorf("Expected call to UserServiceMock.GetInfo at\n%s", m.funcGetInfoOrigin)
	}

	if !m.GetInfoMock.invocationsDone() && afterGetInfoCounter > 0 {
		m.t.Errorf("Expected %d calls to UserServiceMock.GetInfo at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.GetInfoMock.expectedInvocations), m.GetInfoMock.expectedInvocationsOrigin, afterGetInfoCounter)
	}
}

type mUserServiceMockGetStatistics struct {
	optional           bool
	mock               *UserServiceMock
	defaultExpectation *UserServiceMockGetStatisticsExpectation
	expectations       []*UserServiceMockGetStatisticsExpectation

	callArgs []*UserServiceMockGetStatisticsParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// UserServiceMockGetStatisticsExpectation specifies expectation struct of the UserService.GetStatistics
type UserServiceMockGetStatisticsExpectation struct {
	mock               *UserServiceMock
	params             *UserServiceMockGetStatisticsParams
	paramPtrs          *UserServiceMockGetStatisticsParamPtrs
	expectationOrigins UserServiceMockGetStatisticsExpectationOrigins
	results            *UserServiceMockGetStatisticsResults
	returnOrigin       string
	Counter            uint64
}

// UserServiceMockGetStatisticsParams contains parameters of the UserService.GetStatistics
type UserServiceMockGetStatisticsParams struct {
	ctx    context.Context
	userID int
}

// UserServiceMockGetStatisticsParamPtrs contains pointers to parameters of the UserService.GetStatistics
type UserServiceMockGetStatisticsParamPtrs struct {
	ctx    *context.Context
	userID *int
}

// UserServiceMockGetStatisticsResults contains results of the UserService.GetStatistics
type UserServiceMockGetStatisticsResults struct {
	sp1 *mm_service.Statistics
	err error
}

// UserServiceMockGetStatisticsOrigins contains origins of expectations of the UserService.GetStatistics
type UserServiceMockGetStatisticsExpectationOrigins struct {
	origin       string
	originCtx    string
	originUserID string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmGetStatistics *mUserServiceMockGetStatistics) Optional() *mUserServiceMockGetStatistics {
	mmGetStatistics.optional = true
	return mmGetStatistics
}

// Expect sets up expected params for UserService.GetStatistics
func (mmGetStatistics *mUserServiceMockGetStatistics) Expect(ctx context.Context, userID int) *mUserServiceMockGetStatistics {
	if mmGetStatistics.mock.funcGetStatistics != nil {
		mmGetStatistics.mock.t.Fatalf("UserServiceMock.GetStatistics mock is already set by Set")
	}

	if mmGetStatistics.defaultExpectation == nil {
		mmGetStatistics.defaultExpectation = &UserServiceMockGetStatisticsExpectation{}
	}

	if mmGetStatistics.defaultExpectation.paramPtrs != nil {
		mmGetStatistics.mock.t.Fatalf("UserServiceMock.GetStatistics mock is already set by ExpectParams functions")
	}

	mmGetStatistics.defaultExpectation.params = &UserServiceMockGetStatisticsParams{ctx, userID}
	mmGetStatistics.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmGetStatistics.expectations {
		if minimock.Equal(e.params, mmGetStatistics.defaultExpectation.params) {
			mmGetStatistics.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetStatistics.defaultExpectation.params)
		}
	}

	return mmGetStatistics
}

// ExpectCtxParam1 sets up expected param ctx for UserService.GetStatistics
func (mmGetStatistics *mUserServiceMockGetStatistics) ExpectCtxParam1(ctx context.Context) *mUserServiceMockGetStatistics {
	if mmGetStatistics.mock.funcGetStatistics != nil {
		mmGetStatistics.mock.t.Fatalf("UserServiceMock.GetStatistics mock is already set by Set")
	}

	if mmGetStatistics.defaultExpectation == nil {
		mmGetStatistics.defaultExpectation = &UserServiceMockGetStatisticsExpectation{}
	}

	if mmGetStatistics.defaultExpectation.params != nil {
		mmGetStatistics.mock.t.Fatalf("UserServiceMock.GetStatistics mock is already set by Expect")
	}

	if mmGetStatistics.defaultExpectation.paramPtrs == nil {
		mmGetStatistics.defaultExpectation.paramPtrs = &UserServiceMockGetStatisticsParamPtrs{}
	}
	mmGetStatistics.defaultExpectation.paramPtrs.ctx = &ctx
	mmGetStatistics.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmGetStatistics
}

// ExpectUserIDParam2 sets up expected param userID for UserService.GetStatistics
func (mmGetStatistics *mUserServiceMockGetStatistics) ExpectUserIDParam2(userID int) *mUserServiceMockGetStatistics {
	if mmGetStatistics.mock.funcGetStatistics != nil {
		mmGetStatistics.mock.t.Fatalf("UserServiceMock.GetStatistics mock is already set by Set")
	}

	if mmGetStatistics.defaultExpectation == nil {
		mmGetStatistics.defaultExpectation = &UserServiceMockGetStatisticsExpectation{}
	}

	if mmGetStatistics.defaultExpectation.params != nil {
		mmGetStatistics.mock.t.Fatalf("UserServiceMock.GetStatistics mock is already set by Expect")
	}

	if mmGetStatistics.defaultExpectation.paramPtrs == nil {
		mmGetStatistics.defaultExpectation.paramPtrs = &UserServiceMockGetStatisticsParamPtrs{}
	}
	mmGetStatistics.defaultExpectation.paramPtrs.userID = &userID
	mmGetStatistics.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)

	return mmGetStatistics
}

// Inspect accepts an inspector function that has same arguments as the UserService.GetStatistics
func (mmGetStatistics *mUserServiceMockGetStatistics) Inspect(f func(ctx context.Context, userID int)) *mUserServiceMockGetStatistics {
	if mmGetStatistics.mock.inspectFuncGetStatistics != nil {
		mmGetStatistics.mock.t.Fatalf("Inspect function is already set for UserServiceMock.GetStatistics")
	}

	mmGetStatistics.mock.inspectFuncGetStatistics = f

	return mmGetStatistics
}

// Return sets up results that will be returned by UserService.GetStatistics
func (mmGetStatistics *mUserServiceMockGetStatistics) Return(sp1 *mm_service.Statistics, err error) *UserServiceMock {
	if mmGetStatistics.mock.funcGetStatistics != nil {
		mmGetStatistics.mock.t.Fatalf("UserServiceMock.GetStatistics mock is already set by Set")
	}

	if mmGetStatistics.defaultExpectation == nil {
		mmGetStatistics.defaultExpectation = &UserServiceMockGetStatisticsExpectation{mock: mmGetStatistics.mock}
	}
	mmGetStatistics.defaultExpectation.results = &UserServiceMockGetStatisticsResults{sp1, err}
	mmGetStatistics.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmGetStatistics.mock
}

// Set uses given function f to mock the UserService.GetStatistics method
func (mmGetStatistics *mUserServiceMockGetStatistics) Set(f func(ctx context.Context, userID int) (sp1 *mm_service.Statistics, err error)) *UserServiceMock {
	if mmGetStatistics.defaultExpectation != nil {
		mmGetStatistics.mock.t.Fatalf("Default expectation is already set for the UserService.GetStatistics method")
	}

	if len(mmGetStatistics.expectations) > 0 {
		mmGetStatistics.mock.t.Fatalf("Some expectations are already set for the UserService.GetStatistics method")
	}

	mmGetStatistics.mock.funcGetStatistics = f
	mmGetStatistics.mock.funcGetStatisticsOrigin = minimock.CallerInfo(1)
	return mmGetStatistics.mock
}

// When sets expectation for the UserService.GetStatistics which will trigger the result defined by the following
// Then helper
func (mmGetStatistics *mUserServiceMockGetStatistics) When(ctx context.Context, userID int) *UserServiceMockGetStatisticsExpectation {
	if mmGetStatistics.mock.funcGetStatistics != nil {
		mmGetStatistics.mock.t.Fatalf("UserServiceMock.GetStatistics mock is already set by Set")
	}

	expectation := &UserServiceMockGetStatisticsExpectation{
		mock:               mmGetStatistics.mock,
		params:             &UserServiceMockGetStatisticsParams{ctx, userID},
		expectationOrigins: UserServiceMockGetStatisticsExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmGetStatistics.expectations = append(mmGetStatistics.expectations, expectation)
	return expectation
}

// Then sets up UserService.GetStatistics return parameters for the expectation previously defined by the When method
func (e *UserServiceMockGetStatisticsExpectation) Then(sp1 *mm_service.Statistics, err error) *UserServiceMock {
	e.results = &UserServiceMockGetStatisticsResults{sp1, err}
	return e.mock
}

// Times sets number of times UserService.GetStatistics should be invoked
func (mmGetStatistics *mUserServiceMockGetStatistics) Times(n uint64) *mUserServiceMockGetStatistics {
	if n == 0 {
		mmGetStatistics.mock.t.Fatalf("Times of UserServiceMock.GetStatistics mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmGetStatistics.expectedInvocations, n)
	mmGetStatistics.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmGetStatistics
}

func (mmGetStatistics *mUserServiceMockGetStatistics) invocationsDone() bool {
	if len(mmGetStatistics.expectations) == 0 && mmGetStatistics.defaultExpectation == nil && mmGetStatistics.mock.funcGetStatistics == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmGetStatistics.mock.afterGetStatisticsCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmGetStatistics.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// GetStatistics implements mm_service.UserService
func (mmGetStatistics *UserServiceMock) GetStatistics(ctx context.Context, userID int) (sp1 *mm_service.Statistics, err error) {
	mm_atomic.AddUint64(&mmGetStatistics.beforeGetStatisticsCounter, 1)
	defer mm_atomic.AddUint64(&mmGetStatistics.afterGetStatisticsCounter, 1)

	mmGetStatistics.t.Helper()

	if mmGetStatistics.inspectFuncGetStatistics != nil {
		mmGetStatistics.inspectFuncGetStatistics(ctx, userID)
	}

	mm_params := UserServiceMockGetStatisticsParams{ctx, userID}

	// Record call args
	mmGetStatistics.GetStatisticsMock.mutex.Lock()
	mmGetStatistics.GetStatisticsMock.callArgs = append(mmGetStatistics.GetStatisticsMock.callArgs, &mm_params)
	mmGetStatistics.GetStatisticsMock.mutex.Unlock()

	for _, e := range mmGetStatistics.GetStatisticsMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.sp1, e.results.err
		}
	}

	if mmGetStatistics.GetStatisticsMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmGetStatistics.GetStatisticsMock.defaultExpectation.Counter, 1)
		mm_want := mmGetStatistics.GetStatisticsMock.defaultExpectation.params
		mm_want_ptrs := mmGetStatistics.GetStatisticsMock.defaultExpectation.paramPtrs

		mm_got := UserServiceMockGetStatisticsParams{ctx, userID}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmGetStatistics.t.Errorf("UserServiceMock.GetStatistics got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmGetStatistics.GetStatisticsMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
				mmGetStatistics.t.Errorf("UserServiceMock.GetStatistics got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmGetStatistics.GetStatisticsMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmGetStatistics.t.Errorf("UserServiceMock.GetStatistics got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmGetStatistics.GetStatisticsMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmGetStatistics.GetStatisticsMock.defaultExpectation.results
		if mm_results == nil {
			mmGetStatistics.t.Fatal("No results are set for the UserServiceMock.GetStatistics")
		}
		return (*mm_results).sp1, (*mm_results).err
	}
	if mmGetStatistics.funcGetStatistics != nil {
		return mmGetStatistics.funcGetStatistics(ctx, userID)
	}
	mmGetStatistics.t.Fatalf("Unexpected call to UserServiceMock.GetStatistics. %v %v", ctx, userID)
	return
}

// GetStatisticsAfterCounter returns a count of finished UserServiceMock.GetStatistics invocations
func (mmGetStatistics *UserServiceMock) GetStatisticsAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetStatistics.afterGetStatisticsCounter)
}

// GetStatisticsBeforeCounter returns a count of UserServiceMock.GetStatistics invocations
func (mmGetStatistics *UserServiceMock) GetStatisticsBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetStatistics.beforeGetStatisticsCounter)
}

// Calls returns a list of arguments used in each call to UserServiceMock.GetStatistics.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmGetStatistics *mUserServiceMockGetStatistics) Calls() []*UserServiceMockGetStatisticsParams {
	mmGetStatistics.mutex.RLock()

	argCopy := make([]*UserServiceMockGetStatisticsParams, len(mmGetStatistics.callArgs))
	copy(argCopy, mmGetStatistics.callArgs)

	mmGetStatistics.mutex.RUnlock()

	return argCopy
}

// MinimockGetStatisticsDone returns true if the count of the GetStatistics invocations corresponds
// the number of defined expectations
func (m *UserServiceMock) MinimockGetStatisticsDone() bool {
	if m.GetStatisticsMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.GetStatisticsMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.GetStatisticsMock.invocationsDone()
}

// MinimockGetStatisticsInspect logs each unmet expectation
func (m *UserServiceMock) MinimockGetStatisticsInspect() {
	for _, e := range m.GetStatisticsMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to UserServiceMock.GetStatistics at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterGetStatisticsCounter := mm_atomic.LoadUint64(&m.afterGetStatisticsCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.GetStatisticsMock.defaultExpectation != nil && afterGetStatisticsCounter < 1 {
		if m.GetStatisticsMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to UserServiceMock.GetStatistics at\n%s", m.GetStatisticsMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to UserServiceMock.GetStatistics at\n%s with params: %#v", m.GetStatisticsMock.defaultExpectation.expectationOrigins.origin, *m.GetStatisticsMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcGetStatistics != nil && afterGetStatisticsCounter < 1 {
		m.t.Errorf("Expected call to UserServiceMock.GetStatistics at\n%s", m.funcGetStatisticsOrigin)
	}

	if !m.GetStatisticsMock.invocationsDone() && afterGetStatisticsCounter > 0 {
		m.t.Errorf("Expected %d calls to UserServiceMock.GetStatistics at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.GetStatisticsMock.expectedInvocations), m.GetStatisticsMock.expectedInvocationsOrigin, afterGetStatisticsCounter)
	}
}

// MinimockFinish checks that all mocked methods have been called the expected number of times
func (m *UserServiceMock) MinimockFinish() {
	m.finishOnce.Do(func() {
		if !m.minimockDone() {
			m.MinimockGetBalanceInspect()

			m.MinimockGetBalanceStatisticsInspect()

			m.MinimockGetInfoInspect()

			m.MinimockGetStatisticsInspect()
		}
	})
}

// MinimockWait waits for all mocked methods to be called the expected number of times
func (m *UserServiceMock) MinimockWait(timeout mm_time.Duration) {
	timeoutCh := mm_time.After(timeout)
	for {
		if m.minimockDone() {
			return
		}
		select {
		case <-timeoutCh:
			m.MinimockFinish()
			return
		case <-mm_time.After(10 * mm_time.Millisecond):
		}
	}
}

func (m *UserServiceMock) minimockDone() bool {
	done := true
	return done &&
		m.MinimockGetBalanceDone() &&
		m.MinimockGetBalanceStatisticsDone() &&
		m.MinimockGetInfoDone() &&
		m.MinimockGetStatisticsDone()
}