// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq

package mock

import (
	"github.com/axelarnetwork/axelar-core/utils"
	"sync"
)

// Ensure, that ValidatedProtoMarshalerMock does implement utils.ValidatedProtoMarshaler.
// If this is not the case, regenerate this file with moq.
var _ utils.ValidatedProtoMarshaler = &ValidatedProtoMarshalerMock{}

// ValidatedProtoMarshalerMock is a mock implementation of utils.ValidatedProtoMarshaler.
//
//	func TestSomethingThatUsesValidatedProtoMarshaler(t *testing.T) {
//
//		// make and configure a mocked utils.ValidatedProtoMarshaler
//		mockedValidatedProtoMarshaler := &ValidatedProtoMarshalerMock{
//			MarshalFunc: func() ([]byte, error) {
//				panic("mock out the Marshal method")
//			},
//			MarshalToFunc: func(data []byte) (int, error) {
//				panic("mock out the MarshalTo method")
//			},
//			MarshalToSizedBufferFunc: func(dAtA []byte) (int, error) {
//				panic("mock out the MarshalToSizedBuffer method")
//			},
//			ProtoMessageFunc: func()  {
//				panic("mock out the ProtoMessage method")
//			},
//			ResetFunc: func()  {
//				panic("mock out the Reset method")
//			},
//			SizeFunc: func() int {
//				panic("mock out the Size method")
//			},
//			StringFunc: func() string {
//				panic("mock out the String method")
//			},
//			UnmarshalFunc: func(data []byte) error {
//				panic("mock out the Unmarshal method")
//			},
//			ValidateBasicFunc: func() error {
//				panic("mock out the ValidateBasic method")
//			},
//		}
//
//		// use mockedValidatedProtoMarshaler in code that requires utils.ValidatedProtoMarshaler
//		// and then make assertions.
//
//	}
type ValidatedProtoMarshalerMock struct {
	// MarshalFunc mocks the Marshal method.
	MarshalFunc func() ([]byte, error)

	// MarshalToFunc mocks the MarshalTo method.
	MarshalToFunc func(data []byte) (int, error)

	// MarshalToSizedBufferFunc mocks the MarshalToSizedBuffer method.
	MarshalToSizedBufferFunc func(dAtA []byte) (int, error)

	// ProtoMessageFunc mocks the ProtoMessage method.
	ProtoMessageFunc func()

	// ResetFunc mocks the Reset method.
	ResetFunc func()

	// SizeFunc mocks the Size method.
	SizeFunc func() int

	// StringFunc mocks the String method.
	StringFunc func() string

	// UnmarshalFunc mocks the Unmarshal method.
	UnmarshalFunc func(data []byte) error

	// ValidateBasicFunc mocks the ValidateBasic method.
	ValidateBasicFunc func() error

	// calls tracks calls to the methods.
	calls struct {
		// Marshal holds details about calls to the Marshal method.
		Marshal []struct {
		}
		// MarshalTo holds details about calls to the MarshalTo method.
		MarshalTo []struct {
			// Data is the data argument value.
			Data []byte
		}
		// MarshalToSizedBuffer holds details about calls to the MarshalToSizedBuffer method.
		MarshalToSizedBuffer []struct {
			// DAtA is the dAtA argument value.
			DAtA []byte
		}
		// ProtoMessage holds details about calls to the ProtoMessage method.
		ProtoMessage []struct {
		}
		// Reset holds details about calls to the Reset method.
		Reset []struct {
		}
		// Size holds details about calls to the Size method.
		Size []struct {
		}
		// String holds details about calls to the String method.
		String []struct {
		}
		// Unmarshal holds details about calls to the Unmarshal method.
		Unmarshal []struct {
			// Data is the data argument value.
			Data []byte
		}
		// ValidateBasic holds details about calls to the ValidateBasic method.
		ValidateBasic []struct {
		}
	}
	lockMarshal              sync.RWMutex
	lockMarshalTo            sync.RWMutex
	lockMarshalToSizedBuffer sync.RWMutex
	lockProtoMessage         sync.RWMutex
	lockReset                sync.RWMutex
	lockSize                 sync.RWMutex
	lockString               sync.RWMutex
	lockUnmarshal            sync.RWMutex
	lockValidateBasic        sync.RWMutex
}

// Marshal calls MarshalFunc.
func (mock *ValidatedProtoMarshalerMock) Marshal() ([]byte, error) {
	if mock.MarshalFunc == nil {
		panic("ValidatedProtoMarshalerMock.MarshalFunc: method is nil but ValidatedProtoMarshaler.Marshal was just called")
	}
	callInfo := struct {
	}{}
	mock.lockMarshal.Lock()
	mock.calls.Marshal = append(mock.calls.Marshal, callInfo)
	mock.lockMarshal.Unlock()
	return mock.MarshalFunc()
}

// MarshalCalls gets all the calls that were made to Marshal.
// Check the length with:
//
//	len(mockedValidatedProtoMarshaler.MarshalCalls())
func (mock *ValidatedProtoMarshalerMock) MarshalCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockMarshal.RLock()
	calls = mock.calls.Marshal
	mock.lockMarshal.RUnlock()
	return calls
}

// MarshalTo calls MarshalToFunc.
func (mock *ValidatedProtoMarshalerMock) MarshalTo(data []byte) (int, error) {
	if mock.MarshalToFunc == nil {
		panic("ValidatedProtoMarshalerMock.MarshalToFunc: method is nil but ValidatedProtoMarshaler.MarshalTo was just called")
	}
	callInfo := struct {
		Data []byte
	}{
		Data: data,
	}
	mock.lockMarshalTo.Lock()
	mock.calls.MarshalTo = append(mock.calls.MarshalTo, callInfo)
	mock.lockMarshalTo.Unlock()
	return mock.MarshalToFunc(data)
}

// MarshalToCalls gets all the calls that were made to MarshalTo.
// Check the length with:
//
//	len(mockedValidatedProtoMarshaler.MarshalToCalls())
func (mock *ValidatedProtoMarshalerMock) MarshalToCalls() []struct {
	Data []byte
} {
	var calls []struct {
		Data []byte
	}
	mock.lockMarshalTo.RLock()
	calls = mock.calls.MarshalTo
	mock.lockMarshalTo.RUnlock()
	return calls
}

// MarshalToSizedBuffer calls MarshalToSizedBufferFunc.
func (mock *ValidatedProtoMarshalerMock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	if mock.MarshalToSizedBufferFunc == nil {
		panic("ValidatedProtoMarshalerMock.MarshalToSizedBufferFunc: method is nil but ValidatedProtoMarshaler.MarshalToSizedBuffer was just called")
	}
	callInfo := struct {
		DAtA []byte
	}{
		DAtA: dAtA,
	}
	mock.lockMarshalToSizedBuffer.Lock()
	mock.calls.MarshalToSizedBuffer = append(mock.calls.MarshalToSizedBuffer, callInfo)
	mock.lockMarshalToSizedBuffer.Unlock()
	return mock.MarshalToSizedBufferFunc(dAtA)
}

// MarshalToSizedBufferCalls gets all the calls that were made to MarshalToSizedBuffer.
// Check the length with:
//
//	len(mockedValidatedProtoMarshaler.MarshalToSizedBufferCalls())
func (mock *ValidatedProtoMarshalerMock) MarshalToSizedBufferCalls() []struct {
	DAtA []byte
} {
	var calls []struct {
		DAtA []byte
	}
	mock.lockMarshalToSizedBuffer.RLock()
	calls = mock.calls.MarshalToSizedBuffer
	mock.lockMarshalToSizedBuffer.RUnlock()
	return calls
}

// ProtoMessage calls ProtoMessageFunc.
func (mock *ValidatedProtoMarshalerMock) ProtoMessage() {
	if mock.ProtoMessageFunc == nil {
		panic("ValidatedProtoMarshalerMock.ProtoMessageFunc: method is nil but ValidatedProtoMarshaler.ProtoMessage was just called")
	}
	callInfo := struct {
	}{}
	mock.lockProtoMessage.Lock()
	mock.calls.ProtoMessage = append(mock.calls.ProtoMessage, callInfo)
	mock.lockProtoMessage.Unlock()
	mock.ProtoMessageFunc()
}

// ProtoMessageCalls gets all the calls that were made to ProtoMessage.
// Check the length with:
//
//	len(mockedValidatedProtoMarshaler.ProtoMessageCalls())
func (mock *ValidatedProtoMarshalerMock) ProtoMessageCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockProtoMessage.RLock()
	calls = mock.calls.ProtoMessage
	mock.lockProtoMessage.RUnlock()
	return calls
}

// Reset calls ResetFunc.
func (mock *ValidatedProtoMarshalerMock) Reset() {
	if mock.ResetFunc == nil {
		panic("ValidatedProtoMarshalerMock.ResetFunc: method is nil but ValidatedProtoMarshaler.Reset was just called")
	}
	callInfo := struct {
	}{}
	mock.lockReset.Lock()
	mock.calls.Reset = append(mock.calls.Reset, callInfo)
	mock.lockReset.Unlock()
	mock.ResetFunc()
}

// ResetCalls gets all the calls that were made to Reset.
// Check the length with:
//
//	len(mockedValidatedProtoMarshaler.ResetCalls())
func (mock *ValidatedProtoMarshalerMock) ResetCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockReset.RLock()
	calls = mock.calls.Reset
	mock.lockReset.RUnlock()
	return calls
}

// Size calls SizeFunc.
func (mock *ValidatedProtoMarshalerMock) Size() int {
	if mock.SizeFunc == nil {
		panic("ValidatedProtoMarshalerMock.SizeFunc: method is nil but ValidatedProtoMarshaler.Size was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSize.Lock()
	mock.calls.Size = append(mock.calls.Size, callInfo)
	mock.lockSize.Unlock()
	return mock.SizeFunc()
}

// SizeCalls gets all the calls that were made to Size.
// Check the length with:
//
//	len(mockedValidatedProtoMarshaler.SizeCalls())
func (mock *ValidatedProtoMarshalerMock) SizeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSize.RLock()
	calls = mock.calls.Size
	mock.lockSize.RUnlock()
	return calls
}

// String calls StringFunc.
func (mock *ValidatedProtoMarshalerMock) String() string {
	if mock.StringFunc == nil {
		panic("ValidatedProtoMarshalerMock.StringFunc: method is nil but ValidatedProtoMarshaler.String was just called")
	}
	callInfo := struct {
	}{}
	mock.lockString.Lock()
	mock.calls.String = append(mock.calls.String, callInfo)
	mock.lockString.Unlock()
	return mock.StringFunc()
}

// StringCalls gets all the calls that were made to String.
// Check the length with:
//
//	len(mockedValidatedProtoMarshaler.StringCalls())
func (mock *ValidatedProtoMarshalerMock) StringCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockString.RLock()
	calls = mock.calls.String
	mock.lockString.RUnlock()
	return calls
}

// Unmarshal calls UnmarshalFunc.
func (mock *ValidatedProtoMarshalerMock) Unmarshal(data []byte) error {
	if mock.UnmarshalFunc == nil {
		panic("ValidatedProtoMarshalerMock.UnmarshalFunc: method is nil but ValidatedProtoMarshaler.Unmarshal was just called")
	}
	callInfo := struct {
		Data []byte
	}{
		Data: data,
	}
	mock.lockUnmarshal.Lock()
	mock.calls.Unmarshal = append(mock.calls.Unmarshal, callInfo)
	mock.lockUnmarshal.Unlock()
	return mock.UnmarshalFunc(data)
}

// UnmarshalCalls gets all the calls that were made to Unmarshal.
// Check the length with:
//
//	len(mockedValidatedProtoMarshaler.UnmarshalCalls())
func (mock *ValidatedProtoMarshalerMock) UnmarshalCalls() []struct {
	Data []byte
} {
	var calls []struct {
		Data []byte
	}
	mock.lockUnmarshal.RLock()
	calls = mock.calls.Unmarshal
	mock.lockUnmarshal.RUnlock()
	return calls
}

// ValidateBasic calls ValidateBasicFunc.
func (mock *ValidatedProtoMarshalerMock) ValidateBasic() error {
	if mock.ValidateBasicFunc == nil {
		panic("ValidatedProtoMarshalerMock.ValidateBasicFunc: method is nil but ValidatedProtoMarshaler.ValidateBasic was just called")
	}
	callInfo := struct {
	}{}
	mock.lockValidateBasic.Lock()
	mock.calls.ValidateBasic = append(mock.calls.ValidateBasic, callInfo)
	mock.lockValidateBasic.Unlock()
	return mock.ValidateBasicFunc()
}

// ValidateBasicCalls gets all the calls that were made to ValidateBasic.
// Check the length with:
//
//	len(mockedValidatedProtoMarshaler.ValidateBasicCalls())
func (mock *ValidatedProtoMarshalerMock) ValidateBasicCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockValidateBasic.RLock()
	calls = mock.calls.ValidateBasic
	mock.lockValidateBasic.RUnlock()
	return calls
}
