mirror of
https://gitee.com/rainbond/Rainbond.git
synced 2024-12-09 07:07:43 +08:00
238 lines
7.4 KiB
Go
238 lines
7.4 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: event/manager.go
|
|
|
|
// Package event is a generated GoMock package.
|
|
package event
|
|
|
|
import (
|
|
gomock "github.com/golang/mock/gomock"
|
|
reflect "reflect"
|
|
time "time"
|
|
)
|
|
|
|
// MockManager is a mock of Manager interface
|
|
type MockManager struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockManagerMockRecorder
|
|
}
|
|
|
|
// MockManagerMockRecorder is the mock recorder for MockManager
|
|
type MockManagerMockRecorder struct {
|
|
mock *MockManager
|
|
}
|
|
|
|
// NewMockManager creates a new mock instance
|
|
func NewMockManager(ctrl *gomock.Controller) *MockManager {
|
|
mock := &MockManager{ctrl: ctrl}
|
|
mock.recorder = &MockManagerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockManager) EXPECT() *MockManagerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// GetLogger mocks base method
|
|
func (m *MockManager) GetLogger(eventID string) Logger {
|
|
ret := m.ctrl.Call(m, "GetLogger", eventID)
|
|
ret0, _ := ret[0].(Logger)
|
|
return ret0
|
|
}
|
|
|
|
// GetLogger indicates an expected call of GetLogger
|
|
func (mr *MockManagerMockRecorder) GetLogger(eventID interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogger", reflect.TypeOf((*MockManager)(nil).GetLogger), eventID)
|
|
}
|
|
|
|
// Start mocks base method
|
|
func (m *MockManager) Start() error {
|
|
ret := m.ctrl.Call(m, "Start")
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Start indicates an expected call of Start
|
|
func (mr *MockManagerMockRecorder) Start() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockManager)(nil).Start))
|
|
}
|
|
|
|
// Close mocks base method
|
|
func (m *MockManager) Close() error {
|
|
ret := m.ctrl.Call(m, "Close")
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Close indicates an expected call of Close
|
|
func (mr *MockManagerMockRecorder) Close() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockManager)(nil).Close))
|
|
}
|
|
|
|
// ReleaseLogger mocks base method
|
|
func (m *MockManager) ReleaseLogger(arg0 Logger) {
|
|
m.ctrl.Call(m, "ReleaseLogger", arg0)
|
|
}
|
|
|
|
// ReleaseLogger indicates an expected call of ReleaseLogger
|
|
func (mr *MockManagerMockRecorder) ReleaseLogger(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseLogger", reflect.TypeOf((*MockManager)(nil).ReleaseLogger), arg0)
|
|
}
|
|
|
|
// MockLogger is a mock of Logger interface
|
|
type MockLogger struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockLoggerMockRecorder
|
|
}
|
|
|
|
// MockLoggerMockRecorder is the mock recorder for MockLogger
|
|
type MockLoggerMockRecorder struct {
|
|
mock *MockLogger
|
|
}
|
|
|
|
// NewMockLogger creates a new mock instance
|
|
func NewMockLogger(ctrl *gomock.Controller) *MockLogger {
|
|
mock := &MockLogger{ctrl: ctrl}
|
|
mock.recorder = &MockLoggerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockLogger) EXPECT() *MockLoggerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Info mocks base method
|
|
func (m *MockLogger) Info(arg0 string, arg1 map[string]string) {
|
|
m.ctrl.Call(m, "Info", arg0, arg1)
|
|
}
|
|
|
|
// Info indicates an expected call of Info
|
|
func (mr *MockLoggerMockRecorder) Info(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogger)(nil).Info), arg0, arg1)
|
|
}
|
|
|
|
// Error mocks base method
|
|
func (m *MockLogger) Error(arg0 string, arg1 map[string]string) {
|
|
m.ctrl.Call(m, "Error", arg0, arg1)
|
|
}
|
|
|
|
// Error indicates an expected call of Error
|
|
func (mr *MockLoggerMockRecorder) Error(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockLogger)(nil).Error), arg0, arg1)
|
|
}
|
|
|
|
// Debug mocks base method
|
|
func (m *MockLogger) Debug(arg0 string, arg1 map[string]string) {
|
|
m.ctrl.Call(m, "Debug", arg0, arg1)
|
|
}
|
|
|
|
// Debug indicates an expected call of Debug
|
|
func (mr *MockLoggerMockRecorder) Debug(arg0, arg1 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockLogger)(nil).Debug), arg0, arg1)
|
|
}
|
|
|
|
// Event mocks base method
|
|
func (m *MockLogger) Event() string {
|
|
ret := m.ctrl.Call(m, "Event")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// Event indicates an expected call of Event
|
|
func (mr *MockLoggerMockRecorder) Event() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Event", reflect.TypeOf((*MockLogger)(nil).Event))
|
|
}
|
|
|
|
// CreateTime mocks base method
|
|
func (m *MockLogger) CreateTime() time.Time {
|
|
ret := m.ctrl.Call(m, "CreateTime")
|
|
ret0, _ := ret[0].(time.Time)
|
|
return ret0
|
|
}
|
|
|
|
// CreateTime indicates an expected call of CreateTime
|
|
func (mr *MockLoggerMockRecorder) CreateTime() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTime", reflect.TypeOf((*MockLogger)(nil).CreateTime))
|
|
}
|
|
|
|
// GetChan mocks base method
|
|
func (m *MockLogger) GetChan() chan []byte {
|
|
ret := m.ctrl.Call(m, "GetChan")
|
|
ret0, _ := ret[0].(chan []byte)
|
|
return ret0
|
|
}
|
|
|
|
// GetChan indicates an expected call of GetChan
|
|
func (mr *MockLoggerMockRecorder) GetChan() *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChan", reflect.TypeOf((*MockLogger)(nil).GetChan))
|
|
}
|
|
|
|
// SetChan mocks base method
|
|
func (m *MockLogger) SetChan(arg0 chan []byte) {
|
|
m.ctrl.Call(m, "SetChan", arg0)
|
|
}
|
|
|
|
// SetChan indicates an expected call of SetChan
|
|
func (mr *MockLoggerMockRecorder) SetChan(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetChan", reflect.TypeOf((*MockLogger)(nil).SetChan), arg0)
|
|
}
|
|
|
|
// GetWriter mocks base method
|
|
func (m *MockLogger) GetWriter(step, level string) LoggerWriter {
|
|
ret := m.ctrl.Call(m, "GetWriter", step, level)
|
|
ret0, _ := ret[0].(LoggerWriter)
|
|
return ret0
|
|
}
|
|
|
|
// GetWriter indicates an expected call of GetWriter
|
|
func (mr *MockLoggerMockRecorder) GetWriter(step, level interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriter", reflect.TypeOf((*MockLogger)(nil).GetWriter), step, level)
|
|
}
|
|
|
|
// MockLoggerWriter is a mock of LoggerWriter interface
|
|
type MockLoggerWriter struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockLoggerWriterMockRecorder
|
|
}
|
|
|
|
// MockLoggerWriterMockRecorder is the mock recorder for MockLoggerWriter
|
|
type MockLoggerWriterMockRecorder struct {
|
|
mock *MockLoggerWriter
|
|
}
|
|
|
|
// NewMockLoggerWriter creates a new mock instance
|
|
func NewMockLoggerWriter(ctrl *gomock.Controller) *MockLoggerWriter {
|
|
mock := &MockLoggerWriter{ctrl: ctrl}
|
|
mock.recorder = &MockLoggerWriterMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use
|
|
func (m *MockLoggerWriter) EXPECT() *MockLoggerWriterMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Write mocks base method
|
|
func (m *MockLoggerWriter) Write(p []byte) (int, error) {
|
|
ret := m.ctrl.Call(m, "Write", p)
|
|
ret0, _ := ret[0].(int)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Write indicates an expected call of Write
|
|
func (mr *MockLoggerWriterMockRecorder) Write(p interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockLoggerWriter)(nil).Write), p)
|
|
}
|
|
|
|
// SetFormat mocks base method
|
|
func (m *MockLoggerWriter) SetFormat(arg0 map[string]interface{}) {
|
|
m.ctrl.Call(m, "SetFormat", arg0)
|
|
}
|
|
|
|
// SetFormat indicates an expected call of SetFormat
|
|
func (mr *MockLoggerWriterMockRecorder) SetFormat(arg0 interface{}) *gomock.Call {
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFormat", reflect.TypeOf((*MockLoggerWriter)(nil).SetFormat), arg0)
|
|
}
|