// Code generated by MockGen. DO NOT EDIT.
// Source: interfaces.go
//
// Generated by this command:
//
//	mockgen -source=interfaces.go -destination=./mocks_test.go -package=usecase
//

// Package usecase is a generated GoMock package.
package usecase

import (
	context "context"
	reflect "reflect"
	time "time"

	entity "github.com/toc-taiwan/toc-machine-trading/internal/entity"
	pb "github.com/toc-taiwan/toc-trade-protobuf/golang/pb"
	gomock "go.uber.org/mock/gomock"
)

// MockAnalyze is a mock of Analyze interface.
type MockAnalyze struct {
	ctrl     *gomock.Controller
	recorder *MockAnalyzeMockRecorder
}

// MockAnalyzeMockRecorder is the mock recorder for MockAnalyze.
type MockAnalyzeMockRecorder struct {
	mock *MockAnalyze
}

// NewMockAnalyze creates a new mock instance.
func NewMockAnalyze(ctrl *gomock.Controller) *MockAnalyze {
	mock := &MockAnalyze{ctrl: ctrl}
	mock.recorder = &MockAnalyzeMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAnalyze) EXPECT() *MockAnalyzeMockRecorder {
	return m.recorder
}

// GetRebornMap mocks base method.
func (m *MockAnalyze) GetRebornMap(ctx context.Context) map[time.Time][]entity.Stock {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRebornMap", ctx)
	ret0, _ := ret[0].(map[time.Time][]entity.Stock)
	return ret0
}

// GetRebornMap indicates an expected call of GetRebornMap.
func (mr *MockAnalyzeMockRecorder) GetRebornMap(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRebornMap", reflect.TypeOf((*MockAnalyze)(nil).GetRebornMap), ctx)
}

// MockBasic is a mock of Basic interface.
type MockBasic struct {
	ctrl     *gomock.Controller
	recorder *MockBasicMockRecorder
}

// MockBasicMockRecorder is the mock recorder for MockBasic.
type MockBasicMockRecorder struct {
	mock *MockBasic
}

// NewMockBasic creates a new mock instance.
func NewMockBasic(ctrl *gomock.Controller) *MockBasic {
	mock := &MockBasic{ctrl: ctrl}
	mock.recorder = &MockBasicMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBasic) EXPECT() *MockBasicMockRecorder {
	return m.recorder
}

// CreateFutureSearchRoom mocks base method.
func (m *MockBasic) CreateFutureSearchRoom(com chan string, dataChan chan []*entity.Future) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CreateFutureSearchRoom", com, dataChan)
}

// CreateFutureSearchRoom indicates an expected call of CreateFutureSearchRoom.
func (mr *MockBasicMockRecorder) CreateFutureSearchRoom(com, dataChan any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFutureSearchRoom", reflect.TypeOf((*MockBasic)(nil).CreateFutureSearchRoom), com, dataChan)
}

// CreateStockSearchRoom mocks base method.
func (m *MockBasic) CreateStockSearchRoom(com chan string, dataChan chan []*entity.Stock) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CreateStockSearchRoom", com, dataChan)
}

// CreateStockSearchRoom indicates an expected call of CreateStockSearchRoom.
func (mr *MockBasicMockRecorder) CreateStockSearchRoom(com, dataChan any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStockSearchRoom", reflect.TypeOf((*MockBasic)(nil).CreateStockSearchRoom), com, dataChan)
}

// GetFutureDetail mocks base method.
func (m *MockBasic) GetFutureDetail(futureCode string) *entity.Future {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFutureDetail", futureCode)
	ret0, _ := ret[0].(*entity.Future)
	return ret0
}

// GetFutureDetail indicates an expected call of GetFutureDetail.
func (mr *MockBasicMockRecorder) GetFutureDetail(futureCode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFutureDetail", reflect.TypeOf((*MockBasic)(nil).GetFutureDetail), futureCode)
}

// GetShioajiUsage mocks base method.
func (m *MockBasic) GetShioajiUsage() (*entity.ShioajiUsage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetShioajiUsage")
	ret0, _ := ret[0].(*entity.ShioajiUsage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetShioajiUsage indicates an expected call of GetShioajiUsage.
func (mr *MockBasicMockRecorder) GetShioajiUsage() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShioajiUsage", reflect.TypeOf((*MockBasic)(nil).GetShioajiUsage))
}

// GetStockDetail mocks base method.
func (m *MockBasic) GetStockDetail(stockNum string) *entity.Stock {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStockDetail", stockNum)
	ret0, _ := ret[0].(*entity.Stock)
	return ret0
}

// GetStockDetail indicates an expected call of GetStockDetail.
func (mr *MockBasicMockRecorder) GetStockDetail(stockNum any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStockDetail", reflect.TypeOf((*MockBasic)(nil).GetStockDetail), stockNum)
}

// MockHistory is a mock of History interface.
type MockHistory struct {
	ctrl     *gomock.Controller
	recorder *MockHistoryMockRecorder
}

// MockHistoryMockRecorder is the mock recorder for MockHistory.
type MockHistoryMockRecorder struct {
	mock *MockHistory
}

// NewMockHistory creates a new mock instance.
func NewMockHistory(ctrl *gomock.Controller) *MockHistory {
	mock := &MockHistory{ctrl: ctrl}
	mock.recorder = &MockHistoryMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockHistory) EXPECT() *MockHistoryMockRecorder {
	return m.recorder
}

// GetDayKbarByStockNumMultiDate mocks base method.
func (m *MockHistory) GetDayKbarByStockNumMultiDate(stockNum string, date time.Time, interval int64) ([]*entity.StockHistoryKbar, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDayKbarByStockNumMultiDate", stockNum, date, interval)
	ret0, _ := ret[0].([]*entity.StockHistoryKbar)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDayKbarByStockNumMultiDate indicates an expected call of GetDayKbarByStockNumMultiDate.
func (mr *MockHistoryMockRecorder) GetDayKbarByStockNumMultiDate(stockNum, date, interval any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDayKbarByStockNumMultiDate", reflect.TypeOf((*MockHistory)(nil).GetDayKbarByStockNumMultiDate), stockNum, date, interval)
}

// GetFutureHistoryPBKbarByDate mocks base method.
func (m *MockHistory) GetFutureHistoryPBKbarByDate(code string, date time.Time) (*pb.HistoryKbarResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFutureHistoryPBKbarByDate", code, date)
	ret0, _ := ret[0].(*pb.HistoryKbarResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFutureHistoryPBKbarByDate indicates an expected call of GetFutureHistoryPBKbarByDate.
func (mr *MockHistoryMockRecorder) GetFutureHistoryPBKbarByDate(code, date any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFutureHistoryPBKbarByDate", reflect.TypeOf((*MockHistory)(nil).GetFutureHistoryPBKbarByDate), code, date)
}

// MockRealTime is a mock of RealTime interface.
type MockRealTime struct {
	ctrl     *gomock.Controller
	recorder *MockRealTimeMockRecorder
}

// MockRealTimeMockRecorder is the mock recorder for MockRealTime.
type MockRealTimeMockRecorder struct {
	mock *MockRealTime
}

// NewMockRealTime creates a new mock instance.
func NewMockRealTime(ctrl *gomock.Controller) *MockRealTime {
	mock := &MockRealTime{ctrl: ctrl}
	mock.recorder = &MockRealTimeMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRealTime) EXPECT() *MockRealTimeMockRecorder {
	return m.recorder
}

// CreateRealTimePick mocks base method.
func (m *MockRealTime) CreateRealTimePick(connectionID string, odd bool, com chan *pb.PickRealMap, tickChan chan []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CreateRealTimePick", connectionID, odd, com, tickChan)
}

// CreateRealTimePick indicates an expected call of CreateRealTimePick.
func (mr *MockRealTimeMockRecorder) CreateRealTimePick(connectionID, odd, com, tickChan any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRealTimePick", reflect.TypeOf((*MockRealTime)(nil).CreateRealTimePick), connectionID, odd, com, tickChan)
}

// CreateRealTimePickFuture mocks base method.
func (m *MockRealTime) CreateRealTimePickFuture(ctx context.Context, code string, tickChan chan *pb.FutureRealTimeTickMessage) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CreateRealTimePickFuture", ctx, code, tickChan)
}

// CreateRealTimePickFuture indicates an expected call of CreateRealTimePickFuture.
func (mr *MockRealTimeMockRecorder) CreateRealTimePickFuture(ctx, code, tickChan any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRealTimePickFuture", reflect.TypeOf((*MockRealTime)(nil).CreateRealTimePickFuture), ctx, code, tickChan)
}

// DeleteRealTimeClient mocks base method.
func (m *MockRealTime) DeleteRealTimeClient(connectionID string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DeleteRealTimeClient", connectionID)
}

// DeleteRealTimeClient indicates an expected call of DeleteRealTimeClient.
func (mr *MockRealTimeMockRecorder) DeleteRealTimeClient(connectionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRealTimeClient", reflect.TypeOf((*MockRealTime)(nil).DeleteRealTimeClient), connectionID)
}

// GetFutureSnapshotByCode mocks base method.
func (m *MockRealTime) GetFutureSnapshotByCode(code string) (*pb.SnapshotMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFutureSnapshotByCode", code)
	ret0, _ := ret[0].(*pb.SnapshotMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFutureSnapshotByCode indicates an expected call of GetFutureSnapshotByCode.
func (mr *MockRealTimeMockRecorder) GetFutureSnapshotByCode(code any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFutureSnapshotByCode", reflect.TypeOf((*MockRealTime)(nil).GetFutureSnapshotByCode), code)
}

// GetStockSnapshotByNumArr mocks base method.
func (m *MockRealTime) GetStockSnapshotByNumArr(stockNumArr []string) ([]*entity.StockSnapShot, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStockSnapshotByNumArr", stockNumArr)
	ret0, _ := ret[0].([]*entity.StockSnapShot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStockSnapshotByNumArr indicates an expected call of GetStockSnapshotByNumArr.
func (mr *MockRealTimeMockRecorder) GetStockSnapshotByNumArr(stockNumArr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStockSnapshotByNumArr", reflect.TypeOf((*MockRealTime)(nil).GetStockSnapshotByNumArr), stockNumArr)
}

// GetTradeIndex mocks base method.
func (m *MockRealTime) GetTradeIndex() *entity.TradeIndex {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTradeIndex")
	ret0, _ := ret[0].(*entity.TradeIndex)
	return ret0
}

// GetTradeIndex indicates an expected call of GetTradeIndex.
func (mr *MockRealTimeMockRecorder) GetTradeIndex() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTradeIndex", reflect.TypeOf((*MockRealTime)(nil).GetTradeIndex))
}

// MockTarget is a mock of Target interface.
type MockTarget struct {
	ctrl     *gomock.Controller
	recorder *MockTargetMockRecorder
}

// MockTargetMockRecorder is the mock recorder for MockTarget.
type MockTargetMockRecorder struct {
	mock *MockTarget
}

// NewMockTarget creates a new mock instance.
func NewMockTarget(ctrl *gomock.Controller) *MockTarget {
	mock := &MockTarget{ctrl: ctrl}
	mock.recorder = &MockTargetMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTarget) EXPECT() *MockTargetMockRecorder {
	return m.recorder
}

// GetCurrentVolumeRank mocks base method.
func (m *MockTarget) GetCurrentVolumeRank() (*pb.StockVolumeRankResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentVolumeRank")
	ret0, _ := ret[0].(*pb.StockVolumeRankResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCurrentVolumeRank indicates an expected call of GetCurrentVolumeRank.
func (mr *MockTargetMockRecorder) GetCurrentVolumeRank() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentVolumeRank", reflect.TypeOf((*MockTarget)(nil).GetCurrentVolumeRank))
}

// GetTargets mocks base method.
func (m *MockTarget) GetTargets(ctx context.Context) []*entity.StockTarget {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTargets", ctx)
	ret0, _ := ret[0].([]*entity.StockTarget)
	return ret0
}

// GetTargets indicates an expected call of GetTargets.
func (mr *MockTargetMockRecorder) GetTargets(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTargets", reflect.TypeOf((*MockTarget)(nil).GetTargets), ctx)
}

// MockTrade is a mock of Trade interface.
type MockTrade struct {
	ctrl     *gomock.Controller
	recorder *MockTradeMockRecorder
}

// MockTradeMockRecorder is the mock recorder for MockTrade.
type MockTradeMockRecorder struct {
	mock *MockTrade
}

// NewMockTrade creates a new mock instance.
func NewMockTrade(ctrl *gomock.Controller) *MockTrade {
	mock := &MockTrade{ctrl: ctrl}
	mock.recorder = &MockTradeMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTrade) EXPECT() *MockTradeMockRecorder {
	return m.recorder
}

// BuyFuture mocks base method.
func (m *MockTrade) BuyFuture(order *entity.FutureOrder) (string, entity.OrderStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuyFuture", order)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(entity.OrderStatus)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// BuyFuture indicates an expected call of BuyFuture.
func (mr *MockTradeMockRecorder) BuyFuture(order any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuyFuture", reflect.TypeOf((*MockTrade)(nil).BuyFuture), order)
}

// BuyOddStock mocks base method.
func (m *MockTrade) BuyOddStock(num string, price float64, share int64) (string, entity.OrderStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuyOddStock", num, price, share)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(entity.OrderStatus)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// BuyOddStock indicates an expected call of BuyOddStock.
func (mr *MockTradeMockRecorder) BuyOddStock(num, price, share any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuyOddStock", reflect.TypeOf((*MockTrade)(nil).BuyOddStock), num, price, share)
}

// CancelOrderByID mocks base method.
func (m *MockTrade) CancelOrderByID(orderID string) (string, entity.OrderStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelOrderByID", orderID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(entity.OrderStatus)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CancelOrderByID indicates an expected call of CancelOrderByID.
func (mr *MockTradeMockRecorder) CancelOrderByID(orderID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelOrderByID", reflect.TypeOf((*MockTrade)(nil).CancelOrderByID), orderID)
}

// GetAllFutureOrder mocks base method.
func (m *MockTrade) GetAllFutureOrder(ctx context.Context) ([]*entity.FutureOrder, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllFutureOrder", ctx)
	ret0, _ := ret[0].([]*entity.FutureOrder)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllFutureOrder indicates an expected call of GetAllFutureOrder.
func (mr *MockTradeMockRecorder) GetAllFutureOrder(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllFutureOrder", reflect.TypeOf((*MockTrade)(nil).GetAllFutureOrder), ctx)
}

// GetAllFutureTradeBalance mocks base method.
func (m *MockTrade) GetAllFutureTradeBalance(ctx context.Context) ([]*entity.FutureTradeBalance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllFutureTradeBalance", ctx)
	ret0, _ := ret[0].([]*entity.FutureTradeBalance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllFutureTradeBalance indicates an expected call of GetAllFutureTradeBalance.
func (mr *MockTradeMockRecorder) GetAllFutureTradeBalance(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllFutureTradeBalance", reflect.TypeOf((*MockTrade)(nil).GetAllFutureTradeBalance), ctx)
}

// GetAllStockOrder mocks base method.
func (m *MockTrade) GetAllStockOrder(ctx context.Context) ([]*entity.StockOrder, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllStockOrder", ctx)
	ret0, _ := ret[0].([]*entity.StockOrder)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllStockOrder indicates an expected call of GetAllStockOrder.
func (mr *MockTradeMockRecorder) GetAllStockOrder(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllStockOrder", reflect.TypeOf((*MockTrade)(nil).GetAllStockOrder), ctx)
}

// GetAllStockTradeBalance mocks base method.
func (m *MockTrade) GetAllStockTradeBalance(ctx context.Context) ([]*entity.StockTradeBalance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllStockTradeBalance", ctx)
	ret0, _ := ret[0].([]*entity.StockTradeBalance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllStockTradeBalance indicates an expected call of GetAllStockTradeBalance.
func (mr *MockTradeMockRecorder) GetAllStockTradeBalance(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllStockTradeBalance", reflect.TypeOf((*MockTrade)(nil).GetAllStockTradeBalance), ctx)
}

// GetFutureOrderByTradeDay mocks base method.
func (m *MockTrade) GetFutureOrderByTradeDay(ctx context.Context, tradeDay string) ([]*entity.FutureOrder, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFutureOrderByTradeDay", ctx, tradeDay)
	ret0, _ := ret[0].([]*entity.FutureOrder)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFutureOrderByTradeDay indicates an expected call of GetFutureOrderByTradeDay.
func (mr *MockTradeMockRecorder) GetFutureOrderByTradeDay(ctx, tradeDay any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFutureOrderByTradeDay", reflect.TypeOf((*MockTrade)(nil).GetFutureOrderByTradeDay), ctx, tradeDay)
}

// GetFuturePosition mocks base method.
func (m *MockTrade) GetFuturePosition() ([]*entity.FuturePosition, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFuturePosition")
	ret0, _ := ret[0].([]*entity.FuturePosition)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFuturePosition indicates an expected call of GetFuturePosition.
func (mr *MockTradeMockRecorder) GetFuturePosition() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFuturePosition", reflect.TypeOf((*MockTrade)(nil).GetFuturePosition))
}

// GetLatestInventoryStock mocks base method.
func (m *MockTrade) GetLatestInventoryStock() ([]*entity.InventoryStock, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestInventoryStock")
	ret0, _ := ret[0].([]*entity.InventoryStock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLatestInventoryStock indicates an expected call of GetLatestInventoryStock.
func (mr *MockTradeMockRecorder) GetLatestInventoryStock() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestInventoryStock", reflect.TypeOf((*MockTrade)(nil).GetLatestInventoryStock))
}

// IsAuthUser mocks base method.
func (m *MockTrade) IsAuthUser(username string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsAuthUser", username)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsAuthUser indicates an expected call of IsAuthUser.
func (mr *MockTradeMockRecorder) IsAuthUser(username any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAuthUser", reflect.TypeOf((*MockTrade)(nil).IsAuthUser), username)
}

// IsFutureTradeTime mocks base method.
func (m *MockTrade) IsFutureTradeTime() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsFutureTradeTime")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsFutureTradeTime indicates an expected call of IsFutureTradeTime.
func (mr *MockTradeMockRecorder) IsFutureTradeTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsFutureTradeTime", reflect.TypeOf((*MockTrade)(nil).IsFutureTradeTime))
}

// SellFuture mocks base method.
func (m *MockTrade) SellFuture(order *entity.FutureOrder) (string, entity.OrderStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SellFuture", order)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(entity.OrderStatus)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SellFuture indicates an expected call of SellFuture.
func (mr *MockTradeMockRecorder) SellFuture(order any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SellFuture", reflect.TypeOf((*MockTrade)(nil).SellFuture), order)
}

// SelloddStock mocks base method.
func (m *MockTrade) SelloddStock(num string, price float64, share int64) (string, entity.OrderStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelloddStock", num, price, share)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(entity.OrderStatus)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SelloddStock indicates an expected call of SelloddStock.
func (mr *MockTradeMockRecorder) SelloddStock(num, price, share any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelloddStock", reflect.TypeOf((*MockTrade)(nil).SelloddStock), num, price, share)
}

// MockSystem is a mock of System interface.
type MockSystem struct {
	ctrl     *gomock.Controller
	recorder *MockSystemMockRecorder
}

// MockSystemMockRecorder is the mock recorder for MockSystem.
type MockSystemMockRecorder struct {
	mock *MockSystem
}

// NewMockSystem creates a new mock instance.
func NewMockSystem(ctrl *gomock.Controller) *MockSystem {
	mock := &MockSystem{ctrl: ctrl}
	mock.recorder = &MockSystemMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSystem) EXPECT() *MockSystemMockRecorder {
	return m.recorder
}

// AddUser mocks base method.
func (m *MockSystem) AddUser(ctx context.Context, t *entity.NewUser) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddUser", ctx, t)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddUser indicates an expected call of AddUser.
func (mr *MockSystemMockRecorder) AddUser(ctx, t any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddUser", reflect.TypeOf((*MockSystem)(nil).AddUser), ctx, t)
}

// DeleteAllPushTokens mocks base method.
func (m *MockSystem) DeleteAllPushTokens(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAllPushTokens", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteAllPushTokens indicates an expected call of DeleteAllPushTokens.
func (mr *MockSystemMockRecorder) DeleteAllPushTokens(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllPushTokens", reflect.TypeOf((*MockSystem)(nil).DeleteAllPushTokens), ctx)
}

// GetLastJWT mocks base method.
func (m *MockSystem) GetLastJWT(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLastJWT", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLastJWT indicates an expected call of GetLastJWT.
func (mr *MockSystemMockRecorder) GetLastJWT(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastJWT", reflect.TypeOf((*MockSystem)(nil).GetLastJWT), ctx)
}

// GetUserInfo mocks base method.
func (m *MockSystem) GetUserInfo(ctx context.Context, username string) (*entity.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserInfo", ctx, username)
	ret0, _ := ret[0].(*entity.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserInfo indicates an expected call of GetUserInfo.
func (mr *MockSystemMockRecorder) GetUserInfo(ctx, username any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserInfo", reflect.TypeOf((*MockSystem)(nil).GetUserInfo), ctx, username)
}

// InsertJWT mocks base method.
func (m *MockSystem) InsertJWT(ctx context.Context, jwt string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertJWT", ctx, jwt)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertJWT indicates an expected call of InsertJWT.
func (mr *MockSystemMockRecorder) InsertJWT(ctx, jwt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertJWT", reflect.TypeOf((*MockSystem)(nil).InsertJWT), ctx, jwt)
}

// InsertPushToken mocks base method.
func (m *MockSystem) InsertPushToken(ctx context.Context, token, username string, enabled bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertPushToken", ctx, token, username, enabled)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertPushToken indicates an expected call of InsertPushToken.
func (mr *MockSystemMockRecorder) InsertPushToken(ctx, token, username, enabled any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertPushToken", reflect.TypeOf((*MockSystem)(nil).InsertPushToken), ctx, token, username, enabled)
}

// IsPushTokenEnabled mocks base method.
func (m *MockSystem) IsPushTokenEnabled(ctx context.Context, token string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsPushTokenEnabled", ctx, token)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsPushTokenEnabled indicates an expected call of IsPushTokenEnabled.
func (mr *MockSystemMockRecorder) IsPushTokenEnabled(ctx, token any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPushTokenEnabled", reflect.TypeOf((*MockSystem)(nil).IsPushTokenEnabled), ctx, token)
}

// Login mocks base method.
func (m *MockSystem) Login(ctx context.Context, username, password string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Login", ctx, username, password)
	ret0, _ := ret[0].(error)
	return ret0
}

// Login indicates an expected call of Login.
func (mr *MockSystemMockRecorder) Login(ctx, username, password any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Login", reflect.TypeOf((*MockSystem)(nil).Login), ctx, username, password)
}

// UpdateAuthTradeUser mocks base method.
func (m *MockSystem) UpdateAuthTradeUser() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateAuthTradeUser")
}

// UpdateAuthTradeUser indicates an expected call of UpdateAuthTradeUser.
func (mr *MockSystemMockRecorder) UpdateAuthTradeUser() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuthTradeUser", reflect.TypeOf((*MockSystem)(nil).UpdateAuthTradeUser))
}

// VerifyEmail mocks base method.
func (m *MockSystem) VerifyEmail(ctx context.Context, username, code string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyEmail", ctx, username, code)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyEmail indicates an expected call of VerifyEmail.
func (mr *MockSystemMockRecorder) VerifyEmail(ctx, username, code any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyEmail", reflect.TypeOf((*MockSystem)(nil).VerifyEmail), ctx, username, code)
}

// MockFCM is a mock of FCM interface.
type MockFCM struct {
	ctrl     *gomock.Controller
	recorder *MockFCMMockRecorder
}

// MockFCMMockRecorder is the mock recorder for MockFCM.
type MockFCMMockRecorder struct {
	mock *MockFCM
}

// NewMockFCM creates a new mock instance.
func NewMockFCM(ctrl *gomock.Controller) *MockFCM {
	mock := &MockFCM{ctrl: ctrl}
	mock.recorder = &MockFCMMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockFCM) EXPECT() *MockFCMMockRecorder {
	return m.recorder
}

// AnnounceMessage mocks base method.
func (m *MockFCM) AnnounceMessage(msg string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AnnounceMessage", msg)
	ret0, _ := ret[0].(error)
	return ret0
}

// AnnounceMessage indicates an expected call of AnnounceMessage.
func (mr *MockFCMMockRecorder) AnnounceMessage(msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnounceMessage", reflect.TypeOf((*MockFCM)(nil).AnnounceMessage), msg)
}

// PushNotification mocks base method.
func (m *MockFCM) PushNotification(title, msg string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PushNotification", title, msg)
	ret0, _ := ret[0].(error)
	return ret0
}

// PushNotification indicates an expected call of PushNotification.
func (mr *MockFCMMockRecorder) PushNotification(title, msg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushNotification", reflect.TypeOf((*MockFCM)(nil).PushNotification), title, msg)
}
