plc4go/pkg/api/cache/mocks_test.go

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

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

package cache

import (
	"context"

	"github.com/apache/plc4x/plc4go/pkg/api"
	"github.com/apache/plc4x/plc4go/pkg/api/model"
	"github.com/apache/plc4x/plc4go/spi/tracer"
	mock "github.com/stretchr/testify/mock"
)

// NewMockPlcConnectionCache creates a new instance of MockPlcConnectionCache. 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 NewMockPlcConnectionCache(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPlcConnectionCache {
	mock := &MockPlcConnectionCache{}
	mock.Mock.Test(t)

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

	return mock
}

// MockPlcConnectionCache is an autogenerated mock type for the PlcConnectionCache type
type MockPlcConnectionCache struct {
	mock.Mock
}

type MockPlcConnectionCache_Expecter struct {
	mock *mock.Mock
}

func (_m *MockPlcConnectionCache) EXPECT() *MockPlcConnectionCache_Expecter {
	return &MockPlcConnectionCache_Expecter{mock: &_m.Mock}
}

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

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

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

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

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

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

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

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

// GetConnection provides a mock function for the type MockPlcConnectionCache
func (_mock *MockPlcConnectionCache) GetConnection(ctx context.Context, connectionString string) (plc4go.PlcConnection, error) {
	ret := _mock.Called(ctx, connectionString)

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

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

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

// GetConnection is a helper method to define mock.On call
//   - ctx context.Context
//   - connectionString string
func (_e *MockPlcConnectionCache_Expecter) GetConnection(ctx any, connectionString any) *MockPlcConnectionCache_GetConnection_Call {
	return &MockPlcConnectionCache_GetConnection_Call{Call: _e.mock.On("GetConnection", ctx, connectionString)}
}

func (_c *MockPlcConnectionCache_GetConnection_Call) Run(run func(ctx context.Context, connectionString string)) *MockPlcConnectionCache_GetConnection_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 *MockPlcConnectionCache_GetConnection_Call) Return(plcConnection plc4go.PlcConnection, err error) *MockPlcConnectionCache_GetConnection_Call {
	_c.Call.Return(plcConnection, err)
	return _c
}

func (_c *MockPlcConnectionCache_GetConnection_Call) RunAndReturn(run func(ctx context.Context, connectionString string) (plc4go.PlcConnection, error)) *MockPlcConnectionCache_GetConnection_Call {
	_c.Call.Return(run)
	return _c
}

// newMockconnectionListener creates a new instance of mockconnectionListener. 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 newMockconnectionListener(t interface {
	mock.TestingT
	Cleanup(func())
}) *mockconnectionListener {
	mock := &mockconnectionListener{}
	mock.Mock.Test(t)

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

	return mock
}

// mockconnectionListener is an autogenerated mock type for the connectionListener type
type mockconnectionListener struct {
	mock.Mock
}

type mockconnectionListener_Expecter struct {
	mock *mock.Mock
}

func (_m *mockconnectionListener) EXPECT() *mockconnectionListener_Expecter {
	return &mockconnectionListener_Expecter{mock: &_m.Mock}
}

// onConnectionEvent provides a mock function for the type mockconnectionListener
func (_mock *mockconnectionListener) onConnectionEvent(event connectionEvent) {
	_mock.Called(event)
	return
}

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

// onConnectionEvent is a helper method to define mock.On call
//   - event connectionEvent
func (_e *mockconnectionListener_Expecter) onConnectionEvent(event any) *mockconnectionListener_onConnectionEvent_Call {
	return &mockconnectionListener_onConnectionEvent_Call{Call: _e.mock.On("onConnectionEvent", event)}
}

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

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

func (_c *mockconnectionListener_onConnectionEvent_Call) RunAndReturn(run func(event connectionEvent)) *mockconnectionListener_onConnectionEvent_Call {
	_c.Run(run)
	return _c
}

// newMockconnectionEvent creates a new instance of mockconnectionEvent. 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 newMockconnectionEvent(t interface {
	mock.TestingT
	Cleanup(func())
}) *mockconnectionEvent {
	mock := &mockconnectionEvent{}
	mock.Mock.Test(t)

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

	return mock
}

// mockconnectionEvent is an autogenerated mock type for the connectionEvent type
type mockconnectionEvent struct {
	mock.Mock
}

type mockconnectionEvent_Expecter struct {
	mock *mock.Mock
}

func (_m *mockconnectionEvent) EXPECT() *mockconnectionEvent_Expecter {
	return &mockconnectionEvent_Expecter{mock: &_m.Mock}
}

// getConnectionContainer provides a mock function for the type mockconnectionEvent
func (_mock *mockconnectionEvent) getConnectionContainer() *connectionContainer {
	ret := _mock.Called()

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

	var r0 *connectionContainer
	if returnFunc, ok := ret.Get(0).(func() *connectionContainer); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*connectionContainer)
		}
	}
	return r0
}

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

// getConnectionContainer is a helper method to define mock.On call
func (_e *mockconnectionEvent_Expecter) getConnectionContainer() *mockconnectionEvent_getConnectionContainer_Call {
	return &mockconnectionEvent_getConnectionContainer_Call{Call: _e.mock.On("getConnectionContainer")}
}

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

func (_c *mockconnectionEvent_getConnectionContainer_Call) Return(connectionContainerMoqParam *connectionContainer) *mockconnectionEvent_getConnectionContainer_Call {
	_c.Call.Return(connectionContainerMoqParam)
	return _c
}

func (_c *mockconnectionEvent_getConnectionContainer_Call) RunAndReturn(run func() *connectionContainer) *mockconnectionEvent_getConnectionContainer_Call {
	_c.Call.Return(run)
	return _c
}

// newMocksubscriptionAware creates a new instance of mocksubscriptionAware. 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 newMocksubscriptionAware(t interface {
	mock.TestingT
	Cleanup(func())
}) *mocksubscriptionAware {
	mock := &mocksubscriptionAware{}
	mock.Mock.Test(t)

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

	return mock
}

// mocksubscriptionAware is an autogenerated mock type for the subscriptionAware type
type mocksubscriptionAware struct {
	mock.Mock
}

type mocksubscriptionAware_Expecter struct {
	mock *mock.Mock
}

func (_m *mocksubscriptionAware) EXPECT() *mocksubscriptionAware_Expecter {
	return &mocksubscriptionAware_Expecter{mock: &_m.Mock}
}

// ActiveSubscriptionCount provides a mock function for the type mocksubscriptionAware
func (_mock *mocksubscriptionAware) ActiveSubscriptionCount() int {
	ret := _mock.Called()

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

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

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

// ActiveSubscriptionCount is a helper method to define mock.On call
func (_e *mocksubscriptionAware_Expecter) ActiveSubscriptionCount() *mocksubscriptionAware_ActiveSubscriptionCount_Call {
	return &mocksubscriptionAware_ActiveSubscriptionCount_Call{Call: _e.mock.On("ActiveSubscriptionCount")}
}

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

func (_c *mocksubscriptionAware_ActiveSubscriptionCount_Call) Return(n int) *mocksubscriptionAware_ActiveSubscriptionCount_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *mocksubscriptionAware_ActiveSubscriptionCount_Call) RunAndReturn(run func() int) *mocksubscriptionAware_ActiveSubscriptionCount_Call {
	_c.Call.Return(run)
	return _c
}

// newMocktracedPlcConnection creates a new instance of mocktracedPlcConnection. 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 newMocktracedPlcConnection(t interface {
	mock.TestingT
	Cleanup(func())
}) *mocktracedPlcConnection {
	mock := &mocktracedPlcConnection{}
	mock.Mock.Test(t)

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

	return mock
}

// mocktracedPlcConnection is an autogenerated mock type for the tracedPlcConnection type
type mocktracedPlcConnection struct {
	mock.Mock
}

type mocktracedPlcConnection_Expecter struct {
	mock *mock.Mock
}

func (_m *mocktracedPlcConnection) EXPECT() *mocktracedPlcConnection_Expecter {
	return &mocktracedPlcConnection_Expecter{mock: &_m.Mock}
}

// BrowseRequestBuilder provides a mock function for the type mocktracedPlcConnection
func (_mock *mocktracedPlcConnection) BrowseRequestBuilder() model.PlcBrowseRequestBuilder {
	ret := _mock.Called()

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

	var r0 model.PlcBrowseRequestBuilder
	if returnFunc, ok := ret.Get(0).(func() model.PlcBrowseRequestBuilder); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(model.PlcBrowseRequestBuilder)
		}
	}
	return r0
}

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

// BrowseRequestBuilder is a helper method to define mock.On call
func (_e *mocktracedPlcConnection_Expecter) BrowseRequestBuilder() *mocktracedPlcConnection_BrowseRequestBuilder_Call {
	return &mocktracedPlcConnection_BrowseRequestBuilder_Call{Call: _e.mock.On("BrowseRequestBuilder")}
}

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

func (_c *mocktracedPlcConnection_BrowseRequestBuilder_Call) Return(plcBrowseRequestBuilder model.PlcBrowseRequestBuilder) *mocktracedPlcConnection_BrowseRequestBuilder_Call {
	_c.Call.Return(plcBrowseRequestBuilder)
	return _c
}

func (_c *mocktracedPlcConnection_BrowseRequestBuilder_Call) RunAndReturn(run func() model.PlcBrowseRequestBuilder) *mocktracedPlcConnection_BrowseRequestBuilder_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

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

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

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

// Connect provides a mock function for the type mocktracedPlcConnection
func (_mock *mocktracedPlcConnection) Connect(ctx context.Context) error {
	ret := _mock.Called(ctx)

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

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

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

// Connect is a helper method to define mock.On call
//   - ctx context.Context
func (_e *mocktracedPlcConnection_Expecter) Connect(ctx any) *mocktracedPlcConnection_Connect_Call {
	return &mocktracedPlcConnection_Connect_Call{Call: _e.mock.On("Connect", ctx)}
}

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

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

func (_c *mocktracedPlcConnection_Connect_Call) RunAndReturn(run func(ctx context.Context) error) *mocktracedPlcConnection_Connect_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// GetConnectionId is a helper method to define mock.On call
func (_e *mocktracedPlcConnection_Expecter) GetConnectionId() *mocktracedPlcConnection_GetConnectionId_Call {
	return &mocktracedPlcConnection_GetConnectionId_Call{Call: _e.mock.On("GetConnectionId")}
}

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

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

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

// GetMetadata provides a mock function for the type mocktracedPlcConnection
func (_mock *mocktracedPlcConnection) GetMetadata() model.PlcConnectionMetadata {
	ret := _mock.Called()

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

	var r0 model.PlcConnectionMetadata
	if returnFunc, ok := ret.Get(0).(func() model.PlcConnectionMetadata); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(model.PlcConnectionMetadata)
		}
	}
	return r0
}

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

// GetMetadata is a helper method to define mock.On call
func (_e *mocktracedPlcConnection_Expecter) GetMetadata() *mocktracedPlcConnection_GetMetadata_Call {
	return &mocktracedPlcConnection_GetMetadata_Call{Call: _e.mock.On("GetMetadata")}
}

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

func (_c *mocktracedPlcConnection_GetMetadata_Call) Return(plcConnectionMetadata model.PlcConnectionMetadata) *mocktracedPlcConnection_GetMetadata_Call {
	_c.Call.Return(plcConnectionMetadata)
	return _c
}

func (_c *mocktracedPlcConnection_GetMetadata_Call) RunAndReturn(run func() model.PlcConnectionMetadata) *mocktracedPlcConnection_GetMetadata_Call {
	_c.Call.Return(run)
	return _c
}

// GetTracer provides a mock function for the type mocktracedPlcConnection
func (_mock *mocktracedPlcConnection) GetTracer() tracer.Tracer {
	ret := _mock.Called()

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

	var r0 tracer.Tracer
	if returnFunc, ok := ret.Get(0).(func() tracer.Tracer); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(tracer.Tracer)
		}
	}
	return r0
}

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

// GetTracer is a helper method to define mock.On call
func (_e *mocktracedPlcConnection_Expecter) GetTracer() *mocktracedPlcConnection_GetTracer_Call {
	return &mocktracedPlcConnection_GetTracer_Call{Call: _e.mock.On("GetTracer")}
}

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

func (_c *mocktracedPlcConnection_GetTracer_Call) Return(tracer1 tracer.Tracer) *mocktracedPlcConnection_GetTracer_Call {
	_c.Call.Return(tracer1)
	return _c
}

func (_c *mocktracedPlcConnection_GetTracer_Call) RunAndReturn(run func() tracer.Tracer) *mocktracedPlcConnection_GetTracer_Call {
	_c.Call.Return(run)
	return _c
}

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

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

// Invalidate is a helper method to define mock.On call
func (_e *mocktracedPlcConnection_Expecter) Invalidate() *mocktracedPlcConnection_Invalidate_Call {
	return &mocktracedPlcConnection_Invalidate_Call{Call: _e.mock.On("Invalidate")}
}

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

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

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

// IsConnected provides a mock function for the type mocktracedPlcConnection
func (_mock *mocktracedPlcConnection) IsConnected() bool {
	ret := _mock.Called()

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

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

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

// IsConnected is a helper method to define mock.On call
func (_e *mocktracedPlcConnection_Expecter) IsConnected() *mocktracedPlcConnection_IsConnected_Call {
	return &mocktracedPlcConnection_IsConnected_Call{Call: _e.mock.On("IsConnected")}
}

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

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

func (_c *mocktracedPlcConnection_IsConnected_Call) RunAndReturn(run func() bool) *mocktracedPlcConnection_IsConnected_Call {
	_c.Call.Return(run)
	return _c
}

// IsTraceEnabled provides a mock function for the type mocktracedPlcConnection
func (_mock *mocktracedPlcConnection) IsTraceEnabled() bool {
	ret := _mock.Called()

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

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

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

// IsTraceEnabled is a helper method to define mock.On call
func (_e *mocktracedPlcConnection_Expecter) IsTraceEnabled() *mocktracedPlcConnection_IsTraceEnabled_Call {
	return &mocktracedPlcConnection_IsTraceEnabled_Call{Call: _e.mock.On("IsTraceEnabled")}
}

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

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

func (_c *mocktracedPlcConnection_IsTraceEnabled_Call) RunAndReturn(run func() bool) *mocktracedPlcConnection_IsTraceEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// Ping provides a mock function for the type mocktracedPlcConnection
func (_mock *mocktracedPlcConnection) Ping(ctx context.Context) error {
	ret := _mock.Called(ctx)

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

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

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

// Ping is a helper method to define mock.On call
//   - ctx context.Context
func (_e *mocktracedPlcConnection_Expecter) Ping(ctx any) *mocktracedPlcConnection_Ping_Call {
	return &mocktracedPlcConnection_Ping_Call{Call: _e.mock.On("Ping", ctx)}
}

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

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

func (_c *mocktracedPlcConnection_Ping_Call) RunAndReturn(run func(ctx context.Context) error) *mocktracedPlcConnection_Ping_Call {
	_c.Call.Return(run)
	return _c
}

// ReadRequestBuilder provides a mock function for the type mocktracedPlcConnection
func (_mock *mocktracedPlcConnection) ReadRequestBuilder() model.PlcReadRequestBuilder {
	ret := _mock.Called()

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

	var r0 model.PlcReadRequestBuilder
	if returnFunc, ok := ret.Get(0).(func() model.PlcReadRequestBuilder); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(model.PlcReadRequestBuilder)
		}
	}
	return r0
}

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

// ReadRequestBuilder is a helper method to define mock.On call
func (_e *mocktracedPlcConnection_Expecter) ReadRequestBuilder() *mocktracedPlcConnection_ReadRequestBuilder_Call {
	return &mocktracedPlcConnection_ReadRequestBuilder_Call{Call: _e.mock.On("ReadRequestBuilder")}
}

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

func (_c *mocktracedPlcConnection_ReadRequestBuilder_Call) Return(plcReadRequestBuilder model.PlcReadRequestBuilder) *mocktracedPlcConnection_ReadRequestBuilder_Call {
	_c.Call.Return(plcReadRequestBuilder)
	return _c
}

func (_c *mocktracedPlcConnection_ReadRequestBuilder_Call) RunAndReturn(run func() model.PlcReadRequestBuilder) *mocktracedPlcConnection_ReadRequestBuilder_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// String is a helper method to define mock.On call
func (_e *mocktracedPlcConnection_Expecter) String() *mocktracedPlcConnection_String_Call {
	return &mocktracedPlcConnection_String_Call{Call: _e.mock.On("String")}
}

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

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

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

// SubscriptionRequestBuilder provides a mock function for the type mocktracedPlcConnection
func (_mock *mocktracedPlcConnection) SubscriptionRequestBuilder() model.PlcSubscriptionRequestBuilder {
	ret := _mock.Called()

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

	var r0 model.PlcSubscriptionRequestBuilder
	if returnFunc, ok := ret.Get(0).(func() model.PlcSubscriptionRequestBuilder); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(model.PlcSubscriptionRequestBuilder)
		}
	}
	return r0
}

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

// SubscriptionRequestBuilder is a helper method to define mock.On call
func (_e *mocktracedPlcConnection_Expecter) SubscriptionRequestBuilder() *mocktracedPlcConnection_SubscriptionRequestBuilder_Call {
	return &mocktracedPlcConnection_SubscriptionRequestBuilder_Call{Call: _e.mock.On("SubscriptionRequestBuilder")}
}

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

func (_c *mocktracedPlcConnection_SubscriptionRequestBuilder_Call) Return(plcSubscriptionRequestBuilder model.PlcSubscriptionRequestBuilder) *mocktracedPlcConnection_SubscriptionRequestBuilder_Call {
	_c.Call.Return(plcSubscriptionRequestBuilder)
	return _c
}

func (_c *mocktracedPlcConnection_SubscriptionRequestBuilder_Call) RunAndReturn(run func() model.PlcSubscriptionRequestBuilder) *mocktracedPlcConnection_SubscriptionRequestBuilder_Call {
	_c.Call.Return(run)
	return _c
}

// UnsubscriptionRequestBuilder provides a mock function for the type mocktracedPlcConnection
func (_mock *mocktracedPlcConnection) UnsubscriptionRequestBuilder() model.PlcUnsubscriptionRequestBuilder {
	ret := _mock.Called()

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

	var r0 model.PlcUnsubscriptionRequestBuilder
	if returnFunc, ok := ret.Get(0).(func() model.PlcUnsubscriptionRequestBuilder); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(model.PlcUnsubscriptionRequestBuilder)
		}
	}
	return r0
}

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

// UnsubscriptionRequestBuilder is a helper method to define mock.On call
func (_e *mocktracedPlcConnection_Expecter) UnsubscriptionRequestBuilder() *mocktracedPlcConnection_UnsubscriptionRequestBuilder_Call {
	return &mocktracedPlcConnection_UnsubscriptionRequestBuilder_Call{Call: _e.mock.On("UnsubscriptionRequestBuilder")}
}

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

func (_c *mocktracedPlcConnection_UnsubscriptionRequestBuilder_Call) Return(plcUnsubscriptionRequestBuilder model.PlcUnsubscriptionRequestBuilder) *mocktracedPlcConnection_UnsubscriptionRequestBuilder_Call {
	_c.Call.Return(plcUnsubscriptionRequestBuilder)
	return _c
}

func (_c *mocktracedPlcConnection_UnsubscriptionRequestBuilder_Call) RunAndReturn(run func() model.PlcUnsubscriptionRequestBuilder) *mocktracedPlcConnection_UnsubscriptionRequestBuilder_Call {
	_c.Call.Return(run)
	return _c
}

// WriteRequestBuilder provides a mock function for the type mocktracedPlcConnection
func (_mock *mocktracedPlcConnection) WriteRequestBuilder() model.PlcWriteRequestBuilder {
	ret := _mock.Called()

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

	var r0 model.PlcWriteRequestBuilder
	if returnFunc, ok := ret.Get(0).(func() model.PlcWriteRequestBuilder); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(model.PlcWriteRequestBuilder)
		}
	}
	return r0
}

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

// WriteRequestBuilder is a helper method to define mock.On call
func (_e *mocktracedPlcConnection_Expecter) WriteRequestBuilder() *mocktracedPlcConnection_WriteRequestBuilder_Call {
	return &mocktracedPlcConnection_WriteRequestBuilder_Call{Call: _e.mock.On("WriteRequestBuilder")}
}

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

func (_c *mocktracedPlcConnection_WriteRequestBuilder_Call) Return(plcWriteRequestBuilder model.PlcWriteRequestBuilder) *mocktracedPlcConnection_WriteRequestBuilder_Call {
	_c.Call.Return(plcWriteRequestBuilder)
	return _c
}

func (_c *mocktracedPlcConnection_WriteRequestBuilder_Call) RunAndReturn(run func() model.PlcWriteRequestBuilder) *mocktracedPlcConnection_WriteRequestBuilder_Call {
	_c.Call.Return(run)
	return _c
}