// Code generated by MockGen. DO NOT EDIT.
// Source: ./mockgen_slot_calculator.go
//
// Generated by this command:
//
//	mockgen -typed=true -source=./mockgen_slot_calculator.go -destination=./slot_calculator_mock.go -package=testhelpers
//

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

import (
	reflect "reflect"
	time "time"

	gomock "go.uber.org/mock/gomock"
)

// MockSlotCalculator is a mock of SlotCalculator interface.
type MockSlotCalculator struct {
	ctrl     *gomock.Controller
	recorder *MockSlotCalculatorMockRecorder
	isgomock struct{}
}

// MockSlotCalculatorMockRecorder is the mock recorder for MockSlotCalculator.
type MockSlotCalculatorMockRecorder struct {
	mock *MockSlotCalculator
}

// NewMockSlotCalculator creates a new mock instance.
func NewMockSlotCalculator(ctrl *gomock.Controller) *MockSlotCalculator {
	mock := &MockSlotCalculator{ctrl: ctrl}
	mock.recorder = &MockSlotCalculatorMockRecorder{mock}
	return mock
}

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

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

// CalcCurrentSlot indicates an expected call of CalcCurrentSlot.
func (mr *MockSlotCalculatorMockRecorder) CalcCurrentSlot() *MockSlotCalculatorCalcCurrentSlotCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcCurrentSlot", reflect.TypeOf((*MockSlotCalculator)(nil).CalcCurrentSlot))
	return &MockSlotCalculatorCalcCurrentSlotCall{Call: call}
}

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

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

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

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

// CalcSlot mocks base method.
func (m *MockSlotCalculator) CalcSlot(timestamp uint64) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcSlot", timestamp)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalcSlot indicates an expected call of CalcSlot.
func (mr *MockSlotCalculatorMockRecorder) CalcSlot(timestamp any) *MockSlotCalculatorCalcSlotCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcSlot", reflect.TypeOf((*MockSlotCalculator)(nil).CalcSlot), timestamp)
	return &MockSlotCalculatorCalcSlotCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockSlotCalculatorCalcSlotCall) Return(arg0 uint64, arg1 error) *MockSlotCalculatorCalcSlotCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSlotCalculatorCalcSlotCall) Do(f func(uint64) (uint64, error)) *MockSlotCalculatorCalcSlotCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSlotCalculatorCalcSlotCall) DoAndReturn(f func(uint64) (uint64, error)) *MockSlotCalculatorCalcSlotCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CalcSlotAge mocks base method.
func (m *MockSlotCalculator) CalcSlotAge(slot uint64) time.Duration {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcSlotAge", slot)
	ret0, _ := ret[0].(time.Duration)
	return ret0
}

// CalcSlotAge indicates an expected call of CalcSlotAge.
func (mr *MockSlotCalculatorMockRecorder) CalcSlotAge(slot any) *MockSlotCalculatorCalcSlotAgeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcSlotAge", reflect.TypeOf((*MockSlotCalculator)(nil).CalcSlotAge), slot)
	return &MockSlotCalculatorCalcSlotAgeCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockSlotCalculatorCalcSlotAgeCall) Do(f func(uint64) time.Duration) *MockSlotCalculatorCalcSlotAgeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSlotCalculatorCalcSlotAgeCall) DoAndReturn(f func(uint64) time.Duration) *MockSlotCalculatorCalcSlotAgeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CalcSlotStartTimestamp mocks base method.
func (m *MockSlotCalculator) CalcSlotStartTimestamp(slot uint64) uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalcSlotStartTimestamp", slot)
	ret0, _ := ret[0].(uint64)
	return ret0
}

// CalcSlotStartTimestamp indicates an expected call of CalcSlotStartTimestamp.
func (mr *MockSlotCalculatorMockRecorder) CalcSlotStartTimestamp(slot any) *MockSlotCalculatorCalcSlotStartTimestampCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalcSlotStartTimestamp", reflect.TypeOf((*MockSlotCalculator)(nil).CalcSlotStartTimestamp), slot)
	return &MockSlotCalculatorCalcSlotStartTimestampCall{Call: call}
}

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

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

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

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

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

// SecondsPerSlot indicates an expected call of SecondsPerSlot.
func (mr *MockSlotCalculatorMockRecorder) SecondsPerSlot() *MockSlotCalculatorSecondsPerSlotCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecondsPerSlot", reflect.TypeOf((*MockSlotCalculator)(nil).SecondsPerSlot))
	return &MockSlotCalculatorSecondsPerSlotCall{Call: call}
}

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

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

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

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