github.com/enbility/spine-go@v0.7.0/mocks/DeviceInterface.go (about)

     1  // Code generated by mockery v2.45.0. DO NOT EDIT.
     2  
     3  package mocks
     4  
     5  import (
     6  	model "github.com/enbility/spine-go/model"
     7  	mock "github.com/stretchr/testify/mock"
     8  )
     9  
    10  // DeviceInterface is an autogenerated mock type for the DeviceInterface type
    11  type DeviceInterface struct {
    12  	mock.Mock
    13  }
    14  
    15  type DeviceInterface_Expecter struct {
    16  	mock *mock.Mock
    17  }
    18  
    19  func (_m *DeviceInterface) EXPECT() *DeviceInterface_Expecter {
    20  	return &DeviceInterface_Expecter{mock: &_m.Mock}
    21  }
    22  
    23  // Address provides a mock function with given fields:
    24  func (_m *DeviceInterface) Address() *model.AddressDeviceType {
    25  	ret := _m.Called()
    26  
    27  	if len(ret) == 0 {
    28  		panic("no return value specified for Address")
    29  	}
    30  
    31  	var r0 *model.AddressDeviceType
    32  	if rf, ok := ret.Get(0).(func() *model.AddressDeviceType); ok {
    33  		r0 = rf()
    34  	} else {
    35  		if ret.Get(0) != nil {
    36  			r0 = ret.Get(0).(*model.AddressDeviceType)
    37  		}
    38  	}
    39  
    40  	return r0
    41  }
    42  
    43  // DeviceInterface_Address_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Address'
    44  type DeviceInterface_Address_Call struct {
    45  	*mock.Call
    46  }
    47  
    48  // Address is a helper method to define mock.On call
    49  func (_e *DeviceInterface_Expecter) Address() *DeviceInterface_Address_Call {
    50  	return &DeviceInterface_Address_Call{Call: _e.mock.On("Address")}
    51  }
    52  
    53  func (_c *DeviceInterface_Address_Call) Run(run func()) *DeviceInterface_Address_Call {
    54  	_c.Call.Run(func(args mock.Arguments) {
    55  		run()
    56  	})
    57  	return _c
    58  }
    59  
    60  func (_c *DeviceInterface_Address_Call) Return(_a0 *model.AddressDeviceType) *DeviceInterface_Address_Call {
    61  	_c.Call.Return(_a0)
    62  	return _c
    63  }
    64  
    65  func (_c *DeviceInterface_Address_Call) RunAndReturn(run func() *model.AddressDeviceType) *DeviceInterface_Address_Call {
    66  	_c.Call.Return(run)
    67  	return _c
    68  }
    69  
    70  // DestinationData provides a mock function with given fields:
    71  func (_m *DeviceInterface) DestinationData() model.NodeManagementDestinationDataType {
    72  	ret := _m.Called()
    73  
    74  	if len(ret) == 0 {
    75  		panic("no return value specified for DestinationData")
    76  	}
    77  
    78  	var r0 model.NodeManagementDestinationDataType
    79  	if rf, ok := ret.Get(0).(func() model.NodeManagementDestinationDataType); ok {
    80  		r0 = rf()
    81  	} else {
    82  		r0 = ret.Get(0).(model.NodeManagementDestinationDataType)
    83  	}
    84  
    85  	return r0
    86  }
    87  
    88  // DeviceInterface_DestinationData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DestinationData'
    89  type DeviceInterface_DestinationData_Call struct {
    90  	*mock.Call
    91  }
    92  
    93  // DestinationData is a helper method to define mock.On call
    94  func (_e *DeviceInterface_Expecter) DestinationData() *DeviceInterface_DestinationData_Call {
    95  	return &DeviceInterface_DestinationData_Call{Call: _e.mock.On("DestinationData")}
    96  }
    97  
    98  func (_c *DeviceInterface_DestinationData_Call) Run(run func()) *DeviceInterface_DestinationData_Call {
    99  	_c.Call.Run(func(args mock.Arguments) {
   100  		run()
   101  	})
   102  	return _c
   103  }
   104  
   105  func (_c *DeviceInterface_DestinationData_Call) Return(_a0 model.NodeManagementDestinationDataType) *DeviceInterface_DestinationData_Call {
   106  	_c.Call.Return(_a0)
   107  	return _c
   108  }
   109  
   110  func (_c *DeviceInterface_DestinationData_Call) RunAndReturn(run func() model.NodeManagementDestinationDataType) *DeviceInterface_DestinationData_Call {
   111  	_c.Call.Return(run)
   112  	return _c
   113  }
   114  
   115  // DeviceType provides a mock function with given fields:
   116  func (_m *DeviceInterface) DeviceType() *model.DeviceTypeType {
   117  	ret := _m.Called()
   118  
   119  	if len(ret) == 0 {
   120  		panic("no return value specified for DeviceType")
   121  	}
   122  
   123  	var r0 *model.DeviceTypeType
   124  	if rf, ok := ret.Get(0).(func() *model.DeviceTypeType); ok {
   125  		r0 = rf()
   126  	} else {
   127  		if ret.Get(0) != nil {
   128  			r0 = ret.Get(0).(*model.DeviceTypeType)
   129  		}
   130  	}
   131  
   132  	return r0
   133  }
   134  
   135  // DeviceInterface_DeviceType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeviceType'
   136  type DeviceInterface_DeviceType_Call struct {
   137  	*mock.Call
   138  }
   139  
   140  // DeviceType is a helper method to define mock.On call
   141  func (_e *DeviceInterface_Expecter) DeviceType() *DeviceInterface_DeviceType_Call {
   142  	return &DeviceInterface_DeviceType_Call{Call: _e.mock.On("DeviceType")}
   143  }
   144  
   145  func (_c *DeviceInterface_DeviceType_Call) Run(run func()) *DeviceInterface_DeviceType_Call {
   146  	_c.Call.Run(func(args mock.Arguments) {
   147  		run()
   148  	})
   149  	return _c
   150  }
   151  
   152  func (_c *DeviceInterface_DeviceType_Call) Return(_a0 *model.DeviceTypeType) *DeviceInterface_DeviceType_Call {
   153  	_c.Call.Return(_a0)
   154  	return _c
   155  }
   156  
   157  func (_c *DeviceInterface_DeviceType_Call) RunAndReturn(run func() *model.DeviceTypeType) *DeviceInterface_DeviceType_Call {
   158  	_c.Call.Return(run)
   159  	return _c
   160  }
   161  
   162  // FeatureSet provides a mock function with given fields:
   163  func (_m *DeviceInterface) FeatureSet() *model.NetworkManagementFeatureSetType {
   164  	ret := _m.Called()
   165  
   166  	if len(ret) == 0 {
   167  		panic("no return value specified for FeatureSet")
   168  	}
   169  
   170  	var r0 *model.NetworkManagementFeatureSetType
   171  	if rf, ok := ret.Get(0).(func() *model.NetworkManagementFeatureSetType); ok {
   172  		r0 = rf()
   173  	} else {
   174  		if ret.Get(0) != nil {
   175  			r0 = ret.Get(0).(*model.NetworkManagementFeatureSetType)
   176  		}
   177  	}
   178  
   179  	return r0
   180  }
   181  
   182  // DeviceInterface_FeatureSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FeatureSet'
   183  type DeviceInterface_FeatureSet_Call struct {
   184  	*mock.Call
   185  }
   186  
   187  // FeatureSet is a helper method to define mock.On call
   188  func (_e *DeviceInterface_Expecter) FeatureSet() *DeviceInterface_FeatureSet_Call {
   189  	return &DeviceInterface_FeatureSet_Call{Call: _e.mock.On("FeatureSet")}
   190  }
   191  
   192  func (_c *DeviceInterface_FeatureSet_Call) Run(run func()) *DeviceInterface_FeatureSet_Call {
   193  	_c.Call.Run(func(args mock.Arguments) {
   194  		run()
   195  	})
   196  	return _c
   197  }
   198  
   199  func (_c *DeviceInterface_FeatureSet_Call) Return(_a0 *model.NetworkManagementFeatureSetType) *DeviceInterface_FeatureSet_Call {
   200  	_c.Call.Return(_a0)
   201  	return _c
   202  }
   203  
   204  func (_c *DeviceInterface_FeatureSet_Call) RunAndReturn(run func() *model.NetworkManagementFeatureSetType) *DeviceInterface_FeatureSet_Call {
   205  	_c.Call.Return(run)
   206  	return _c
   207  }
   208  
   209  // NewDeviceInterface creates a new instance of DeviceInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
   210  // The first argument is typically a *testing.T value.
   211  func NewDeviceInterface(t interface {
   212  	mock.TestingT
   213  	Cleanup(func())
   214  }) *DeviceInterface {
   215  	mock := &DeviceInterface{}
   216  	mock.Mock.Test(t)
   217  
   218  	t.Cleanup(func() { mock.AssertExpectations(t) })
   219  
   220  	return mock
   221  }