github.com/kubeshop/testkube@v1.17.23/pkg/tcl/expressionstcl/mock_expression.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/kubeshop/testkube/pkg/tcl/expressionstcl (interfaces: Expression)

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

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockExpression is a mock of Expression interface.
type MockExpression struct {
	ctrl     *gomock.Controller
	recorder *MockExpressionMockRecorder
}

// MockExpressionMockRecorder is the mock recorder for MockExpression.
type MockExpressionMockRecorder struct {
	mock *MockExpression
}

// NewMockExpression creates a new mock instance.
func NewMockExpression(ctrl *gomock.Controller) *MockExpression {
	mock := &MockExpression{ctrl: ctrl}
	mock.recorder = &MockExpressionMockRecorder{mock}
	return mock
}

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

// Accessors mocks base method.
func (m *MockExpression) Accessors() map[string]struct{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Accessors")
	ret0, _ := ret[0].(map[string]struct{})
	return ret0
}

// Accessors indicates an expected call of Accessors.
func (mr *MockExpressionMockRecorder) Accessors() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Accessors", reflect.TypeOf((*MockExpression)(nil).Accessors))
}

// Functions mocks base method.
func (m *MockExpression) Functions() map[string]struct{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Functions")
	ret0, _ := ret[0].(map[string]struct{})
	return ret0
}

// Functions indicates an expected call of Functions.
func (mr *MockExpressionMockRecorder) Functions() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Functions", reflect.TypeOf((*MockExpression)(nil).Functions))
}

// Resolve mocks base method.
func (m *MockExpression) Resolve(arg0 ...Machine) (Expression, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Resolve", varargs...)
	ret0, _ := ret[0].(Expression)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Resolve indicates an expected call of Resolve.
func (mr *MockExpressionMockRecorder) Resolve(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockExpression)(nil).Resolve), arg0...)
}

// SafeResolve mocks base method.
func (m *MockExpression) SafeResolve(arg0 ...Machine) (Expression, bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SafeResolve", varargs...)
	ret0, _ := ret[0].(Expression)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SafeResolve indicates an expected call of SafeResolve.
func (mr *MockExpressionMockRecorder) SafeResolve(arg0 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SafeResolve", reflect.TypeOf((*MockExpression)(nil).SafeResolve), arg0...)
}

// SafeString mocks base method.
func (m *MockExpression) SafeString() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SafeString")
	ret0, _ := ret[0].(string)
	return ret0
}

// SafeString indicates an expected call of SafeString.
func (mr *MockExpressionMockRecorder) SafeString() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SafeString", reflect.TypeOf((*MockExpression)(nil).SafeString))
}

// Static mocks base method.
func (m *MockExpression) Static() StaticValue {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Static")
	ret0, _ := ret[0].(StaticValue)
	return ret0
}

// Static indicates an expected call of Static.
func (mr *MockExpressionMockRecorder) Static() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Static", reflect.TypeOf((*MockExpression)(nil).Static))
}

// String mocks base method.
func (m *MockExpression) String() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "String")
	ret0, _ := ret[0].(string)
	return ret0
}

// String indicates an expected call of String.
func (mr *MockExpressionMockRecorder) String() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "String", reflect.TypeOf((*MockExpression)(nil).String))
}

// Template mocks base method.
func (m *MockExpression) Template() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Template")
	ret0, _ := ret[0].(string)
	return ret0
}

// Template indicates an expected call of Template.
func (mr *MockExpressionMockRecorder) Template() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Template", reflect.TypeOf((*MockExpression)(nil).Template))
}

// Type mocks base method.
func (m *MockExpression) Type() Type {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type")
	ret0, _ := ret[0].(Type)
	return ret0
}

// Type indicates an expected call of Type.
func (mr *MockExpressionMockRecorder) Type() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockExpression)(nil).Type))
}