any2anexoj/internal/mocks/mocks_gen.go

// Code generated by MockGen. DO NOT EDIT.
// Source: git.naterciomoniz.net/applications/broker2anexoj/internal (interfaces: RecordReader,Record,ReportWriter)
//
// Generated by this command:
//
//	mockgen -destination=mocks/mocks_gen.go -package=mocks -typed . RecordReader,Record,ReportWriter
//

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

import (
	context "context"
	big "math/big"
	reflect "reflect"
	time "time"

	internal "git.naterciomoniz.net/applications/broker2anexoj/internal"
	gomock "go.uber.org/mock/gomock"
)

// MockRecordReader is a mock of RecordReader interface.
type MockRecordReader struct {
	ctrl     *gomock.Controller
	recorder *MockRecordReaderMockRecorder
	isgomock struct{}
}

// MockRecordReaderMockRecorder is the mock recorder for MockRecordReader.
type MockRecordReaderMockRecorder struct {
	mock *MockRecordReader
}

// NewMockRecordReader creates a new mock instance.
func NewMockRecordReader(ctrl *gomock.Controller) *MockRecordReader {
	mock := &MockRecordReader{ctrl: ctrl}
	mock.recorder = &MockRecordReaderMockRecorder{mock}
	return mock
}

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

// ReadRecord mocks base method.
func (m *MockRecordReader) ReadRecord(arg0 context.Context) (internal.Record, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadRecord", arg0)
	ret0, _ := ret[0].(internal.Record)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReadRecord indicates an expected call of ReadRecord.
func (mr *MockRecordReaderMockRecorder) ReadRecord(arg0 any) *MockRecordReaderReadRecordCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadRecord", reflect.TypeOf((*MockRecordReader)(nil).ReadRecord), arg0)
	return &MockRecordReaderReadRecordCall{Call: call}
}

// MockRecordReaderReadRecordCall wrap *gomock.Call
type MockRecordReaderReadRecordCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRecordReaderReadRecordCall) Return(arg0 internal.Record, arg1 error) *MockRecordReaderReadRecordCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRecordReaderReadRecordCall) Do(f func(context.Context) (internal.Record, error)) *MockRecordReaderReadRecordCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRecordReaderReadRecordCall) DoAndReturn(f func(context.Context) (internal.Record, error)) *MockRecordReaderReadRecordCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockRecord is a mock of Record interface.
type MockRecord struct {
	ctrl     *gomock.Controller
	recorder *MockRecordMockRecorder
	isgomock struct{}
}

// MockRecordMockRecorder is the mock recorder for MockRecord.
type MockRecordMockRecorder struct {
	mock *MockRecord
}

// NewMockRecord creates a new mock instance.
func NewMockRecord(ctrl *gomock.Controller) *MockRecord {
	mock := &MockRecord{ctrl: ctrl}
	mock.recorder = &MockRecordMockRecorder{mock}
	return mock
}

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

// Fees mocks base method.
func (m *MockRecord) Fees() *big.Float {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fees")
	ret0, _ := ret[0].(*big.Float)
	return ret0
}

// Fees indicates an expected call of Fees.
func (mr *MockRecordMockRecorder) Fees() *MockRecordFeesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fees", reflect.TypeOf((*MockRecord)(nil).Fees))
	return &MockRecordFeesCall{Call: call}
}

// MockRecordFeesCall wrap *gomock.Call
type MockRecordFeesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRecordFeesCall) Return(arg0 *big.Float) *MockRecordFeesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRecordFeesCall) Do(f func() *big.Float) *MockRecordFeesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRecordFeesCall) DoAndReturn(f func() *big.Float) *MockRecordFeesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Price mocks base method.
func (m *MockRecord) Price() *big.Float {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Price")
	ret0, _ := ret[0].(*big.Float)
	return ret0
}

// Price indicates an expected call of Price.
func (mr *MockRecordMockRecorder) Price() *MockRecordPriceCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Price", reflect.TypeOf((*MockRecord)(nil).Price))
	return &MockRecordPriceCall{Call: call}
}

// MockRecordPriceCall wrap *gomock.Call
type MockRecordPriceCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRecordPriceCall) Return(arg0 *big.Float) *MockRecordPriceCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRecordPriceCall) Do(f func() *big.Float) *MockRecordPriceCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRecordPriceCall) DoAndReturn(f func() *big.Float) *MockRecordPriceCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Quantity mocks base method.
func (m *MockRecord) Quantity() *big.Float {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Quantity")
	ret0, _ := ret[0].(*big.Float)
	return ret0
}

// Quantity indicates an expected call of Quantity.
func (mr *MockRecordMockRecorder) Quantity() *MockRecordQuantityCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quantity", reflect.TypeOf((*MockRecord)(nil).Quantity))
	return &MockRecordQuantityCall{Call: call}
}

// MockRecordQuantityCall wrap *gomock.Call
type MockRecordQuantityCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRecordQuantityCall) Return(arg0 *big.Float) *MockRecordQuantityCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRecordQuantityCall) Do(f func() *big.Float) *MockRecordQuantityCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRecordQuantityCall) DoAndReturn(f func() *big.Float) *MockRecordQuantityCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Side indicates an expected call of Side.
func (mr *MockRecordMockRecorder) Side() *MockRecordSideCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Side", reflect.TypeOf((*MockRecord)(nil).Side))
	return &MockRecordSideCall{Call: call}
}

// MockRecordSideCall wrap *gomock.Call
type MockRecordSideCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRecordSideCall) Return(arg0 internal.Side) *MockRecordSideCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRecordSideCall) Do(f func() internal.Side) *MockRecordSideCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRecordSideCall) DoAndReturn(f func() internal.Side) *MockRecordSideCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Symbol indicates an expected call of Symbol.
func (mr *MockRecordMockRecorder) Symbol() *MockRecordSymbolCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Symbol", reflect.TypeOf((*MockRecord)(nil).Symbol))
	return &MockRecordSymbolCall{Call: call}
}

// MockRecordSymbolCall wrap *gomock.Call
type MockRecordSymbolCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRecordSymbolCall) Return(arg0 string) *MockRecordSymbolCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRecordSymbolCall) Do(f func() string) *MockRecordSymbolCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRecordSymbolCall) DoAndReturn(f func() string) *MockRecordSymbolCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Taxes mocks base method.
func (m *MockRecord) Taxes() *big.Float {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Taxes")
	ret0, _ := ret[0].(*big.Float)
	return ret0
}

// Taxes indicates an expected call of Taxes.
func (mr *MockRecordMockRecorder) Taxes() *MockRecordTaxesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Taxes", reflect.TypeOf((*MockRecord)(nil).Taxes))
	return &MockRecordTaxesCall{Call: call}
}

// MockRecordTaxesCall wrap *gomock.Call
type MockRecordTaxesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRecordTaxesCall) Return(arg0 *big.Float) *MockRecordTaxesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRecordTaxesCall) Do(f func() *big.Float) *MockRecordTaxesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRecordTaxesCall) DoAndReturn(f func() *big.Float) *MockRecordTaxesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Timestamp mocks base method.
func (m *MockRecord) Timestamp() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Timestamp")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

// Timestamp indicates an expected call of Timestamp.
func (mr *MockRecordMockRecorder) Timestamp() *MockRecordTimestampCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timestamp", reflect.TypeOf((*MockRecord)(nil).Timestamp))
	return &MockRecordTimestampCall{Call: call}
}

// MockRecordTimestampCall wrap *gomock.Call
type MockRecordTimestampCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRecordTimestampCall) Return(arg0 time.Time) *MockRecordTimestampCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRecordTimestampCall) Do(f func() time.Time) *MockRecordTimestampCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRecordTimestampCall) DoAndReturn(f func() time.Time) *MockRecordTimestampCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockReportWriter is a mock of ReportWriter interface.
type MockReportWriter struct {
	ctrl     *gomock.Controller
	recorder *MockReportWriterMockRecorder
	isgomock struct{}
}

// MockReportWriterMockRecorder is the mock recorder for MockReportWriter.
type MockReportWriterMockRecorder struct {
	mock *MockReportWriter
}

// NewMockReportWriter creates a new mock instance.
func NewMockReportWriter(ctrl *gomock.Controller) *MockReportWriter {
	mock := &MockReportWriter{ctrl: ctrl}
	mock.recorder = &MockReportWriterMockRecorder{mock}
	return mock
}

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

// Write mocks base method.
func (m *MockReportWriter) Write(arg0 context.Context, arg1 internal.ReportItem) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// Write indicates an expected call of Write.
func (mr *MockReportWriterMockRecorder) Write(arg0, arg1 any) *MockReportWriterWriteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockReportWriter)(nil).Write), arg0, arg1)
	return &MockReportWriterWriteCall{Call: call}
}

// MockReportWriterWriteCall wrap *gomock.Call
type MockReportWriterWriteCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockReportWriterWriteCall) Return(arg0 error) *MockReportWriterWriteCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockReportWriterWriteCall) Do(f func(context.Context, internal.ReportItem) error) *MockReportWriterWriteCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockReportWriterWriteCall) DoAndReturn(f func(context.Context, internal.ReportItem) error) *MockReportWriterWriteCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}