func (_m *TaskExecutionContext) PluginStateReader() core.PluginStateReader {
	ret := _m.Called()
	var r0 core.PluginStateReader
	if rf, ok := ret.Get(0).(func() core.PluginStateReader); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(core.PluginStateReader)
		}
	}
	return r0
}
PluginStateReader provides a mock function with given fields:
package mocks
import (
	catalog "github.com/flyteorg/flyteplugins/go/tasks/pluginmachinery/catalog"
	core "github.com/flyteorg/flyteplugins/go/tasks/pluginmachinery/core"
	io "github.com/flyteorg/flyteplugins/go/tasks/pluginmachinery/io"
	mock "github.com/stretchr/testify/mock"
	storage "github.com/flyteorg/flytestdlib/storage"
)
type TaskExecutionContext struct {
	mock.Mock
}
type TaskExecutionContext_Catalog struct {
	*mock.Call
}
func (_m TaskExecutionContext_Catalog) Return(_a0 catalog.AsyncClient) *TaskExecutionContext_Catalog {
	return &TaskExecutionContext_Catalog{Call: _m.Call.Return(_a0)}
}
func (_m *TaskExecutionContext) OnCatalog() *TaskExecutionContext_Catalog {
	c := _m.On("Catalog")
	return &TaskExecutionContext_Catalog{Call: c}
}
func (_m *TaskExecutionContext) OnCatalogMatch(matchers ...interface{}) *TaskExecutionContext_Catalog {
	c := _m.On("Catalog", matchers...)
	return &TaskExecutionContext_Catalog{Call: c}
}
func (_m *TaskExecutionContext) Catalog() catalog.AsyncClient {
	ret := _m.Called()
	var r0 catalog.AsyncClient
	if rf, ok := ret.Get(0).(func() catalog.AsyncClient); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(catalog.AsyncClient)
		}
	}
	return r0
}
type TaskExecutionContext_DataStore struct {
	*mock.Call
}
func (_m TaskExecutionContext_DataStore) Return(_a0 *storage.DataStore) *TaskExecutionContext_DataStore {
	return &TaskExecutionContext_DataStore{Call: _m.Call.Return(_a0)}
}
func (_m *TaskExecutionContext) OnDataStore() *TaskExecutionContext_DataStore {
	c := _m.On("DataStore")
	return &TaskExecutionContext_DataStore{Call: c}
}
func (_m *TaskExecutionContext) OnDataStoreMatch(matchers ...interface{}) *TaskExecutionContext_DataStore {
	c := _m.On("DataStore", matchers...)
	return &TaskExecutionContext_DataStore{Call: c}
}
func (_m *TaskExecutionContext) DataStore() *storage.DataStore {
	ret := _m.Called()
	var r0 *storage.DataStore
	if rf, ok := ret.Get(0).(func() *storage.DataStore); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*storage.DataStore)
		}
	}
	return r0
}
type TaskExecutionContext_EventsRecorder struct {
	*mock.Call
}
func (_m TaskExecutionContext_EventsRecorder) Return(_a0 core.EventsRecorder) *TaskExecutionContext_EventsRecorder {
	return &TaskExecutionContext_EventsRecorder{Call: _m.Call.Return(_a0)}
}
func (_m *TaskExecutionContext) OnEventsRecorder() *TaskExecutionContext_EventsRecorder {
	c := _m.On("EventsRecorder")
	return &TaskExecutionContext_EventsRecorder{Call: c}
}
func (_m *TaskExecutionContext) OnEventsRecorderMatch(matchers ...interface{}) *TaskExecutionContext_EventsRecorder {
	c := _m.On("EventsRecorder", matchers...)
	return &TaskExecutionContext_EventsRecorder{Call: c}
}
func (_m *TaskExecutionContext) EventsRecorder() core.EventsRecorder {
	ret := _m.Called()
	var r0 core.EventsRecorder
	if rf, ok := ret.Get(0).(func() core.EventsRecorder); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(core.EventsRecorder)
		}
	}
	return r0
}
type TaskExecutionContext_InputReader struct {
	*mock.Call
}
func (_m TaskExecutionContext_InputReader) Return(_a0 io.InputReader) *TaskExecutionContext_InputReader {
	return &TaskExecutionContext_InputReader{Call: _m.Call.Return(_a0)}
}
func (_m *TaskExecutionContext) OnInputReader() *TaskExecutionContext_InputReader {
	c := _m.On("InputReader")
	return &TaskExecutionContext_InputReader{Call: c}
}
func (_m *TaskExecutionContext) OnInputReaderMatch(matchers ...interface{}) *TaskExecutionContext_InputReader {
	c := _m.On("InputReader", matchers...)
	return &TaskExecutionContext_InputReader{Call: c}
}
func (_m *TaskExecutionContext) InputReader() io.InputReader {
	ret := _m.Called()
	var r0 io.InputReader
	if rf, ok := ret.Get(0).(func() io.InputReader); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.InputReader)
		}
	}
	return r0
}
type TaskExecutionContext_MaxDatasetSizeBytes struct {
	*mock.Call
}
func (_m TaskExecutionContext_MaxDatasetSizeBytes) Return(_a0 int64) *TaskExecutionContext_MaxDatasetSizeBytes {
	return &TaskExecutionContext_MaxDatasetSizeBytes{Call: _m.Call.Return(_a0)}
}
func (_m *TaskExecutionContext) OnMaxDatasetSizeBytes() *TaskExecutionContext_MaxDatasetSizeBytes {
	c := _m.On("MaxDatasetSizeBytes")
	return &TaskExecutionContext_MaxDatasetSizeBytes{Call: c}
}
func (_m *TaskExecutionContext) OnMaxDatasetSizeBytesMatch(matchers ...interface{}) *TaskExecutionContext_MaxDatasetSizeBytes {
	c := _m.On("MaxDatasetSizeBytes", matchers...)
	return &TaskExecutionContext_MaxDatasetSizeBytes{Call: c}
}
func (_m *TaskExecutionContext) MaxDatasetSizeBytes() int64 {
	ret := _m.Called()
	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}
	return r0
}
type TaskExecutionContext_OutputWriter struct {
	*mock.Call
}
func (_m TaskExecutionContext_OutputWriter) Return(_a0 io.OutputWriter) *TaskExecutionContext_OutputWriter {
	return &TaskExecutionContext_OutputWriter{Call: _m.Call.Return(_a0)}
}
func (_m *TaskExecutionContext) OnOutputWriter() *TaskExecutionContext_OutputWriter {
	c := _m.On("OutputWriter")
	return &TaskExecutionContext_OutputWriter{Call: c}
}
func (_m *TaskExecutionContext) OnOutputWriterMatch(matchers ...interface{}) *TaskExecutionContext_OutputWriter {
	c := _m.On("OutputWriter", matchers...)
	return &TaskExecutionContext_OutputWriter{Call: c}
}
func (_m *TaskExecutionContext) OutputWriter() io.OutputWriter {
	ret := _m.Called()
	var r0 io.OutputWriter
	if rf, ok := ret.Get(0).(func() io.OutputWriter); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.OutputWriter)
		}
	}
	return r0
}
type TaskExecutionContext_PluginStateReader struct {
	*mock.Call
}
func (_m TaskExecutionContext_PluginStateReader) Return(_a0 core.PluginStateReader) *TaskExecutionContext_PluginStateReader {
	return &TaskExecutionContext_PluginStateReader{Call: _m.Call.Return(_a0)}
}
func (_m *TaskExecutionContext) OnPluginStateReader() *TaskExecutionContext_PluginStateReader {
	c := _m.On("PluginStateReader")
	return &TaskExecutionContext_PluginStateReader{Call: c}
}
func (_m *TaskExecutionContext) OnPluginStateReaderMatch(matchers ...interface{}) *TaskExecutionContext_PluginStateReader {
	c := _m.On("PluginStateReader", matchers...)
	return &TaskExecutionContext_PluginStateReader{Call: c}
}