// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"

	mock "github.com/stretchr/testify/mock"
)

// NewMockFaviconService creates a new instance of MockFaviconService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockFaviconService(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFaviconService {
	mock := &MockFaviconService{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockFaviconService is an autogenerated mock type for the FaviconService type
type MockFaviconService struct {
	mock.Mock
}

type MockFaviconService_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFaviconService) EXPECT() *MockFaviconService_Expecter {
	return &MockFaviconService_Expecter{mock: &_m.Mock}
}

// Close provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) Close() {
	_mock.Called()
	return
}

// MockFaviconService_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
type MockFaviconService_Close_Call struct {
	*mock.Call
}

// Close is a helper method to define mock.On call
func (_e *MockFaviconService_Expecter) Close() *MockFaviconService_Close_Call {
	return &MockFaviconService_Close_Call{Call: _e.mock.On("Close")}
}

func (_c *MockFaviconService_Close_Call) Run(run func()) *MockFaviconService_Close_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockFaviconService_Close_Call) Return() *MockFaviconService_Close_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFaviconService_Close_Call) RunAndReturn(run func()) *MockFaviconService_Close_Call {
	_c.Run(run)
	return _c
}

// DiskPathPNG provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) DiskPathPNG(domain string) string {
	ret := _mock.Called(domain)

	if len(ret) == 0 {
		panic("no return value specified for DiskPathPNG")
	}

	var r0 string
	if returnFunc, ok := ret.Get(0).(func(string) string); ok {
		r0 = returnFunc(domain)
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

// MockFaviconService_DiskPathPNG_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiskPathPNG'
type MockFaviconService_DiskPathPNG_Call struct {
	*mock.Call
}

// DiskPathPNG is a helper method to define mock.On call
//   - domain string
func (_e *MockFaviconService_Expecter) DiskPathPNG(domain any) *MockFaviconService_DiskPathPNG_Call {
	return &MockFaviconService_DiskPathPNG_Call{Call: _e.mock.On("DiskPathPNG", domain)}
}

func (_c *MockFaviconService_DiskPathPNG_Call) Run(run func(domain string)) *MockFaviconService_DiskPathPNG_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockFaviconService_DiskPathPNG_Call) Return(s string) *MockFaviconService_DiskPathPNG_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockFaviconService_DiskPathPNG_Call) RunAndReturn(run func(domain string) string) *MockFaviconService_DiskPathPNG_Call {
	_c.Call.Return(run)
	return _c
}

// DiskPathPNGSized provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) DiskPathPNGSized(domain string, size int) string {
	ret := _mock.Called(domain, size)

	if len(ret) == 0 {
		panic("no return value specified for DiskPathPNGSized")
	}

	var r0 string
	if returnFunc, ok := ret.Get(0).(func(string, int) string); ok {
		r0 = returnFunc(domain, size)
	} else {
		r0 = ret.Get(0).(string)
	}
	return r0
}

// MockFaviconService_DiskPathPNGSized_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DiskPathPNGSized'
type MockFaviconService_DiskPathPNGSized_Call struct {
	*mock.Call
}

// DiskPathPNGSized is a helper method to define mock.On call
//   - domain string
//   - size int
func (_e *MockFaviconService_Expecter) DiskPathPNGSized(domain any, size any) *MockFaviconService_DiskPathPNGSized_Call {
	return &MockFaviconService_DiskPathPNGSized_Call{Call: _e.mock.On("DiskPathPNGSized", domain, size)}
}

func (_c *MockFaviconService_DiskPathPNGSized_Call) Run(run func(domain string, size int)) *MockFaviconService_DiskPathPNGSized_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockFaviconService_DiskPathPNGSized_Call) Return(s string) *MockFaviconService_DiskPathPNGSized_Call {
	_c.Call.Return(s)
	return _c
}

func (_c *MockFaviconService_DiskPathPNGSized_Call) RunAndReturn(run func(domain string, size int) string) *MockFaviconService_DiskPathPNGSized_Call {
	_c.Call.Return(run)
	return _c
}

// EnsureCacheDir provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) EnsureCacheDir() error {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for EnsureCacheDir")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func() error); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockFaviconService_EnsureCacheDir_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnsureCacheDir'
type MockFaviconService_EnsureCacheDir_Call struct {
	*mock.Call
}

// EnsureCacheDir is a helper method to define mock.On call
func (_e *MockFaviconService_Expecter) EnsureCacheDir() *MockFaviconService_EnsureCacheDir_Call {
	return &MockFaviconService_EnsureCacheDir_Call{Call: _e.mock.On("EnsureCacheDir")}
}

func (_c *MockFaviconService_EnsureCacheDir_Call) Run(run func()) *MockFaviconService_EnsureCacheDir_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockFaviconService_EnsureCacheDir_Call) Return(err error) *MockFaviconService_EnsureCacheDir_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockFaviconService_EnsureCacheDir_Call) RunAndReturn(run func() error) *MockFaviconService_EnsureCacheDir_Call {
	_c.Call.Return(run)
	return _c
}

// EnsureDiskCache provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) EnsureDiskCache(ctx context.Context, domain string) {
	_mock.Called(ctx, domain)
	return
}

// MockFaviconService_EnsureDiskCache_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnsureDiskCache'
type MockFaviconService_EnsureDiskCache_Call struct {
	*mock.Call
}

// EnsureDiskCache is a helper method to define mock.On call
//   - ctx context.Context
//   - domain string
func (_e *MockFaviconService_Expecter) EnsureDiskCache(ctx any, domain any) *MockFaviconService_EnsureDiskCache_Call {
	return &MockFaviconService_EnsureDiskCache_Call{Call: _e.mock.On("EnsureDiskCache", ctx, domain)}
}

func (_c *MockFaviconService_EnsureDiskCache_Call) Run(run func(ctx context.Context, domain string)) *MockFaviconService_EnsureDiskCache_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockFaviconService_EnsureDiskCache_Call) Return() *MockFaviconService_EnsureDiskCache_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockFaviconService_EnsureDiskCache_Call) RunAndReturn(run func(ctx context.Context, domain string)) *MockFaviconService_EnsureDiskCache_Call {
	_c.Run(run)
	return _c
}

// EnsureSizedPNG provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) EnsureSizedPNG(ctx context.Context, domain string, size int) error {
	ret := _mock.Called(ctx, domain, size)

	if len(ret) == 0 {
		panic("no return value specified for EnsureSizedPNG")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, int) error); ok {
		r0 = returnFunc(ctx, domain, size)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockFaviconService_EnsureSizedPNG_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnsureSizedPNG'
type MockFaviconService_EnsureSizedPNG_Call struct {
	*mock.Call
}

// EnsureSizedPNG is a helper method to define mock.On call
//   - ctx context.Context
//   - domain string
//   - size int
func (_e *MockFaviconService_Expecter) EnsureSizedPNG(ctx any, domain any, size any) *MockFaviconService_EnsureSizedPNG_Call {
	return &MockFaviconService_EnsureSizedPNG_Call{Call: _e.mock.On("EnsureSizedPNG", ctx, domain, size)}
}

func (_c *MockFaviconService_EnsureSizedPNG_Call) Run(run func(ctx context.Context, domain string, size int)) *MockFaviconService_EnsureSizedPNG_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockFaviconService_EnsureSizedPNG_Call) Return(err error) *MockFaviconService_EnsureSizedPNG_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockFaviconService_EnsureSizedPNG_Call) RunAndReturn(run func(ctx context.Context, domain string, size int) error) *MockFaviconService_EnsureSizedPNG_Call {
	_c.Call.Return(run)
	return _c
}

// Get provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) Get(ctx context.Context, domain string) ([]byte, error) {
	ret := _mock.Called(ctx, domain)

	if len(ret) == 0 {
		panic("no return value specified for Get")
	}

	var r0 []byte
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]byte, error)); ok {
		return returnFunc(ctx, domain)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []byte); ok {
		r0 = returnFunc(ctx, domain)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, domain)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockFaviconService_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
type MockFaviconService_Get_Call struct {
	*mock.Call
}

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - domain string
func (_e *MockFaviconService_Expecter) Get(ctx any, domain any) *MockFaviconService_Get_Call {
	return &MockFaviconService_Get_Call{Call: _e.mock.On("Get", ctx, domain)}
}

func (_c *MockFaviconService_Get_Call) Run(run func(ctx context.Context, domain string)) *MockFaviconService_Get_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockFaviconService_Get_Call) Return(bytes []byte, err error) *MockFaviconService_Get_Call {
	_c.Call.Return(bytes, err)
	return _c
}

func (_c *MockFaviconService_Get_Call) RunAndReturn(run func(ctx context.Context, domain string) ([]byte, error)) *MockFaviconService_Get_Call {
	_c.Call.Return(run)
	return _c
}

// GetCached provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) GetCached(ctx context.Context, domain string) ([]byte, bool) {
	ret := _mock.Called(ctx, domain)

	if len(ret) == 0 {
		panic("no return value specified for GetCached")
	}

	var r0 []byte
	var r1 bool
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]byte, bool)); ok {
		return returnFunc(ctx, domain)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []byte); ok {
		r0 = returnFunc(ctx, domain)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) bool); ok {
		r1 = returnFunc(ctx, domain)
	} else {
		r1 = ret.Get(1).(bool)
	}
	return r0, r1
}

// MockFaviconService_GetCached_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCached'
type MockFaviconService_GetCached_Call struct {
	*mock.Call
}

// GetCached is a helper method to define mock.On call
//   - ctx context.Context
//   - domain string
func (_e *MockFaviconService_Expecter) GetCached(ctx any, domain any) *MockFaviconService_GetCached_Call {
	return &MockFaviconService_GetCached_Call{Call: _e.mock.On("GetCached", ctx, domain)}
}

func (_c *MockFaviconService_GetCached_Call) Run(run func(ctx context.Context, domain string)) *MockFaviconService_GetCached_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockFaviconService_GetCached_Call) Return(bytes []byte, b bool) *MockFaviconService_GetCached_Call {
	_c.Call.Return(bytes, b)
	return _c
}

func (_c *MockFaviconService_GetCached_Call) RunAndReturn(run func(ctx context.Context, domain string) ([]byte, bool)) *MockFaviconService_GetCached_Call {
	_c.Call.Return(run)
	return _c
}

// HasPNGOnDisk provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) HasPNGOnDisk(domain string) bool {
	ret := _mock.Called(domain)

	if len(ret) == 0 {
		panic("no return value specified for HasPNGOnDisk")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(string) bool); ok {
		r0 = returnFunc(domain)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockFaviconService_HasPNGOnDisk_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasPNGOnDisk'
type MockFaviconService_HasPNGOnDisk_Call struct {
	*mock.Call
}

// HasPNGOnDisk is a helper method to define mock.On call
//   - domain string
func (_e *MockFaviconService_Expecter) HasPNGOnDisk(domain any) *MockFaviconService_HasPNGOnDisk_Call {
	return &MockFaviconService_HasPNGOnDisk_Call{Call: _e.mock.On("HasPNGOnDisk", domain)}
}

func (_c *MockFaviconService_HasPNGOnDisk_Call) Run(run func(domain string)) *MockFaviconService_HasPNGOnDisk_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockFaviconService_HasPNGOnDisk_Call) Return(b bool) *MockFaviconService_HasPNGOnDisk_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockFaviconService_HasPNGOnDisk_Call) RunAndReturn(run func(domain string) bool) *MockFaviconService_HasPNGOnDisk_Call {
	_c.Call.Return(run)
	return _c
}

// HasPNGSizedOnDisk provides a mock function for the type MockFaviconService
func (_mock *MockFaviconService) HasPNGSizedOnDisk(domain string, size int) bool {
	ret := _mock.Called(domain, size)

	if len(ret) == 0 {
		panic("no return value specified for HasPNGSizedOnDisk")
	}

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func(string, int) bool); ok {
		r0 = returnFunc(domain, size)
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

// MockFaviconService_HasPNGSizedOnDisk_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasPNGSizedOnDisk'
type MockFaviconService_HasPNGSizedOnDisk_Call struct {
	*mock.Call
}

// HasPNGSizedOnDisk is a helper method to define mock.On call
//   - domain string
//   - size int
func (_e *MockFaviconService_Expecter) HasPNGSizedOnDisk(domain any, size any) *MockFaviconService_HasPNGSizedOnDisk_Call {
	return &MockFaviconService_HasPNGSizedOnDisk_Call{Call: _e.mock.On("HasPNGSizedOnDisk", domain, size)}
}

func (_c *MockFaviconService_HasPNGSizedOnDisk_Call) Run(run func(domain string, size int)) *MockFaviconService_HasPNGSizedOnDisk_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockFaviconService_HasPNGSizedOnDisk_Call) Return(b bool) *MockFaviconService_HasPNGSizedOnDisk_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockFaviconService_HasPNGSizedOnDisk_Call) RunAndReturn(run func(domain string, size int) bool) *MockFaviconService_HasPNGSizedOnDisk_Call {
	_c.Call.Return(run)
	return _c
}