// Code generated by MockGen. DO NOT EDIT.
// Source: git.tizen.org/tools/muxpi/sw/nanopi/stm (interfaces: Interface)

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

import (
	stm "git.tizen.org/tools/muxpi/sw/nanopi/stm"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
	time "time"
)

// MockInterface is a mock of Interface interface
type MockInterface struct {
	ctrl     *gomock.Controller
	recorder *MockInterfaceMockRecorder
}

// MockInterfaceMockRecorder is the mock recorder for MockInterface
type MockInterfaceMockRecorder struct {
	mock *MockInterface
}

// NewMockInterface creates a new mock instance
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
	mock := &MockInterface{ctrl: ctrl}
	mock.recorder = &MockInterfaceMockRecorder{mock}
	return mock
}

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

// ClearDisplay mocks base method
func (m *MockInterface) ClearDisplay() error {
	ret := m.ctrl.Call(m, "ClearDisplay")
	ret0, _ := ret[0].(error)
	return ret0
}

// ClearDisplay indicates an expected call of ClearDisplay
func (mr *MockInterfaceMockRecorder) ClearDisplay() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearDisplay", reflect.TypeOf((*MockInterface)(nil).ClearDisplay))
}

// DUT mocks base method
func (m *MockInterface) DUT() error {
	ret := m.ctrl.Call(m, "DUT")
	ret0, _ := ret[0].(error)
	return ret0
}

// DUT indicates an expected call of DUT
func (mr *MockInterfaceMockRecorder) DUT() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DUT", reflect.TypeOf((*MockInterface)(nil).DUT))
}

// GetCurrent mocks base method
func (m *MockInterface) GetCurrent() (int, error) {
	ret := m.ctrl.Call(m, "GetCurrent")
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCurrent indicates an expected call of GetCurrent
func (mr *MockInterfaceMockRecorder) GetCurrent() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrent", reflect.TypeOf((*MockInterface)(nil).GetCurrent))
}

// GetCurrentRecord mocks base method
func (m *MockInterface) GetCurrentRecord() ([]int, error) {
	ret := m.ctrl.Call(m, "GetCurrentRecord")
	ret0, _ := ret[0].([]int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCurrentRecord indicates an expected call of GetCurrentRecord
func (mr *MockInterfaceMockRecorder) GetCurrentRecord() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentRecord", reflect.TypeOf((*MockInterface)(nil).GetCurrentRecord))
}

// HDMI mocks base method
func (m *MockInterface) HDMI(arg0 bool) error {
	ret := m.ctrl.Call(m, "HDMI", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// HDMI indicates an expected call of HDMI
func (mr *MockInterfaceMockRecorder) HDMI(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HDMI", reflect.TypeOf((*MockInterface)(nil).HDMI), arg0)
}

// PowerTick mocks base method
func (m *MockInterface) PowerTick(arg0 time.Duration) error {
	ret := m.ctrl.Call(m, "PowerTick", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// PowerTick indicates an expected call of PowerTick
func (mr *MockInterfaceMockRecorder) PowerTick(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PowerTick", reflect.TypeOf((*MockInterface)(nil).PowerTick), arg0)
}

// PrintText mocks base method
func (m *MockInterface) PrintText(arg0, arg1 uint, arg2 stm.Color, arg3 string) error {
	ret := m.ctrl.Call(m, "PrintText", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// PrintText indicates an expected call of PrintText
func (mr *MockInterfaceMockRecorder) PrintText(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrintText", reflect.TypeOf((*MockInterface)(nil).PrintText), arg0, arg1, arg2, arg3)
}

// SetDyper mocks base method
func (m *MockInterface) SetDyper(arg0 stm.Dyper, arg1 bool) error {
	ret := m.ctrl.Call(m, "SetDyper", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetDyper indicates an expected call of SetDyper
func (mr *MockInterfaceMockRecorder) SetDyper(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDyper", reflect.TypeOf((*MockInterface)(nil).SetDyper), arg0, arg1)
}

// SetLED mocks base method
func (m *MockInterface) SetLED(arg0 stm.LED, arg1, arg2, arg3 byte) error {
	ret := m.ctrl.Call(m, "SetLED", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetLED indicates an expected call of SetLED
func (mr *MockInterfaceMockRecorder) SetLED(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLED", reflect.TypeOf((*MockInterface)(nil).SetLED), arg0, arg1, arg2, arg3)
}

// StartCurrentRecord mocks base method
func (m *MockInterface) StartCurrentRecord(arg0 int, arg1 time.Duration) error {
	ret := m.ctrl.Call(m, "StartCurrentRecord", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// StartCurrentRecord indicates an expected call of StartCurrentRecord
func (mr *MockInterfaceMockRecorder) StartCurrentRecord(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartCurrentRecord", reflect.TypeOf((*MockInterface)(nil).StartCurrentRecord), arg0, arg1)
}

// StopCurrentRecord mocks base method
func (m *MockInterface) StopCurrentRecord() error {
	ret := m.ctrl.Call(m, "StopCurrentRecord")
	ret0, _ := ret[0].(error)
	return ret0
}

// StopCurrentRecord indicates an expected call of StopCurrentRecord
func (mr *MockInterfaceMockRecorder) StopCurrentRecord() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopCurrentRecord", reflect.TypeOf((*MockInterface)(nil).StopCurrentRecord))
}

// TS mocks base method
func (m *MockInterface) TS() error {
	ret := m.ctrl.Call(m, "TS")
	ret0, _ := ret[0].(error)
	return ret0
}

// TS indicates an expected call of TS
func (mr *MockInterfaceMockRecorder) TS() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TS", reflect.TypeOf((*MockInterface)(nil).TS))
}