mock_environment.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/ARM-software/golang-utils/utils/environment (interfaces: IEnvironmentVariable,IEnvironment)

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

import (
	user "os/user"
	reflect "reflect"

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

	environment "github.com/ARM-software/golang-utils/utils/environment"
	filesystem "github.com/ARM-software/golang-utils/utils/filesystem"
)

// MockIEnvironmentVariable is a mock of IEnvironmentVariable interface.
type MockIEnvironmentVariable struct {
	ctrl     *gomock.Controller
	recorder *MockIEnvironmentVariableMockRecorder
}

// MockIEnvironmentVariableMockRecorder is the mock recorder for MockIEnvironmentVariable.
type MockIEnvironmentVariableMockRecorder struct {
	mock *MockIEnvironmentVariable
}

// NewMockIEnvironmentVariable creates a new mock instance.
func NewMockIEnvironmentVariable(ctrl *gomock.Controller) *MockIEnvironmentVariable {
	mock := &MockIEnvironmentVariable{ctrl: ctrl}
	mock.recorder = &MockIEnvironmentVariableMockRecorder{mock}
	return mock
}

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

// Equal mocks base method.
func (m *MockIEnvironmentVariable) Equal(arg0 environment.IEnvironmentVariable) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Equal", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

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

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

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

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

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

// MarshalText mocks base method.
func (m *MockIEnvironmentVariable) MarshalText() ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarshalText")
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// String mocks base method.
func (m *MockIEnvironmentVariable) 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 *MockIEnvironmentVariableMockRecorder) String() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "String", reflect.TypeOf((*MockIEnvironmentVariable)(nil).String))
}

// UnmarshalText mocks base method.
func (m *MockIEnvironmentVariable) UnmarshalText(arg0 []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnmarshalText", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// MockIEnvironment is a mock of IEnvironment interface.
type MockIEnvironment struct {
	ctrl     *gomock.Controller
	recorder *MockIEnvironmentMockRecorder
}

// MockIEnvironmentMockRecorder is the mock recorder for MockIEnvironment.
type MockIEnvironmentMockRecorder struct {
	mock *MockIEnvironment
}

// NewMockIEnvironment creates a new mock instance.
func NewMockIEnvironment(ctrl *gomock.Controller) *MockIEnvironment {
	mock := &MockIEnvironment{ctrl: ctrl}
	mock.recorder = &MockIEnvironmentMockRecorder{mock}
	return mock
}

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

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

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

// GetEnvironmentVariable mocks base method.
func (m *MockIEnvironment) GetEnvironmentVariable(arg0 string, arg1 ...string) (environment.IEnvironmentVariable, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetEnvironmentVariable", varargs...)
	ret0, _ := ret[0].(environment.IEnvironmentVariable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEnvironmentVariable indicates an expected call of GetEnvironmentVariable.
func (mr *MockIEnvironmentMockRecorder) GetEnvironmentVariable(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEnvironmentVariable", reflect.TypeOf((*MockIEnvironment)(nil).GetEnvironmentVariable), varargs...)
}

// GetEnvironmentVariables mocks base method.
func (m *MockIEnvironment) GetEnvironmentVariables(arg0 ...string) []environment.IEnvironmentVariable {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetEnvironmentVariables", varargs...)
	ret0, _ := ret[0].([]environment.IEnvironmentVariable)
	return ret0
}

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

// GetExpandedEnvironmentVariable mocks base method.
func (m *MockIEnvironment) GetExpandedEnvironmentVariable(arg0 string, arg1 ...string) (environment.IEnvironmentVariable, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetExpandedEnvironmentVariable", varargs...)
	ret0, _ := ret[0].(environment.IEnvironmentVariable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExpandedEnvironmentVariable indicates an expected call of GetExpandedEnvironmentVariable.
func (mr *MockIEnvironmentMockRecorder) GetExpandedEnvironmentVariable(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExpandedEnvironmentVariable", reflect.TypeOf((*MockIEnvironment)(nil).GetExpandedEnvironmentVariable), varargs...)
}

// GetExpandedEnvironmentVariables mocks base method.
func (m *MockIEnvironment) GetExpandedEnvironmentVariables(arg0 ...string) []environment.IEnvironmentVariable {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetExpandedEnvironmentVariables", varargs...)
	ret0, _ := ret[0].([]environment.IEnvironmentVariable)
	return ret0
}

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

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

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