diff --git a/pkg/symmetrix/metro.go b/pkg/symmetrix/metro.go
index 06e24a5b..46eeddcf 100644
--- a/pkg/symmetrix/metro.go
+++ b/pkg/symmetrix/metro.go
@@ -31,6 +31,13 @@ const (
 	failureTimeThreshold time.Duration = 2 * time.Minute
 )
 
+// RoundTripperInterface is an interface for http.RoundTripper
+//
+//go:generate mockgen -destination=mocks/roundtripper.go -package=mocks github.com/dell/csi-powermax/v2/pkg/symmetrix RoundTripperInterface
+type RoundTripperInterface interface {
+	http.RoundTripper
+}
+
 func init() {
 	metroClients = sync.Map{}
 }
diff --git a/pkg/symmetrix/metro_test.go b/pkg/symmetrix/metro_test.go
new file mode 100644
index 00000000..09548aee
--- /dev/null
+++ b/pkg/symmetrix/metro_test.go
@@ -0,0 +1,220 @@
+/*
+ Copyright © 2025 Dell Inc. or its subsidiaries. All Rights Reserved.
+
+ Licensed 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
+      http://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.
+*/
+
+package symmetrix
+
+import (
+	"errors"
+	"net/http"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/dell/csi-powermax/v2/pkg/symmetrix/mocks"
+	"github.com/golang/mock/gomock"
+)
+
+func TestMetroClient_healthHandler(t *testing.T) {
+	tests := []struct {
+		name           string
+		failureWeight  int
+		failureCount   int
+		lastFailure    time.Time
+		expectedCount  int
+		expectedActive string
+	}{
+		{
+			name:           "failure count below threshold",
+			failureWeight:  1,
+			failureCount:   1,
+			lastFailure:    time.Now().Add(-1 * time.Minute),
+			expectedCount:  2,
+			expectedActive: "primaryArray",
+		},
+		{
+			name:           "failure count at threshold",
+			failureWeight:  1,
+			failureCount:   failoverThereshold,
+			lastFailure:    time.Now().Add(-1 * time.Minute),
+			expectedCount:  6,
+			expectedActive: "primaryArray",
+		},
+		{
+			name:           "failure count above threshold",
+			failureWeight:  1,
+			failureCount:   failoverThereshold + 1,
+			lastFailure:    time.Now().Add(-1 * time.Minute),
+			expectedCount:  7,
+			expectedActive: "primaryArray",
+		},
+		{
+			name:           "last failure more than failure time threshold",
+			failureWeight:  1,
+			failureCount:   1,
+			lastFailure:    time.Now().Add(-2 * time.Minute),
+			expectedCount:  1,
+			expectedActive: "primaryArray",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := &metroClient{
+				primaryArray:   "primaryArray",
+				secondaryArray: "secondaryArray",
+				activeArray:    "primaryArray",
+				failureCount:   tt.failureCount,
+				lastFailure:    tt.lastFailure,
+			}
+
+			m.healthHandler(tt.failureWeight)
+
+			if m.failureCount != tt.expectedCount {
+				t.Errorf("expected failure count %d, but got %d", tt.expectedCount, m.failureCount)
+			}
+
+			if m.activeArray != tt.expectedActive {
+				t.Errorf("expected active array %s, but got %s", tt.expectedActive, m.activeArray)
+			}
+		})
+	}
+}
+
+func TestTransport_RoundTrip(t *testing.T) {
+	type args struct {
+		req *http.Request
+	}
+	tests := []struct {
+		name    string
+		wantRes *http.Response
+		wantErr bool
+		err     error
+	}{
+		{
+			name:    "Success",
+			wantRes: &http.Response{},
+			wantErr: false,
+		},
+		{
+			name:    "Expected error",
+			wantRes: &http.Response{},
+			err:     errors.New("error"),
+			wantErr: true,
+		},
+		{
+			name:    "Response code 401",
+			wantRes: &http.Response{StatusCode: 401},
+			wantErr: false,
+		},
+		{
+			name:    "Response code 500",
+			wantRes: &http.Response{StatusCode: 500},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := &metroClient{
+				primaryArray:   "primaryArray",
+				secondaryArray: "secondaryArray",
+				activeArray:    "primaryArray",
+				failureCount:   1,
+				lastFailure:    time.Now().Add(-1 * time.Minute),
+			}
+			roundTripper := mocks.NewMockRoundTripperInterface(gomock.NewController(t))
+			roundTripper.EXPECT().RoundTrip(&http.Request{}).Return(tt.wantRes, tt.err).AnyTimes()
+			tr := &transport{
+				roundTripper,
+				m.healthHandler,
+			}
+
+			gotRes, err := tr.RoundTrip(&http.Request{})
+			if (err != nil) != tt.wantErr {
+				t.Errorf("RoundTrip() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotRes, tt.wantRes) {
+				t.Errorf("RoundTrip() = %v, want %v", gotRes, tt.wantRes)
+			}
+		})
+	}
+}
+
+func TestMetroClient_getActiveArray(t *testing.T) {
+	tests := []struct {
+		name           string
+		failureWeight  int
+		failureCount   int
+		lastFailure    time.Time
+		expectedActive string
+		activeArray    string
+	}{
+		{
+			name:           "failure count below threshold",
+			failureWeight:  1,
+			failureCount:   1,
+			lastFailure:    time.Now().Add(-1 * time.Minute),
+			expectedActive: "primaryArray",
+			activeArray:    "primaryArray",
+		},
+		{
+			name:           "failure count at threshold",
+			failureWeight:  1,
+			failureCount:   failoverThereshold,
+			lastFailure:    time.Now().Add(-1 * time.Minute),
+			expectedActive: "secondaryArray",
+			activeArray:    "primaryArray",
+		},
+		{
+			name:           "failure count above threshold",
+			failureWeight:  1,
+			failureCount:   failoverThereshold + 1,
+			lastFailure:    time.Now().Add(-1 * time.Minute),
+			expectedActive: "secondaryArray",
+			activeArray:    "primaryArray",
+		},
+		{
+			name:           "last failure more than failure time threshold",
+			failureWeight:  1,
+			failureCount:   1,
+			lastFailure:    time.Now().Add(-2 * time.Minute),
+			expectedActive: "primaryArray",
+			activeArray:    "primaryArray",
+		},
+		{
+			name:           "failure count above threshold and active array was secondaryArray",
+			failureWeight:  1,
+			failureCount:   failoverThereshold + 1,
+			lastFailure:    time.Now().Add(-1 * time.Minute),
+			expectedActive: "primaryArray",
+			activeArray:    "secondaryArray",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := &metroClient{
+				primaryArray:   "primaryArray",
+				secondaryArray: "secondaryArray",
+				activeArray:    tt.activeArray,
+				failureCount:   tt.failureCount,
+				lastFailure:    tt.lastFailure,
+			}
+
+			if got := m.getActiveArray(); got != tt.expectedActive {
+				t.Errorf("getActiveArray() = %v, want %v", got, tt.expectedActive)
+			}
+		})
+	}
+}
diff --git a/pkg/symmetrix/mocks/pmaxclient.go b/pkg/symmetrix/mocks/pmaxclient.go
new file mode 100644
index 00000000..0a30fa83
--- /dev/null
+++ b/pkg/symmetrix/mocks/pmaxclient.go
@@ -0,0 +1,2209 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/dell/csi-powermax/v2/pkg/symmetrix (interfaces: PmaxClient)
+
+// Package mocks is a generated GoMock package.
+package mocks
+
+import (
+	context "context"
+	http "net/http"
+	reflect "reflect"
+
+	pmax "github.com/dell/gopowermax/v2"
+	v100 "github.com/dell/gopowermax/v2/types/v100"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockPmaxClient is a mock of PmaxClient interface.
+type MockPmaxClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockPmaxClientMockRecorder
+}
+
+// MockPmaxClientMockRecorder is the mock recorder for MockPmaxClient.
+type MockPmaxClientMockRecorder struct {
+	mock *MockPmaxClient
+}
+
+// NewMockPmaxClient creates a new mock instance.
+func NewMockPmaxClient(ctrl *gomock.Controller) *MockPmaxClient {
+	mock := &MockPmaxClient{ctrl: ctrl}
+	mock.recorder = &MockPmaxClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockPmaxClient) EXPECT() *MockPmaxClientMockRecorder {
+	return m.recorder
+}
+
+// AddVolumesToProtectedStorageGroup mocks base method.
+func (m *MockPmaxClient) AddVolumesToProtectedStorageGroup(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 bool, arg6 ...string) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2, arg3, arg4, arg5}
+	for _, a := range arg6 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AddVolumesToProtectedStorageGroup", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AddVolumesToProtectedStorageGroup indicates an expected call of AddVolumesToProtectedStorageGroup.
+func (mr *MockPmaxClientMockRecorder) AddVolumesToProtectedStorageGroup(arg0, arg1, arg2, arg3, arg4, arg5 interface{}, arg6 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5}, arg6...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddVolumesToProtectedStorageGroup", reflect.TypeOf((*MockPmaxClient)(nil).AddVolumesToProtectedStorageGroup), varargs...)
+}
+
+// AddVolumesToStorageGroup mocks base method.
+func (m *MockPmaxClient) AddVolumesToStorageGroup(arg0 context.Context, arg1, arg2 string, arg3 bool, arg4 ...string) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2, arg3}
+	for _, a := range arg4 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AddVolumesToStorageGroup", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AddVolumesToStorageGroup indicates an expected call of AddVolumesToStorageGroup.
+func (mr *MockPmaxClientMockRecorder) AddVolumesToStorageGroup(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddVolumesToStorageGroup", reflect.TypeOf((*MockPmaxClient)(nil).AddVolumesToStorageGroup), varargs...)
+}
+
+// AddVolumesToStorageGroupS mocks base method.
+func (m *MockPmaxClient) AddVolumesToStorageGroupS(arg0 context.Context, arg1, arg2 string, arg3 bool, arg4 ...string) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2, arg3}
+	for _, a := range arg4 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AddVolumesToStorageGroupS", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AddVolumesToStorageGroupS indicates an expected call of AddVolumesToStorageGroupS.
+func (mr *MockPmaxClientMockRecorder) AddVolumesToStorageGroupS(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddVolumesToStorageGroupS", reflect.TypeOf((*MockPmaxClient)(nil).AddVolumesToStorageGroupS), varargs...)
+}
+
+// Authenticate mocks base method.
+func (m *MockPmaxClient) Authenticate(arg0 context.Context, arg1 *pmax.ConfigConnect) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Authenticate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Authenticate indicates an expected call of Authenticate.
+func (mr *MockPmaxClientMockRecorder) Authenticate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Authenticate", reflect.TypeOf((*MockPmaxClient)(nil).Authenticate), arg0, arg1)
+}
+
+// CreateFileSystem mocks base method.
+func (m *MockPmaxClient) CreateFileSystem(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 int64) (*v100.FileSystem, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateFileSystem", arg0, arg1, arg2, arg3, arg4, arg5)
+	ret0, _ := ret[0].(*v100.FileSystem)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateFileSystem indicates an expected call of CreateFileSystem.
+func (mr *MockPmaxClientMockRecorder) CreateFileSystem(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFileSystem", reflect.TypeOf((*MockPmaxClient)(nil).CreateFileSystem), arg0, arg1, arg2, arg3, arg4, arg5)
+}
+
+// CreateHost mocks base method.
+func (m *MockPmaxClient) CreateHost(arg0 context.Context, arg1, arg2 string, arg3 []string, arg4 *v100.HostFlags) (*v100.Host, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateHost", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*v100.Host)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateHost indicates an expected call of CreateHost.
+func (mr *MockPmaxClientMockRecorder) CreateHost(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHost", reflect.TypeOf((*MockPmaxClient)(nil).CreateHost), arg0, arg1, arg2, arg3, arg4)
+}
+
+// CreateHostGroup mocks base method.
+func (m *MockPmaxClient) CreateHostGroup(arg0 context.Context, arg1, arg2 string, arg3 []string, arg4 *v100.HostFlags) (*v100.HostGroup, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateHostGroup", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*v100.HostGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateHostGroup indicates an expected call of CreateHostGroup.
+func (mr *MockPmaxClientMockRecorder) CreateHostGroup(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHostGroup", reflect.TypeOf((*MockPmaxClient)(nil).CreateHostGroup), arg0, arg1, arg2, arg3, arg4)
+}
+
+// CreateMaskingView mocks base method.
+func (m *MockPmaxClient) CreateMaskingView(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 bool, arg6 string) (*v100.MaskingView, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateMaskingView", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+	ret0, _ := ret[0].(*v100.MaskingView)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateMaskingView indicates an expected call of CreateMaskingView.
+func (mr *MockPmaxClientMockRecorder) CreateMaskingView(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMaskingView", reflect.TypeOf((*MockPmaxClient)(nil).CreateMaskingView), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+}
+
+// CreateMigrationEnvironment mocks base method.
+func (m *MockPmaxClient) CreateMigrationEnvironment(arg0 context.Context, arg1, arg2 string) (*v100.MigrationEnv, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateMigrationEnvironment", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.MigrationEnv)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateMigrationEnvironment indicates an expected call of CreateMigrationEnvironment.
+func (mr *MockPmaxClientMockRecorder) CreateMigrationEnvironment(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMigrationEnvironment", reflect.TypeOf((*MockPmaxClient)(nil).CreateMigrationEnvironment), arg0, arg1, arg2)
+}
+
+// CreateNFSExport mocks base method.
+func (m *MockPmaxClient) CreateNFSExport(arg0 context.Context, arg1 string, arg2 v100.CreateNFSExport) (*v100.NFSExport, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateNFSExport", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.NFSExport)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateNFSExport indicates an expected call of CreateNFSExport.
+func (mr *MockPmaxClientMockRecorder) CreateNFSExport(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNFSExport", reflect.TypeOf((*MockPmaxClient)(nil).CreateNFSExport), arg0, arg1, arg2)
+}
+
+// CreatePortGroup mocks base method.
+func (m *MockPmaxClient) CreatePortGroup(arg0 context.Context, arg1, arg2 string, arg3 []v100.PortKey, arg4 string) (*v100.PortGroup, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreatePortGroup", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*v100.PortGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreatePortGroup indicates an expected call of CreatePortGroup.
+func (mr *MockPmaxClientMockRecorder) CreatePortGroup(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePortGroup", reflect.TypeOf((*MockPmaxClient)(nil).CreatePortGroup), arg0, arg1, arg2, arg3, arg4)
+}
+
+// CreateRDFPair mocks base method.
+func (m *MockPmaxClient) CreateRDFPair(arg0 context.Context, arg1, arg2, arg3, arg4, arg5 string, arg6, arg7 bool) (*v100.RDFDevicePairList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateRDFPair", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+	ret0, _ := ret[0].(*v100.RDFDevicePairList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateRDFPair indicates an expected call of CreateRDFPair.
+func (mr *MockPmaxClientMockRecorder) CreateRDFPair(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRDFPair", reflect.TypeOf((*MockPmaxClient)(nil).CreateRDFPair), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+}
+
+// CreateSGMigration mocks base method.
+func (m *MockPmaxClient) CreateSGMigration(arg0 context.Context, arg1, arg2, arg3 string) (*v100.MigrationSession, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateSGMigration", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.MigrationSession)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateSGMigration indicates an expected call of CreateSGMigration.
+func (mr *MockPmaxClientMockRecorder) CreateSGMigration(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSGMigration", reflect.TypeOf((*MockPmaxClient)(nil).CreateSGMigration), arg0, arg1, arg2, arg3)
+}
+
+// CreateSGReplica mocks base method.
+func (m *MockPmaxClient) CreateSGReplica(arg0 context.Context, arg1, arg2, arg3, arg4, arg5, arg6, arg7 string, arg8 bool) (*v100.SGRDFInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateSGReplica", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+	ret0, _ := ret[0].(*v100.SGRDFInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateSGReplica indicates an expected call of CreateSGReplica.
+func (mr *MockPmaxClientMockRecorder) CreateSGReplica(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSGReplica", reflect.TypeOf((*MockPmaxClient)(nil).CreateSGReplica), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+}
+
+// CreateSnapshot mocks base method.
+func (m *MockPmaxClient) CreateSnapshot(arg0 context.Context, arg1, arg2 string, arg3 []v100.VolumeList, arg4 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateSnapshot", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CreateSnapshot indicates an expected call of CreateSnapshot.
+func (mr *MockPmaxClientMockRecorder) CreateSnapshot(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockPmaxClient)(nil).CreateSnapshot), arg0, arg1, arg2, arg3, arg4)
+}
+
+// CreateSnapshotPolicy mocks base method.
+func (m *MockPmaxClient) CreateSnapshotPolicy(arg0 context.Context, arg1, arg2, arg3 string, arg4 int32, arg5, arg6 int64, arg7 map[string]interface{}) (*v100.SnapshotPolicy, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateSnapshotPolicy", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+	ret0, _ := ret[0].(*v100.SnapshotPolicy)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateSnapshotPolicy indicates an expected call of CreateSnapshotPolicy.
+func (mr *MockPmaxClientMockRecorder) CreateSnapshotPolicy(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotPolicy", reflect.TypeOf((*MockPmaxClient)(nil).CreateSnapshotPolicy), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+}
+
+// CreateStorageGroup mocks base method.
+func (m *MockPmaxClient) CreateStorageGroup(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 bool, arg6 map[string]interface{}) (*v100.StorageGroup, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateStorageGroup", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+	ret0, _ := ret[0].(*v100.StorageGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateStorageGroup indicates an expected call of CreateStorageGroup.
+func (mr *MockPmaxClientMockRecorder) CreateStorageGroup(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStorageGroup", reflect.TypeOf((*MockPmaxClient)(nil).CreateStorageGroup), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+}
+
+// CreateStorageGroupSnapshot mocks base method.
+func (m *MockPmaxClient) CreateStorageGroupSnapshot(arg0 context.Context, arg1, arg2 string, arg3 *v100.CreateStorageGroupSnapshot) (*v100.StorageGroupSnap, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateStorageGroupSnapshot", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.StorageGroupSnap)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateStorageGroupSnapshot indicates an expected call of CreateStorageGroupSnapshot.
+func (mr *MockPmaxClientMockRecorder) CreateStorageGroupSnapshot(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStorageGroupSnapshot", reflect.TypeOf((*MockPmaxClient)(nil).CreateStorageGroupSnapshot), arg0, arg1, arg2, arg3)
+}
+
+// CreateVolumeInProtectedStorageGroupS mocks base method.
+func (m *MockPmaxClient) CreateVolumeInProtectedStorageGroupS(arg0 context.Context, arg1, arg2, arg3, arg4, arg5 string, arg6 interface{}, arg7 map[string]interface{}, arg8 ...http.Header) (*v100.Volume, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7}
+	for _, a := range arg8 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateVolumeInProtectedStorageGroupS", varargs...)
+	ret0, _ := ret[0].(*v100.Volume)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateVolumeInProtectedStorageGroupS indicates an expected call of CreateVolumeInProtectedStorageGroupS.
+func (mr *MockPmaxClientMockRecorder) CreateVolumeInProtectedStorageGroupS(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 interface{}, arg8 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7}, arg8...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolumeInProtectedStorageGroupS", reflect.TypeOf((*MockPmaxClient)(nil).CreateVolumeInProtectedStorageGroupS), varargs...)
+}
+
+// CreateVolumeInStorageGroup mocks base method.
+func (m *MockPmaxClient) CreateVolumeInStorageGroup(arg0 context.Context, arg1, arg2, arg3 string, arg4 interface{}, arg5 map[string]interface{}) (*v100.Volume, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateVolumeInStorageGroup", arg0, arg1, arg2, arg3, arg4, arg5)
+	ret0, _ := ret[0].(*v100.Volume)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateVolumeInStorageGroup indicates an expected call of CreateVolumeInStorageGroup.
+func (mr *MockPmaxClientMockRecorder) CreateVolumeInStorageGroup(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolumeInStorageGroup", reflect.TypeOf((*MockPmaxClient)(nil).CreateVolumeInStorageGroup), arg0, arg1, arg2, arg3, arg4, arg5)
+}
+
+// CreateVolumeInStorageGroupS mocks base method.
+func (m *MockPmaxClient) CreateVolumeInStorageGroupS(arg0 context.Context, arg1, arg2, arg3 string, arg4 interface{}, arg5 map[string]interface{}, arg6 ...http.Header) (*v100.Volume, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2, arg3, arg4, arg5}
+	for _, a := range arg6 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateVolumeInStorageGroupS", varargs...)
+	ret0, _ := ret[0].(*v100.Volume)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateVolumeInStorageGroupS indicates an expected call of CreateVolumeInStorageGroupS.
+func (mr *MockPmaxClientMockRecorder) CreateVolumeInStorageGroupS(arg0, arg1, arg2, arg3, arg4, arg5 interface{}, arg6 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5}, arg6...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolumeInStorageGroupS", reflect.TypeOf((*MockPmaxClient)(nil).CreateVolumeInStorageGroupS), varargs...)
+}
+
+// DeleteFileSystem mocks base method.
+func (m *MockPmaxClient) DeleteFileSystem(arg0 context.Context, arg1, arg2 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteFileSystem", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteFileSystem indicates an expected call of DeleteFileSystem.
+func (mr *MockPmaxClientMockRecorder) DeleteFileSystem(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFileSystem", reflect.TypeOf((*MockPmaxClient)(nil).DeleteFileSystem), arg0, arg1, arg2)
+}
+
+// DeleteHost mocks base method.
+func (m *MockPmaxClient) DeleteHost(arg0 context.Context, arg1, arg2 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteHost", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteHost indicates an expected call of DeleteHost.
+func (mr *MockPmaxClientMockRecorder) DeleteHost(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHost", reflect.TypeOf((*MockPmaxClient)(nil).DeleteHost), arg0, arg1, arg2)
+}
+
+// DeleteHostGroup mocks base method.
+func (m *MockPmaxClient) DeleteHostGroup(arg0 context.Context, arg1, arg2 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteHostGroup", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteHostGroup indicates an expected call of DeleteHostGroup.
+func (mr *MockPmaxClientMockRecorder) DeleteHostGroup(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHostGroup", reflect.TypeOf((*MockPmaxClient)(nil).DeleteHostGroup), arg0, arg1, arg2)
+}
+
+// DeleteMaskingView mocks base method.
+func (m *MockPmaxClient) DeleteMaskingView(arg0 context.Context, arg1, arg2 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteMaskingView", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteMaskingView indicates an expected call of DeleteMaskingView.
+func (mr *MockPmaxClientMockRecorder) DeleteMaskingView(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMaskingView", reflect.TypeOf((*MockPmaxClient)(nil).DeleteMaskingView), arg0, arg1, arg2)
+}
+
+// DeleteMigrationEnvironment mocks base method.
+func (m *MockPmaxClient) DeleteMigrationEnvironment(arg0 context.Context, arg1, arg2 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteMigrationEnvironment", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteMigrationEnvironment indicates an expected call of DeleteMigrationEnvironment.
+func (mr *MockPmaxClientMockRecorder) DeleteMigrationEnvironment(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMigrationEnvironment", reflect.TypeOf((*MockPmaxClient)(nil).DeleteMigrationEnvironment), arg0, arg1, arg2)
+}
+
+// DeleteNASServer mocks base method.
+func (m *MockPmaxClient) DeleteNASServer(arg0 context.Context, arg1, arg2 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteNASServer", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteNASServer indicates an expected call of DeleteNASServer.
+func (mr *MockPmaxClientMockRecorder) DeleteNASServer(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNASServer", reflect.TypeOf((*MockPmaxClient)(nil).DeleteNASServer), arg0, arg1, arg2)
+}
+
+// DeleteNFSExport mocks base method.
+func (m *MockPmaxClient) DeleteNFSExport(arg0 context.Context, arg1, arg2 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteNFSExport", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteNFSExport indicates an expected call of DeleteNFSExport.
+func (mr *MockPmaxClientMockRecorder) DeleteNFSExport(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNFSExport", reflect.TypeOf((*MockPmaxClient)(nil).DeleteNFSExport), arg0, arg1, arg2)
+}
+
+// DeletePortGroup mocks base method.
+func (m *MockPmaxClient) DeletePortGroup(arg0 context.Context, arg1, arg2 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeletePortGroup", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeletePortGroup indicates an expected call of DeletePortGroup.
+func (mr *MockPmaxClientMockRecorder) DeletePortGroup(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePortGroup", reflect.TypeOf((*MockPmaxClient)(nil).DeletePortGroup), arg0, arg1, arg2)
+}
+
+// DeleteSnapshot mocks base method.
+func (m *MockPmaxClient) DeleteSnapshot(arg0 context.Context, arg1, arg2 string, arg3 []v100.VolumeList, arg4 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteSnapshot", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteSnapshot indicates an expected call of DeleteSnapshot.
+func (mr *MockPmaxClientMockRecorder) DeleteSnapshot(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockPmaxClient)(nil).DeleteSnapshot), arg0, arg1, arg2, arg3, arg4)
+}
+
+// DeleteSnapshotPolicy mocks base method.
+func (m *MockPmaxClient) DeleteSnapshotPolicy(arg0 context.Context, arg1, arg2 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteSnapshotPolicy", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteSnapshotPolicy indicates an expected call of DeleteSnapshotPolicy.
+func (mr *MockPmaxClientMockRecorder) DeleteSnapshotPolicy(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotPolicy", reflect.TypeOf((*MockPmaxClient)(nil).DeleteSnapshotPolicy), arg0, arg1, arg2)
+}
+
+// DeleteSnapshotS mocks base method.
+func (m *MockPmaxClient) DeleteSnapshotS(arg0 context.Context, arg1, arg2 string, arg3 []v100.VolumeList, arg4 int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteSnapshotS", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteSnapshotS indicates an expected call of DeleteSnapshotS.
+func (mr *MockPmaxClientMockRecorder) DeleteSnapshotS(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotS", reflect.TypeOf((*MockPmaxClient)(nil).DeleteSnapshotS), arg0, arg1, arg2, arg3, arg4)
+}
+
+// DeleteStorageGroup mocks base method.
+func (m *MockPmaxClient) DeleteStorageGroup(arg0 context.Context, arg1, arg2 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteStorageGroup", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteStorageGroup indicates an expected call of DeleteStorageGroup.
+func (mr *MockPmaxClientMockRecorder) DeleteStorageGroup(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStorageGroup", reflect.TypeOf((*MockPmaxClient)(nil).DeleteStorageGroup), arg0, arg1, arg2)
+}
+
+// DeleteStorageGroupSnapshot mocks base method.
+func (m *MockPmaxClient) DeleteStorageGroupSnapshot(arg0 context.Context, arg1, arg2, arg3, arg4 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteStorageGroupSnapshot", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteStorageGroupSnapshot indicates an expected call of DeleteStorageGroupSnapshot.
+func (mr *MockPmaxClientMockRecorder) DeleteStorageGroupSnapshot(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStorageGroupSnapshot", reflect.TypeOf((*MockPmaxClient)(nil).DeleteStorageGroupSnapshot), arg0, arg1, arg2, arg3, arg4)
+}
+
+// DeleteVolume mocks base method.
+func (m *MockPmaxClient) DeleteVolume(arg0 context.Context, arg1, arg2 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteVolume", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteVolume indicates an expected call of DeleteVolume.
+func (mr *MockPmaxClientMockRecorder) DeleteVolume(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolume", reflect.TypeOf((*MockPmaxClient)(nil).DeleteVolume), arg0, arg1, arg2)
+}
+
+// DeleteVolumeIDsIterator mocks base method.
+func (m *MockPmaxClient) DeleteVolumeIDsIterator(arg0 context.Context, arg1 *v100.VolumeIterator) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteVolumeIDsIterator", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteVolumeIDsIterator indicates an expected call of DeleteVolumeIDsIterator.
+func (mr *MockPmaxClientMockRecorder) DeleteVolumeIDsIterator(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolumeIDsIterator", reflect.TypeOf((*MockPmaxClient)(nil).DeleteVolumeIDsIterator), arg0, arg1)
+}
+
+// ExecuteCreateRDFGroup mocks base method.
+func (m *MockPmaxClient) ExecuteCreateRDFGroup(arg0 context.Context, arg1 string, arg2 *v100.RDFGroupCreate) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExecuteCreateRDFGroup", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ExecuteCreateRDFGroup indicates an expected call of ExecuteCreateRDFGroup.
+func (mr *MockPmaxClientMockRecorder) ExecuteCreateRDFGroup(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteCreateRDFGroup", reflect.TypeOf((*MockPmaxClient)(nil).ExecuteCreateRDFGroup), arg0, arg1, arg2)
+}
+
+// ExecuteReplicationActionOnSG mocks base method.
+func (m *MockPmaxClient) ExecuteReplicationActionOnSG(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5, arg6, arg7 bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExecuteReplicationActionOnSG", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ExecuteReplicationActionOnSG indicates an expected call of ExecuteReplicationActionOnSG.
+func (mr *MockPmaxClientMockRecorder) ExecuteReplicationActionOnSG(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteReplicationActionOnSG", reflect.TypeOf((*MockPmaxClient)(nil).ExecuteReplicationActionOnSG), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+}
+
+// ExpandVolume mocks base method.
+func (m *MockPmaxClient) ExpandVolume(arg0 context.Context, arg1, arg2 string, arg3 int, arg4 interface{}, arg5 ...string) (*v100.Volume, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2, arg3, arg4}
+	for _, a := range arg5 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ExpandVolume", varargs...)
+	ret0, _ := ret[0].(*v100.Volume)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExpandVolume indicates an expected call of ExpandVolume.
+func (mr *MockPmaxClientMockRecorder) ExpandVolume(arg0, arg1, arg2, arg3, arg4 interface{}, arg5 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2, arg3, arg4}, arg5...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpandVolume", reflect.TypeOf((*MockPmaxClient)(nil).ExpandVolume), varargs...)
+}
+
+// GetAllowedArrays mocks base method.
+func (m *MockPmaxClient) GetAllowedArrays() []string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAllowedArrays")
+	ret0, _ := ret[0].([]string)
+	return ret0
+}
+
+// GetAllowedArrays indicates an expected call of GetAllowedArrays.
+func (mr *MockPmaxClientMockRecorder) GetAllowedArrays() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllowedArrays", reflect.TypeOf((*MockPmaxClient)(nil).GetAllowedArrays))
+}
+
+// GetArrayPerfKeys mocks base method.
+func (m *MockPmaxClient) GetArrayPerfKeys(arg0 context.Context) (*v100.ArrayKeysResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetArrayPerfKeys", arg0)
+	ret0, _ := ret[0].(*v100.ArrayKeysResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetArrayPerfKeys indicates an expected call of GetArrayPerfKeys.
+func (mr *MockPmaxClientMockRecorder) GetArrayPerfKeys(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetArrayPerfKeys", reflect.TypeOf((*MockPmaxClient)(nil).GetArrayPerfKeys), arg0)
+}
+
+// GetCreateVolInSGPayload mocks base method.
+func (m *MockPmaxClient) GetCreateVolInSGPayload(arg0 interface{}, arg1, arg2 string, arg3, arg4 bool, arg5, arg6 string, arg7 ...http.Header) interface{} {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2, arg3, arg4, arg5, arg6}
+	for _, a := range arg7 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCreateVolInSGPayload", varargs...)
+	ret0, _ := ret[0].(interface{})
+	return ret0
+}
+
+// GetCreateVolInSGPayload indicates an expected call of GetCreateVolInSGPayload.
+func (mr *MockPmaxClientMockRecorder) GetCreateVolInSGPayload(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}, arg7 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5, arg6}, arg7...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCreateVolInSGPayload", reflect.TypeOf((*MockPmaxClient)(nil).GetCreateVolInSGPayload), varargs...)
+}
+
+// GetDirectorIDList mocks base method.
+func (m *MockPmaxClient) GetDirectorIDList(arg0 context.Context, arg1 string) (*v100.DirectorIDList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDirectorIDList", arg0, arg1)
+	ret0, _ := ret[0].(*v100.DirectorIDList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDirectorIDList indicates an expected call of GetDirectorIDList.
+func (mr *MockPmaxClientMockRecorder) GetDirectorIDList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDirectorIDList", reflect.TypeOf((*MockPmaxClient)(nil).GetDirectorIDList), arg0, arg1)
+}
+
+// GetFileInterfaceByID mocks base method.
+func (m *MockPmaxClient) GetFileInterfaceByID(arg0 context.Context, arg1, arg2 string) (*v100.FileInterface, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetFileInterfaceByID", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.FileInterface)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetFileInterfaceByID indicates an expected call of GetFileInterfaceByID.
+func (mr *MockPmaxClientMockRecorder) GetFileInterfaceByID(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFileInterfaceByID", reflect.TypeOf((*MockPmaxClient)(nil).GetFileInterfaceByID), arg0, arg1, arg2)
+}
+
+// GetFileSystemByID mocks base method.
+func (m *MockPmaxClient) GetFileSystemByID(arg0 context.Context, arg1, arg2 string) (*v100.FileSystem, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetFileSystemByID", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.FileSystem)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetFileSystemByID indicates an expected call of GetFileSystemByID.
+func (mr *MockPmaxClientMockRecorder) GetFileSystemByID(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFileSystemByID", reflect.TypeOf((*MockPmaxClient)(nil).GetFileSystemByID), arg0, arg1, arg2)
+}
+
+// GetFileSystemList mocks base method.
+func (m *MockPmaxClient) GetFileSystemList(arg0 context.Context, arg1 string, arg2 v100.QueryParams) (*v100.FileSystemIterator, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetFileSystemList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.FileSystemIterator)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetFileSystemList indicates an expected call of GetFileSystemList.
+func (mr *MockPmaxClientMockRecorder) GetFileSystemList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFileSystemList", reflect.TypeOf((*MockPmaxClient)(nil).GetFileSystemList), arg0, arg1, arg2)
+}
+
+// GetFileSystemMetricsByID mocks base method.
+func (m *MockPmaxClient) GetFileSystemMetricsByID(arg0 context.Context, arg1, arg2 string, arg3 []string, arg4, arg5 int64) (*v100.FileSystemMetricsIterator, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetFileSystemMetricsByID", arg0, arg1, arg2, arg3, arg4, arg5)
+	ret0, _ := ret[0].(*v100.FileSystemMetricsIterator)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetFileSystemMetricsByID indicates an expected call of GetFileSystemMetricsByID.
+func (mr *MockPmaxClientMockRecorder) GetFileSystemMetricsByID(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFileSystemMetricsByID", reflect.TypeOf((*MockPmaxClient)(nil).GetFileSystemMetricsByID), arg0, arg1, arg2, arg3, arg4, arg5)
+}
+
+// GetFreeLocalAndRemoteRDFg mocks base method.
+func (m *MockPmaxClient) GetFreeLocalAndRemoteRDFg(arg0 context.Context, arg1, arg2 string) (*v100.NextFreeRDFGroup, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetFreeLocalAndRemoteRDFg", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.NextFreeRDFGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetFreeLocalAndRemoteRDFg indicates an expected call of GetFreeLocalAndRemoteRDFg.
+func (mr *MockPmaxClientMockRecorder) GetFreeLocalAndRemoteRDFg(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFreeLocalAndRemoteRDFg", reflect.TypeOf((*MockPmaxClient)(nil).GetFreeLocalAndRemoteRDFg), arg0, arg1, arg2)
+}
+
+// GetHTTPClient mocks base method.
+func (m *MockPmaxClient) GetHTTPClient() *http.Client {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetHTTPClient")
+	ret0, _ := ret[0].(*http.Client)
+	return ret0
+}
+
+// GetHTTPClient indicates an expected call of GetHTTPClient.
+func (mr *MockPmaxClientMockRecorder) GetHTTPClient() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHTTPClient", reflect.TypeOf((*MockPmaxClient)(nil).GetHTTPClient))
+}
+
+// GetHostByID mocks base method.
+func (m *MockPmaxClient) GetHostByID(arg0 context.Context, arg1, arg2 string) (*v100.Host, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetHostByID", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.Host)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetHostByID indicates an expected call of GetHostByID.
+func (mr *MockPmaxClientMockRecorder) GetHostByID(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostByID", reflect.TypeOf((*MockPmaxClient)(nil).GetHostByID), arg0, arg1, arg2)
+}
+
+// GetHostGroupByID mocks base method.
+func (m *MockPmaxClient) GetHostGroupByID(arg0 context.Context, arg1, arg2 string) (*v100.HostGroup, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetHostGroupByID", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.HostGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetHostGroupByID indicates an expected call of GetHostGroupByID.
+func (mr *MockPmaxClientMockRecorder) GetHostGroupByID(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostGroupByID", reflect.TypeOf((*MockPmaxClient)(nil).GetHostGroupByID), arg0, arg1, arg2)
+}
+
+// GetHostGroupList mocks base method.
+func (m *MockPmaxClient) GetHostGroupList(arg0 context.Context, arg1 string) (*v100.HostGroupList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetHostGroupList", arg0, arg1)
+	ret0, _ := ret[0].(*v100.HostGroupList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetHostGroupList indicates an expected call of GetHostGroupList.
+func (mr *MockPmaxClientMockRecorder) GetHostGroupList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostGroupList", reflect.TypeOf((*MockPmaxClient)(nil).GetHostGroupList), arg0, arg1)
+}
+
+// GetHostList mocks base method.
+func (m *MockPmaxClient) GetHostList(arg0 context.Context, arg1 string) (*v100.HostList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetHostList", arg0, arg1)
+	ret0, _ := ret[0].(*v100.HostList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetHostList indicates an expected call of GetHostList.
+func (mr *MockPmaxClientMockRecorder) GetHostList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostList", reflect.TypeOf((*MockPmaxClient)(nil).GetHostList), arg0, arg1)
+}
+
+// GetISCSITargets mocks base method.
+func (m *MockPmaxClient) GetISCSITargets(arg0 context.Context, arg1 string) ([]pmax.ISCSITarget, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetISCSITargets", arg0, arg1)
+	ret0, _ := ret[0].([]pmax.ISCSITarget)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetISCSITargets indicates an expected call of GetISCSITargets.
+func (mr *MockPmaxClientMockRecorder) GetISCSITargets(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetISCSITargets", reflect.TypeOf((*MockPmaxClient)(nil).GetISCSITargets), arg0, arg1)
+}
+
+// GetInitiatorByID mocks base method.
+func (m *MockPmaxClient) GetInitiatorByID(arg0 context.Context, arg1, arg2 string) (*v100.Initiator, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetInitiatorByID", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.Initiator)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetInitiatorByID indicates an expected call of GetInitiatorByID.
+func (mr *MockPmaxClientMockRecorder) GetInitiatorByID(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInitiatorByID", reflect.TypeOf((*MockPmaxClient)(nil).GetInitiatorByID), arg0, arg1, arg2)
+}
+
+// GetInitiatorList mocks base method.
+func (m *MockPmaxClient) GetInitiatorList(arg0 context.Context, arg1, arg2 string, arg3, arg4 bool) (*v100.InitiatorList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetInitiatorList", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*v100.InitiatorList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetInitiatorList indicates an expected call of GetInitiatorList.
+func (mr *MockPmaxClientMockRecorder) GetInitiatorList(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInitiatorList", reflect.TypeOf((*MockPmaxClient)(nil).GetInitiatorList), arg0, arg1, arg2, arg3, arg4)
+}
+
+// GetJobByID mocks base method.
+func (m *MockPmaxClient) GetJobByID(arg0 context.Context, arg1, arg2 string) (*v100.Job, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetJobByID", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.Job)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetJobByID indicates an expected call of GetJobByID.
+func (mr *MockPmaxClientMockRecorder) GetJobByID(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJobByID", reflect.TypeOf((*MockPmaxClient)(nil).GetJobByID), arg0, arg1, arg2)
+}
+
+// GetJobIDList mocks base method.
+func (m *MockPmaxClient) GetJobIDList(arg0 context.Context, arg1, arg2 string) ([]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetJobIDList", arg0, arg1, arg2)
+	ret0, _ := ret[0].([]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetJobIDList indicates an expected call of GetJobIDList.
+func (mr *MockPmaxClientMockRecorder) GetJobIDList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJobIDList", reflect.TypeOf((*MockPmaxClient)(nil).GetJobIDList), arg0, arg1, arg2)
+}
+
+// GetListOfTargetAddresses mocks base method.
+func (m *MockPmaxClient) GetListOfTargetAddresses(arg0 context.Context, arg1 string) ([]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetListOfTargetAddresses", arg0, arg1)
+	ret0, _ := ret[0].([]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetListOfTargetAddresses indicates an expected call of GetListOfTargetAddresses.
+func (mr *MockPmaxClientMockRecorder) GetListOfTargetAddresses(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetListOfTargetAddresses", reflect.TypeOf((*MockPmaxClient)(nil).GetListOfTargetAddresses), arg0, arg1)
+}
+
+// GetLocalOnlineRDFDirs mocks base method.
+func (m *MockPmaxClient) GetLocalOnlineRDFDirs(arg0 context.Context, arg1 string) (*v100.RDFDirList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetLocalOnlineRDFDirs", arg0, arg1)
+	ret0, _ := ret[0].(*v100.RDFDirList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLocalOnlineRDFDirs indicates an expected call of GetLocalOnlineRDFDirs.
+func (mr *MockPmaxClientMockRecorder) GetLocalOnlineRDFDirs(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLocalOnlineRDFDirs", reflect.TypeOf((*MockPmaxClient)(nil).GetLocalOnlineRDFDirs), arg0, arg1)
+}
+
+// GetLocalOnlineRDFPorts mocks base method.
+func (m *MockPmaxClient) GetLocalOnlineRDFPorts(arg0 context.Context, arg1, arg2 string) (*v100.RDFPortList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetLocalOnlineRDFPorts", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.RDFPortList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLocalOnlineRDFPorts indicates an expected call of GetLocalOnlineRDFPorts.
+func (mr *MockPmaxClientMockRecorder) GetLocalOnlineRDFPorts(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLocalOnlineRDFPorts", reflect.TypeOf((*MockPmaxClient)(nil).GetLocalOnlineRDFPorts), arg0, arg1, arg2)
+}
+
+// GetLocalRDFPortDetails mocks base method.
+func (m *MockPmaxClient) GetLocalRDFPortDetails(arg0 context.Context, arg1, arg2 string, arg3 int) (*v100.RDFPortDetails, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetLocalRDFPortDetails", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.RDFPortDetails)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLocalRDFPortDetails indicates an expected call of GetLocalRDFPortDetails.
+func (mr *MockPmaxClientMockRecorder) GetLocalRDFPortDetails(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLocalRDFPortDetails", reflect.TypeOf((*MockPmaxClient)(nil).GetLocalRDFPortDetails), arg0, arg1, arg2, arg3)
+}
+
+// GetMaskingViewByID mocks base method.
+func (m *MockPmaxClient) GetMaskingViewByID(arg0 context.Context, arg1, arg2 string) (*v100.MaskingView, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetMaskingViewByID", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.MaskingView)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetMaskingViewByID indicates an expected call of GetMaskingViewByID.
+func (mr *MockPmaxClientMockRecorder) GetMaskingViewByID(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaskingViewByID", reflect.TypeOf((*MockPmaxClient)(nil).GetMaskingViewByID), arg0, arg1, arg2)
+}
+
+// GetMaskingViewConnections mocks base method.
+func (m *MockPmaxClient) GetMaskingViewConnections(arg0 context.Context, arg1, arg2, arg3 string) ([]*v100.MaskingViewConnection, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetMaskingViewConnections", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].([]*v100.MaskingViewConnection)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetMaskingViewConnections indicates an expected call of GetMaskingViewConnections.
+func (mr *MockPmaxClientMockRecorder) GetMaskingViewConnections(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaskingViewConnections", reflect.TypeOf((*MockPmaxClient)(nil).GetMaskingViewConnections), arg0, arg1, arg2, arg3)
+}
+
+// GetMaskingViewList mocks base method.
+func (m *MockPmaxClient) GetMaskingViewList(arg0 context.Context, arg1 string) (*v100.MaskingViewList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetMaskingViewList", arg0, arg1)
+	ret0, _ := ret[0].(*v100.MaskingViewList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetMaskingViewList indicates an expected call of GetMaskingViewList.
+func (mr *MockPmaxClientMockRecorder) GetMaskingViewList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaskingViewList", reflect.TypeOf((*MockPmaxClient)(nil).GetMaskingViewList), arg0, arg1)
+}
+
+// GetMigrationEnvironment mocks base method.
+func (m *MockPmaxClient) GetMigrationEnvironment(arg0 context.Context, arg1, arg2 string) (*v100.MigrationEnv, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetMigrationEnvironment", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.MigrationEnv)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetMigrationEnvironment indicates an expected call of GetMigrationEnvironment.
+func (mr *MockPmaxClientMockRecorder) GetMigrationEnvironment(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMigrationEnvironment", reflect.TypeOf((*MockPmaxClient)(nil).GetMigrationEnvironment), arg0, arg1, arg2)
+}
+
+// GetNASServerByID mocks base method.
+func (m *MockPmaxClient) GetNASServerByID(arg0 context.Context, arg1, arg2 string) (*v100.NASServer, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetNASServerByID", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.NASServer)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetNASServerByID indicates an expected call of GetNASServerByID.
+func (mr *MockPmaxClientMockRecorder) GetNASServerByID(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNASServerByID", reflect.TypeOf((*MockPmaxClient)(nil).GetNASServerByID), arg0, arg1, arg2)
+}
+
+// GetNASServerList mocks base method.
+func (m *MockPmaxClient) GetNASServerList(arg0 context.Context, arg1 string, arg2 v100.QueryParams) (*v100.NASServerIterator, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetNASServerList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.NASServerIterator)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetNASServerList indicates an expected call of GetNASServerList.
+func (mr *MockPmaxClientMockRecorder) GetNASServerList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNASServerList", reflect.TypeOf((*MockPmaxClient)(nil).GetNASServerList), arg0, arg1, arg2)
+}
+
+// GetNFSExportByID mocks base method.
+func (m *MockPmaxClient) GetNFSExportByID(arg0 context.Context, arg1, arg2 string) (*v100.NFSExport, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetNFSExportByID", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.NFSExport)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetNFSExportByID indicates an expected call of GetNFSExportByID.
+func (mr *MockPmaxClientMockRecorder) GetNFSExportByID(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNFSExportByID", reflect.TypeOf((*MockPmaxClient)(nil).GetNFSExportByID), arg0, arg1, arg2)
+}
+
+// GetNFSExportList mocks base method.
+func (m *MockPmaxClient) GetNFSExportList(arg0 context.Context, arg1 string, arg2 v100.QueryParams) (*v100.NFSExportIterator, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetNFSExportList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.NFSExportIterator)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetNFSExportList indicates an expected call of GetNFSExportList.
+func (mr *MockPmaxClientMockRecorder) GetNFSExportList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNFSExportList", reflect.TypeOf((*MockPmaxClient)(nil).GetNFSExportList), arg0, arg1, arg2)
+}
+
+// GetNVMeTCPTargets mocks base method.
+func (m *MockPmaxClient) GetNVMeTCPTargets(arg0 context.Context, arg1 string) ([]pmax.NVMeTCPTarget, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetNVMeTCPTargets", arg0, arg1)
+	ret0, _ := ret[0].([]pmax.NVMeTCPTarget)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetNVMeTCPTargets indicates an expected call of GetNVMeTCPTargets.
+func (mr *MockPmaxClientMockRecorder) GetNVMeTCPTargets(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNVMeTCPTargets", reflect.TypeOf((*MockPmaxClient)(nil).GetNVMeTCPTargets), arg0, arg1)
+}
+
+// GetPort mocks base method.
+func (m *MockPmaxClient) GetPort(arg0 context.Context, arg1, arg2, arg3 string) (*v100.Port, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPort", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.Port)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPort indicates an expected call of GetPort.
+func (mr *MockPmaxClientMockRecorder) GetPort(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPort", reflect.TypeOf((*MockPmaxClient)(nil).GetPort), arg0, arg1, arg2, arg3)
+}
+
+// GetPortGroupByID mocks base method.
+func (m *MockPmaxClient) GetPortGroupByID(arg0 context.Context, arg1, arg2 string) (*v100.PortGroup, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPortGroupByID", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.PortGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPortGroupByID indicates an expected call of GetPortGroupByID.
+func (mr *MockPmaxClientMockRecorder) GetPortGroupByID(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPortGroupByID", reflect.TypeOf((*MockPmaxClient)(nil).GetPortGroupByID), arg0, arg1, arg2)
+}
+
+// GetPortGroupList mocks base method.
+func (m *MockPmaxClient) GetPortGroupList(arg0 context.Context, arg1, arg2 string) (*v100.PortGroupList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPortGroupList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.PortGroupList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPortGroupList indicates an expected call of GetPortGroupList.
+func (mr *MockPmaxClientMockRecorder) GetPortGroupList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPortGroupList", reflect.TypeOf((*MockPmaxClient)(nil).GetPortGroupList), arg0, arg1, arg2)
+}
+
+// GetPortList mocks base method.
+func (m *MockPmaxClient) GetPortList(arg0 context.Context, arg1, arg2, arg3 string) (*v100.PortList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPortList", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.PortList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPortList indicates an expected call of GetPortList.
+func (mr *MockPmaxClientMockRecorder) GetPortList(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPortList", reflect.TypeOf((*MockPmaxClient)(nil).GetPortList), arg0, arg1, arg2, arg3)
+}
+
+// GetPrivVolumeByID mocks base method.
+func (m *MockPmaxClient) GetPrivVolumeByID(arg0 context.Context, arg1, arg2 string) (*v100.VolumeResultPrivate, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPrivVolumeByID", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.VolumeResultPrivate)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPrivVolumeByID indicates an expected call of GetPrivVolumeByID.
+func (mr *MockPmaxClientMockRecorder) GetPrivVolumeByID(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrivVolumeByID", reflect.TypeOf((*MockPmaxClient)(nil).GetPrivVolumeByID), arg0, arg1, arg2)
+}
+
+// GetProtectedStorageGroup mocks base method.
+func (m *MockPmaxClient) GetProtectedStorageGroup(arg0 context.Context, arg1, arg2 string) (*v100.RDFStorageGroup, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetProtectedStorageGroup", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.RDFStorageGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetProtectedStorageGroup indicates an expected call of GetProtectedStorageGroup.
+func (mr *MockPmaxClientMockRecorder) GetProtectedStorageGroup(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProtectedStorageGroup", reflect.TypeOf((*MockPmaxClient)(nil).GetProtectedStorageGroup), arg0, arg1, arg2)
+}
+
+// GetRDFDevicePairInfo mocks base method.
+func (m *MockPmaxClient) GetRDFDevicePairInfo(arg0 context.Context, arg1, arg2, arg3 string) (*v100.RDFDevicePair, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRDFDevicePairInfo", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.RDFDevicePair)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRDFDevicePairInfo indicates an expected call of GetRDFDevicePairInfo.
+func (mr *MockPmaxClientMockRecorder) GetRDFDevicePairInfo(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRDFDevicePairInfo", reflect.TypeOf((*MockPmaxClient)(nil).GetRDFDevicePairInfo), arg0, arg1, arg2, arg3)
+}
+
+// GetRDFGroupByID mocks base method.
+func (m *MockPmaxClient) GetRDFGroupByID(arg0 context.Context, arg1, arg2 string) (*v100.RDFGroup, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRDFGroupByID", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.RDFGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRDFGroupByID indicates an expected call of GetRDFGroupByID.
+func (mr *MockPmaxClientMockRecorder) GetRDFGroupByID(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRDFGroupByID", reflect.TypeOf((*MockPmaxClient)(nil).GetRDFGroupByID), arg0, arg1, arg2)
+}
+
+// GetRDFGroupList mocks base method.
+func (m *MockPmaxClient) GetRDFGroupList(arg0 context.Context, arg1 string, arg2 v100.QueryParams) (*v100.RDFGroupList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRDFGroupList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.RDFGroupList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRDFGroupList indicates an expected call of GetRDFGroupList.
+func (mr *MockPmaxClientMockRecorder) GetRDFGroupList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRDFGroupList", reflect.TypeOf((*MockPmaxClient)(nil).GetRDFGroupList), arg0, arg1, arg2)
+}
+
+// GetRemoteRDFPortOnSAN mocks base method.
+func (m *MockPmaxClient) GetRemoteRDFPortOnSAN(arg0 context.Context, arg1, arg2, arg3 string) (*v100.RemoteRDFPortDetails, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRemoteRDFPortOnSAN", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.RemoteRDFPortDetails)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRemoteRDFPortOnSAN indicates an expected call of GetRemoteRDFPortOnSAN.
+func (mr *MockPmaxClientMockRecorder) GetRemoteRDFPortOnSAN(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteRDFPortOnSAN", reflect.TypeOf((*MockPmaxClient)(nil).GetRemoteRDFPortOnSAN), arg0, arg1, arg2, arg3)
+}
+
+// GetReplicationCapabilities mocks base method.
+func (m *MockPmaxClient) GetReplicationCapabilities(arg0 context.Context) (*v100.SymReplicationCapabilities, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetReplicationCapabilities", arg0)
+	ret0, _ := ret[0].(*v100.SymReplicationCapabilities)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetReplicationCapabilities indicates an expected call of GetReplicationCapabilities.
+func (mr *MockPmaxClientMockRecorder) GetReplicationCapabilities(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReplicationCapabilities", reflect.TypeOf((*MockPmaxClient)(nil).GetReplicationCapabilities), arg0)
+}
+
+// GetSnapVolumeList mocks base method.
+func (m *MockPmaxClient) GetSnapVolumeList(arg0 context.Context, arg1 string, arg2 v100.QueryParams) (*v100.SymVolumeList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSnapVolumeList", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.SymVolumeList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSnapVolumeList indicates an expected call of GetSnapVolumeList.
+func (mr *MockPmaxClientMockRecorder) GetSnapVolumeList(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapVolumeList", reflect.TypeOf((*MockPmaxClient)(nil).GetSnapVolumeList), arg0, arg1, arg2)
+}
+
+// GetSnapshotGenerationInfo mocks base method.
+func (m *MockPmaxClient) GetSnapshotGenerationInfo(arg0 context.Context, arg1, arg2, arg3 string, arg4 int64) (*v100.VolumeSnapshotGeneration, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSnapshotGenerationInfo", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*v100.VolumeSnapshotGeneration)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSnapshotGenerationInfo indicates an expected call of GetSnapshotGenerationInfo.
+func (mr *MockPmaxClientMockRecorder) GetSnapshotGenerationInfo(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotGenerationInfo", reflect.TypeOf((*MockPmaxClient)(nil).GetSnapshotGenerationInfo), arg0, arg1, arg2, arg3, arg4)
+}
+
+// GetSnapshotGenerations mocks base method.
+func (m *MockPmaxClient) GetSnapshotGenerations(arg0 context.Context, arg1, arg2, arg3 string) (*v100.VolumeSnapshotGenerations, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSnapshotGenerations", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.VolumeSnapshotGenerations)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSnapshotGenerations indicates an expected call of GetSnapshotGenerations.
+func (mr *MockPmaxClientMockRecorder) GetSnapshotGenerations(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotGenerations", reflect.TypeOf((*MockPmaxClient)(nil).GetSnapshotGenerations), arg0, arg1, arg2, arg3)
+}
+
+// GetSnapshotInfo mocks base method.
+func (m *MockPmaxClient) GetSnapshotInfo(arg0 context.Context, arg1, arg2, arg3 string) (*v100.VolumeSnapshot, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSnapshotInfo", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.VolumeSnapshot)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSnapshotInfo indicates an expected call of GetSnapshotInfo.
+func (mr *MockPmaxClientMockRecorder) GetSnapshotInfo(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotInfo", reflect.TypeOf((*MockPmaxClient)(nil).GetSnapshotInfo), arg0, arg1, arg2, arg3)
+}
+
+// GetSnapshotPolicy mocks base method.
+func (m *MockPmaxClient) GetSnapshotPolicy(arg0 context.Context, arg1, arg2 string) (*v100.SnapshotPolicy, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSnapshotPolicy", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.SnapshotPolicy)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSnapshotPolicy indicates an expected call of GetSnapshotPolicy.
+func (mr *MockPmaxClientMockRecorder) GetSnapshotPolicy(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotPolicy", reflect.TypeOf((*MockPmaxClient)(nil).GetSnapshotPolicy), arg0, arg1, arg2)
+}
+
+// GetSnapshotPolicyList mocks base method.
+func (m *MockPmaxClient) GetSnapshotPolicyList(arg0 context.Context, arg1 string) (*v100.SnapshotPolicyList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSnapshotPolicyList", arg0, arg1)
+	ret0, _ := ret[0].(*v100.SnapshotPolicyList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSnapshotPolicyList indicates an expected call of GetSnapshotPolicyList.
+func (mr *MockPmaxClientMockRecorder) GetSnapshotPolicyList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotPolicyList", reflect.TypeOf((*MockPmaxClient)(nil).GetSnapshotPolicyList), arg0, arg1)
+}
+
+// GetStorageGroup mocks base method.
+func (m *MockPmaxClient) GetStorageGroup(arg0 context.Context, arg1, arg2 string) (*v100.StorageGroup, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStorageGroup", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.StorageGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStorageGroup indicates an expected call of GetStorageGroup.
+func (mr *MockPmaxClientMockRecorder) GetStorageGroup(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageGroup", reflect.TypeOf((*MockPmaxClient)(nil).GetStorageGroup), arg0, arg1, arg2)
+}
+
+// GetStorageGroupIDList mocks base method.
+func (m *MockPmaxClient) GetStorageGroupIDList(arg0 context.Context, arg1, arg2 string, arg3 bool) (*v100.StorageGroupIDList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStorageGroupIDList", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.StorageGroupIDList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStorageGroupIDList indicates an expected call of GetStorageGroupIDList.
+func (mr *MockPmaxClientMockRecorder) GetStorageGroupIDList(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageGroupIDList", reflect.TypeOf((*MockPmaxClient)(nil).GetStorageGroupIDList), arg0, arg1, arg2, arg3)
+}
+
+// GetStorageGroupMetrics mocks base method.
+func (m *MockPmaxClient) GetStorageGroupMetrics(arg0 context.Context, arg1, arg2 string, arg3 []string, arg4, arg5 int64) (*v100.StorageGroupMetricsIterator, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStorageGroupMetrics", arg0, arg1, arg2, arg3, arg4, arg5)
+	ret0, _ := ret[0].(*v100.StorageGroupMetricsIterator)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStorageGroupMetrics indicates an expected call of GetStorageGroupMetrics.
+func (mr *MockPmaxClientMockRecorder) GetStorageGroupMetrics(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageGroupMetrics", reflect.TypeOf((*MockPmaxClient)(nil).GetStorageGroupMetrics), arg0, arg1, arg2, arg3, arg4, arg5)
+}
+
+// GetStorageGroupMigration mocks base method.
+func (m *MockPmaxClient) GetStorageGroupMigration(arg0 context.Context, arg1 string) (*v100.MigrationStorageGroups, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStorageGroupMigration", arg0, arg1)
+	ret0, _ := ret[0].(*v100.MigrationStorageGroups)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStorageGroupMigration indicates an expected call of GetStorageGroupMigration.
+func (mr *MockPmaxClientMockRecorder) GetStorageGroupMigration(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageGroupMigration", reflect.TypeOf((*MockPmaxClient)(nil).GetStorageGroupMigration), arg0, arg1)
+}
+
+// GetStorageGroupMigrationByID mocks base method.
+func (m *MockPmaxClient) GetStorageGroupMigrationByID(arg0 context.Context, arg1, arg2 string) (*v100.MigrationSession, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStorageGroupMigrationByID", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.MigrationSession)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStorageGroupMigrationByID indicates an expected call of GetStorageGroupMigrationByID.
+func (mr *MockPmaxClientMockRecorder) GetStorageGroupMigrationByID(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageGroupMigrationByID", reflect.TypeOf((*MockPmaxClient)(nil).GetStorageGroupMigrationByID), arg0, arg1, arg2)
+}
+
+// GetStorageGroupPerfKeys mocks base method.
+func (m *MockPmaxClient) GetStorageGroupPerfKeys(arg0 context.Context, arg1 string) (*v100.StorageGroupKeysResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStorageGroupPerfKeys", arg0, arg1)
+	ret0, _ := ret[0].(*v100.StorageGroupKeysResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStorageGroupPerfKeys indicates an expected call of GetStorageGroupPerfKeys.
+func (mr *MockPmaxClientMockRecorder) GetStorageGroupPerfKeys(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageGroupPerfKeys", reflect.TypeOf((*MockPmaxClient)(nil).GetStorageGroupPerfKeys), arg0, arg1)
+}
+
+// GetStorageGroupRDFInfo mocks base method.
+func (m *MockPmaxClient) GetStorageGroupRDFInfo(arg0 context.Context, arg1, arg2, arg3 string) (*v100.StorageGroupRDFG, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStorageGroupRDFInfo", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.StorageGroupRDFG)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStorageGroupRDFInfo indicates an expected call of GetStorageGroupRDFInfo.
+func (mr *MockPmaxClientMockRecorder) GetStorageGroupRDFInfo(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageGroupRDFInfo", reflect.TypeOf((*MockPmaxClient)(nil).GetStorageGroupRDFInfo), arg0, arg1, arg2, arg3)
+}
+
+// GetStorageGroupSnapshotPolicy mocks base method.
+func (m *MockPmaxClient) GetStorageGroupSnapshotPolicy(arg0 context.Context, arg1, arg2, arg3 string) (*v100.StorageGroupSnapshotPolicy, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStorageGroupSnapshotPolicy", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.StorageGroupSnapshotPolicy)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStorageGroupSnapshotPolicy indicates an expected call of GetStorageGroupSnapshotPolicy.
+func (mr *MockPmaxClientMockRecorder) GetStorageGroupSnapshotPolicy(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageGroupSnapshotPolicy", reflect.TypeOf((*MockPmaxClient)(nil).GetStorageGroupSnapshotPolicy), arg0, arg1, arg2, arg3)
+}
+
+// GetStorageGroupSnapshotSnap mocks base method.
+func (m *MockPmaxClient) GetStorageGroupSnapshotSnap(arg0 context.Context, arg1, arg2, arg3, arg4 string) (*v100.StorageGroupSnap, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStorageGroupSnapshotSnap", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*v100.StorageGroupSnap)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStorageGroupSnapshotSnap indicates an expected call of GetStorageGroupSnapshotSnap.
+func (mr *MockPmaxClientMockRecorder) GetStorageGroupSnapshotSnap(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageGroupSnapshotSnap", reflect.TypeOf((*MockPmaxClient)(nil).GetStorageGroupSnapshotSnap), arg0, arg1, arg2, arg3, arg4)
+}
+
+// GetStorageGroupSnapshotSnapIDs mocks base method.
+func (m *MockPmaxClient) GetStorageGroupSnapshotSnapIDs(arg0 context.Context, arg1, arg2, arg3 string) (*v100.SnapID, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStorageGroupSnapshotSnapIDs", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.SnapID)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStorageGroupSnapshotSnapIDs indicates an expected call of GetStorageGroupSnapshotSnapIDs.
+func (mr *MockPmaxClientMockRecorder) GetStorageGroupSnapshotSnapIDs(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageGroupSnapshotSnapIDs", reflect.TypeOf((*MockPmaxClient)(nil).GetStorageGroupSnapshotSnapIDs), arg0, arg1, arg2, arg3)
+}
+
+// GetStorageGroupSnapshots mocks base method.
+func (m *MockPmaxClient) GetStorageGroupSnapshots(arg0 context.Context, arg1, arg2 string, arg3, arg4 bool) (*v100.StorageGroupSnapshot, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStorageGroupSnapshots", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*v100.StorageGroupSnapshot)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStorageGroupSnapshots indicates an expected call of GetStorageGroupSnapshots.
+func (mr *MockPmaxClientMockRecorder) GetStorageGroupSnapshots(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageGroupSnapshots", reflect.TypeOf((*MockPmaxClient)(nil).GetStorageGroupSnapshots), arg0, arg1, arg2, arg3, arg4)
+}
+
+// GetStoragePool mocks base method.
+func (m *MockPmaxClient) GetStoragePool(arg0 context.Context, arg1, arg2 string) (*v100.StoragePool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStoragePool", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.StoragePool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStoragePool indicates an expected call of GetStoragePool.
+func (mr *MockPmaxClientMockRecorder) GetStoragePool(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePool", reflect.TypeOf((*MockPmaxClient)(nil).GetStoragePool), arg0, arg1, arg2)
+}
+
+// GetStoragePoolList mocks base method.
+func (m *MockPmaxClient) GetStoragePoolList(arg0 context.Context, arg1 string) (*v100.StoragePoolList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetStoragePoolList", arg0, arg1)
+	ret0, _ := ret[0].(*v100.StoragePoolList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStoragePoolList indicates an expected call of GetStoragePoolList.
+func (mr *MockPmaxClientMockRecorder) GetStoragePoolList(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStoragePoolList", reflect.TypeOf((*MockPmaxClient)(nil).GetStoragePoolList), arg0, arg1)
+}
+
+// GetSymmetrixByID mocks base method.
+func (m *MockPmaxClient) GetSymmetrixByID(arg0 context.Context, arg1 string) (*v100.Symmetrix, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSymmetrixByID", arg0, arg1)
+	ret0, _ := ret[0].(*v100.Symmetrix)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSymmetrixByID indicates an expected call of GetSymmetrixByID.
+func (mr *MockPmaxClientMockRecorder) GetSymmetrixByID(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSymmetrixByID", reflect.TypeOf((*MockPmaxClient)(nil).GetSymmetrixByID), arg0, arg1)
+}
+
+// GetSymmetrixIDList mocks base method.
+func (m *MockPmaxClient) GetSymmetrixIDList(arg0 context.Context) (*v100.SymmetrixIDList, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSymmetrixIDList", arg0)
+	ret0, _ := ret[0].(*v100.SymmetrixIDList)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSymmetrixIDList indicates an expected call of GetSymmetrixIDList.
+func (mr *MockPmaxClientMockRecorder) GetSymmetrixIDList(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSymmetrixIDList", reflect.TypeOf((*MockPmaxClient)(nil).GetSymmetrixIDList), arg0)
+}
+
+// GetVolumeByID mocks base method.
+func (m *MockPmaxClient) GetVolumeByID(arg0 context.Context, arg1, arg2 string) (*v100.Volume, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetVolumeByID", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.Volume)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVolumeByID indicates an expected call of GetVolumeByID.
+func (mr *MockPmaxClientMockRecorder) GetVolumeByID(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumeByID", reflect.TypeOf((*MockPmaxClient)(nil).GetVolumeByID), arg0, arg1, arg2)
+}
+
+// GetVolumeIDList mocks base method.
+func (m *MockPmaxClient) GetVolumeIDList(arg0 context.Context, arg1, arg2 string, arg3 bool) ([]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetVolumeIDList", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].([]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVolumeIDList indicates an expected call of GetVolumeIDList.
+func (mr *MockPmaxClientMockRecorder) GetVolumeIDList(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumeIDList", reflect.TypeOf((*MockPmaxClient)(nil).GetVolumeIDList), arg0, arg1, arg2, arg3)
+}
+
+// GetVolumeIDListInStorageGroup mocks base method.
+func (m *MockPmaxClient) GetVolumeIDListInStorageGroup(arg0 context.Context, arg1, arg2 string) ([]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetVolumeIDListInStorageGroup", arg0, arg1, arg2)
+	ret0, _ := ret[0].([]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVolumeIDListInStorageGroup indicates an expected call of GetVolumeIDListInStorageGroup.
+func (mr *MockPmaxClientMockRecorder) GetVolumeIDListInStorageGroup(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumeIDListInStorageGroup", reflect.TypeOf((*MockPmaxClient)(nil).GetVolumeIDListInStorageGroup), arg0, arg1, arg2)
+}
+
+// GetVolumeIDListWithParams mocks base method.
+func (m *MockPmaxClient) GetVolumeIDListWithParams(arg0 context.Context, arg1 string, arg2 map[string]string) ([]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetVolumeIDListWithParams", arg0, arg1, arg2)
+	ret0, _ := ret[0].([]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVolumeIDListWithParams indicates an expected call of GetVolumeIDListWithParams.
+func (mr *MockPmaxClientMockRecorder) GetVolumeIDListWithParams(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumeIDListWithParams", reflect.TypeOf((*MockPmaxClient)(nil).GetVolumeIDListWithParams), arg0, arg1, arg2)
+}
+
+// GetVolumeIDsIterator mocks base method.
+func (m *MockPmaxClient) GetVolumeIDsIterator(arg0 context.Context, arg1, arg2 string, arg3 bool) (*v100.VolumeIterator, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetVolumeIDsIterator", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.VolumeIterator)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVolumeIDsIterator indicates an expected call of GetVolumeIDsIterator.
+func (mr *MockPmaxClientMockRecorder) GetVolumeIDsIterator(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumeIDsIterator", reflect.TypeOf((*MockPmaxClient)(nil).GetVolumeIDsIterator), arg0, arg1, arg2, arg3)
+}
+
+// GetVolumeIDsIteratorPage mocks base method.
+func (m *MockPmaxClient) GetVolumeIDsIteratorPage(arg0 context.Context, arg1 *v100.VolumeIterator, arg2, arg3 int) ([]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetVolumeIDsIteratorPage", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].([]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVolumeIDsIteratorPage indicates an expected call of GetVolumeIDsIteratorPage.
+func (mr *MockPmaxClientMockRecorder) GetVolumeIDsIteratorPage(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumeIDsIteratorPage", reflect.TypeOf((*MockPmaxClient)(nil).GetVolumeIDsIteratorPage), arg0, arg1, arg2, arg3)
+}
+
+// GetVolumeIDsIteratorWithParams mocks base method.
+func (m *MockPmaxClient) GetVolumeIDsIteratorWithParams(arg0 context.Context, arg1 string, arg2 map[string]string) (*v100.VolumeIterator, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetVolumeIDsIteratorWithParams", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.VolumeIterator)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVolumeIDsIteratorWithParams indicates an expected call of GetVolumeIDsIteratorWithParams.
+func (mr *MockPmaxClientMockRecorder) GetVolumeIDsIteratorWithParams(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumeIDsIteratorWithParams", reflect.TypeOf((*MockPmaxClient)(nil).GetVolumeIDsIteratorWithParams), arg0, arg1, arg2)
+}
+
+// GetVolumeSnapInfo mocks base method.
+func (m *MockPmaxClient) GetVolumeSnapInfo(arg0 context.Context, arg1, arg2 string) (*v100.SnapshotVolumeGeneration, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetVolumeSnapInfo", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.SnapshotVolumeGeneration)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVolumeSnapInfo indicates an expected call of GetVolumeSnapInfo.
+func (mr *MockPmaxClientMockRecorder) GetVolumeSnapInfo(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumeSnapInfo", reflect.TypeOf((*MockPmaxClient)(nil).GetVolumeSnapInfo), arg0, arg1, arg2)
+}
+
+// GetVolumesInStorageGroupIterator mocks base method.
+func (m *MockPmaxClient) GetVolumesInStorageGroupIterator(arg0 context.Context, arg1, arg2 string) (*v100.VolumeIterator, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetVolumesInStorageGroupIterator", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.VolumeIterator)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVolumesInStorageGroupIterator indicates an expected call of GetVolumesInStorageGroupIterator.
+func (mr *MockPmaxClientMockRecorder) GetVolumesInStorageGroupIterator(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumesInStorageGroupIterator", reflect.TypeOf((*MockPmaxClient)(nil).GetVolumesInStorageGroupIterator), arg0, arg1, arg2)
+}
+
+// GetVolumesMetrics mocks base method.
+func (m *MockPmaxClient) GetVolumesMetrics(arg0 context.Context, arg1, arg2 string, arg3 []string, arg4, arg5 int64) (*v100.VolumeMetricsIterator, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetVolumesMetrics", arg0, arg1, arg2, arg3, arg4, arg5)
+	ret0, _ := ret[0].(*v100.VolumeMetricsIterator)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVolumesMetrics indicates an expected call of GetVolumesMetrics.
+func (mr *MockPmaxClientMockRecorder) GetVolumesMetrics(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumesMetrics", reflect.TypeOf((*MockPmaxClient)(nil).GetVolumesMetrics), arg0, arg1, arg2, arg3, arg4, arg5)
+}
+
+// GetVolumesMetricsByID mocks base method.
+func (m *MockPmaxClient) GetVolumesMetricsByID(arg0 context.Context, arg1, arg2 string, arg3 []string, arg4, arg5 int64) (*v100.VolumeMetricsIterator, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetVolumesMetricsByID", arg0, arg1, arg2, arg3, arg4, arg5)
+	ret0, _ := ret[0].(*v100.VolumeMetricsIterator)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVolumesMetricsByID indicates an expected call of GetVolumesMetricsByID.
+func (mr *MockPmaxClientMockRecorder) GetVolumesMetricsByID(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVolumesMetricsByID", reflect.TypeOf((*MockPmaxClient)(nil).GetVolumesMetricsByID), arg0, arg1, arg2, arg3, arg4, arg5)
+}
+
+// InitiateDeallocationOfTracksFromVolume mocks base method.
+func (m *MockPmaxClient) InitiateDeallocationOfTracksFromVolume(arg0 context.Context, arg1, arg2 string) (*v100.Job, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InitiateDeallocationOfTracksFromVolume", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.Job)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// InitiateDeallocationOfTracksFromVolume indicates an expected call of InitiateDeallocationOfTracksFromVolume.
+func (mr *MockPmaxClientMockRecorder) InitiateDeallocationOfTracksFromVolume(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitiateDeallocationOfTracksFromVolume", reflect.TypeOf((*MockPmaxClient)(nil).InitiateDeallocationOfTracksFromVolume), arg0, arg1, arg2)
+}
+
+// IsAllowedArray mocks base method.
+func (m *MockPmaxClient) IsAllowedArray(arg0 string) (bool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsAllowedArray", arg0)
+	ret0, _ := ret[0].(bool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// IsAllowedArray indicates an expected call of IsAllowedArray.
+func (mr *MockPmaxClientMockRecorder) IsAllowedArray(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAllowedArray", reflect.TypeOf((*MockPmaxClient)(nil).IsAllowedArray), arg0)
+}
+
+// JobToString mocks base method.
+func (m *MockPmaxClient) JobToString(arg0 *v100.Job) string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "JobToString", arg0)
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// JobToString indicates an expected call of JobToString.
+func (mr *MockPmaxClientMockRecorder) JobToString(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JobToString", reflect.TypeOf((*MockPmaxClient)(nil).JobToString), arg0)
+}
+
+// ModifyFileSystem mocks base method.
+func (m *MockPmaxClient) ModifyFileSystem(arg0 context.Context, arg1, arg2 string, arg3 v100.ModifyFileSystem) (*v100.FileSystem, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ModifyFileSystem", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.FileSystem)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ModifyFileSystem indicates an expected call of ModifyFileSystem.
+func (mr *MockPmaxClientMockRecorder) ModifyFileSystem(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFileSystem", reflect.TypeOf((*MockPmaxClient)(nil).ModifyFileSystem), arg0, arg1, arg2, arg3)
+}
+
+// ModifyMigrationSession mocks base method.
+func (m *MockPmaxClient) ModifyMigrationSession(arg0 context.Context, arg1, arg2, arg3 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ModifyMigrationSession", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ModifyMigrationSession indicates an expected call of ModifyMigrationSession.
+func (mr *MockPmaxClientMockRecorder) ModifyMigrationSession(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyMigrationSession", reflect.TypeOf((*MockPmaxClient)(nil).ModifyMigrationSession), arg0, arg1, arg2, arg3)
+}
+
+// ModifyMobilityForVolume mocks base method.
+func (m *MockPmaxClient) ModifyMobilityForVolume(arg0 context.Context, arg1, arg2 string, arg3 bool) (*v100.Volume, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ModifyMobilityForVolume", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.Volume)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ModifyMobilityForVolume indicates an expected call of ModifyMobilityForVolume.
+func (mr *MockPmaxClientMockRecorder) ModifyMobilityForVolume(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyMobilityForVolume", reflect.TypeOf((*MockPmaxClient)(nil).ModifyMobilityForVolume), arg0, arg1, arg2, arg3)
+}
+
+// ModifyNASServer mocks base method.
+func (m *MockPmaxClient) ModifyNASServer(arg0 context.Context, arg1, arg2 string, arg3 v100.ModifyNASServer) (*v100.NASServer, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ModifyNASServer", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.NASServer)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ModifyNASServer indicates an expected call of ModifyNASServer.
+func (mr *MockPmaxClientMockRecorder) ModifyNASServer(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNASServer", reflect.TypeOf((*MockPmaxClient)(nil).ModifyNASServer), arg0, arg1, arg2, arg3)
+}
+
+// ModifyNFSExport mocks base method.
+func (m *MockPmaxClient) ModifyNFSExport(arg0 context.Context, arg1, arg2 string, arg3 v100.ModifyNFSExport) (*v100.NFSExport, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ModifyNFSExport", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.NFSExport)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ModifyNFSExport indicates an expected call of ModifyNFSExport.
+func (mr *MockPmaxClientMockRecorder) ModifyNFSExport(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNFSExport", reflect.TypeOf((*MockPmaxClient)(nil).ModifyNFSExport), arg0, arg1, arg2, arg3)
+}
+
+// ModifySnapshot mocks base method.
+func (m *MockPmaxClient) ModifySnapshot(arg0 context.Context, arg1 string, arg2, arg3 []v100.VolumeList, arg4, arg5, arg6 string, arg7 int64, arg8 bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ModifySnapshot", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ModifySnapshot indicates an expected call of ModifySnapshot.
+func (mr *MockPmaxClientMockRecorder) ModifySnapshot(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshot", reflect.TypeOf((*MockPmaxClient)(nil).ModifySnapshot), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+}
+
+// ModifySnapshotS mocks base method.
+func (m *MockPmaxClient) ModifySnapshotS(arg0 context.Context, arg1 string, arg2, arg3 []v100.VolumeList, arg4, arg5, arg6 string, arg7 int64, arg8 bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ModifySnapshotS", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ModifySnapshotS indicates an expected call of ModifySnapshotS.
+func (mr *MockPmaxClientMockRecorder) ModifySnapshotS(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotS", reflect.TypeOf((*MockPmaxClient)(nil).ModifySnapshotS), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+}
+
+// ModifyStorageGroupSnapshot mocks base method.
+func (m *MockPmaxClient) ModifyStorageGroupSnapshot(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 *v100.ModifyStorageGroupSnapshot) (*v100.StorageGroupSnap, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ModifyStorageGroupSnapshot", arg0, arg1, arg2, arg3, arg4, arg5)
+	ret0, _ := ret[0].(*v100.StorageGroupSnap)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ModifyStorageGroupSnapshot indicates an expected call of ModifyStorageGroupSnapshot.
+func (mr *MockPmaxClientMockRecorder) ModifyStorageGroupSnapshot(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyStorageGroupSnapshot", reflect.TypeOf((*MockPmaxClient)(nil).ModifyStorageGroupSnapshot), arg0, arg1, arg2, arg3, arg4, arg5)
+}
+
+// RefreshSymmetrix mocks base method.
+func (m *MockPmaxClient) RefreshSymmetrix(arg0 context.Context, arg1 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RefreshSymmetrix", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RefreshSymmetrix indicates an expected call of RefreshSymmetrix.
+func (mr *MockPmaxClientMockRecorder) RefreshSymmetrix(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshSymmetrix", reflect.TypeOf((*MockPmaxClient)(nil).RefreshSymmetrix), arg0, arg1)
+}
+
+// RemoveVolumesFromProtectedStorageGroup mocks base method.
+func (m *MockPmaxClient) RemoveVolumesFromProtectedStorageGroup(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 bool, arg6 ...string) (*v100.StorageGroup, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2, arg3, arg4, arg5}
+	for _, a := range arg6 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RemoveVolumesFromProtectedStorageGroup", varargs...)
+	ret0, _ := ret[0].(*v100.StorageGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RemoveVolumesFromProtectedStorageGroup indicates an expected call of RemoveVolumesFromProtectedStorageGroup.
+func (mr *MockPmaxClientMockRecorder) RemoveVolumesFromProtectedStorageGroup(arg0, arg1, arg2, arg3, arg4, arg5 interface{}, arg6 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5}, arg6...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveVolumesFromProtectedStorageGroup", reflect.TypeOf((*MockPmaxClient)(nil).RemoveVolumesFromProtectedStorageGroup), varargs...)
+}
+
+// RemoveVolumesFromStorageGroup mocks base method.
+func (m *MockPmaxClient) RemoveVolumesFromStorageGroup(arg0 context.Context, arg1, arg2 string, arg3 bool, arg4 ...string) (*v100.StorageGroup, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2, arg3}
+	for _, a := range arg4 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RemoveVolumesFromStorageGroup", varargs...)
+	ret0, _ := ret[0].(*v100.StorageGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RemoveVolumesFromStorageGroup indicates an expected call of RemoveVolumesFromStorageGroup.
+func (mr *MockPmaxClientMockRecorder) RemoveVolumesFromStorageGroup(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveVolumesFromStorageGroup", reflect.TypeOf((*MockPmaxClient)(nil).RemoveVolumesFromStorageGroup), varargs...)
+}
+
+// RenameMaskingView mocks base method.
+func (m *MockPmaxClient) RenameMaskingView(arg0 context.Context, arg1, arg2, arg3 string) (*v100.MaskingView, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RenameMaskingView", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.MaskingView)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RenameMaskingView indicates an expected call of RenameMaskingView.
+func (mr *MockPmaxClientMockRecorder) RenameMaskingView(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameMaskingView", reflect.TypeOf((*MockPmaxClient)(nil).RenameMaskingView), arg0, arg1, arg2, arg3)
+}
+
+// RenamePortGroup mocks base method.
+func (m *MockPmaxClient) RenamePortGroup(arg0 context.Context, arg1, arg2, arg3 string) (*v100.PortGroup, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RenamePortGroup", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.PortGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RenamePortGroup indicates an expected call of RenamePortGroup.
+func (mr *MockPmaxClientMockRecorder) RenamePortGroup(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenamePortGroup", reflect.TypeOf((*MockPmaxClient)(nil).RenamePortGroup), arg0, arg1, arg2, arg3)
+}
+
+// RenameVolume mocks base method.
+func (m *MockPmaxClient) RenameVolume(arg0 context.Context, arg1, arg2, arg3 string) (*v100.Volume, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RenameVolume", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.Volume)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RenameVolume indicates an expected call of RenameVolume.
+func (mr *MockPmaxClientMockRecorder) RenameVolume(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameVolume", reflect.TypeOf((*MockPmaxClient)(nil).RenameVolume), arg0, arg1, arg2, arg3)
+}
+
+// SetAllowedArrays mocks base method.
+func (m *MockPmaxClient) SetAllowedArrays(arg0 []string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetAllowedArrays", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SetAllowedArrays indicates an expected call of SetAllowedArrays.
+func (mr *MockPmaxClientMockRecorder) SetAllowedArrays(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllowedArrays", reflect.TypeOf((*MockPmaxClient)(nil).SetAllowedArrays), arg0)
+}
+
+// UpdateHostFlags mocks base method.
+func (m *MockPmaxClient) UpdateHostFlags(arg0 context.Context, arg1, arg2 string, arg3 *v100.HostFlags) (*v100.Host, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateHostFlags", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.Host)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateHostFlags indicates an expected call of UpdateHostFlags.
+func (mr *MockPmaxClientMockRecorder) UpdateHostFlags(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostFlags", reflect.TypeOf((*MockPmaxClient)(nil).UpdateHostFlags), arg0, arg1, arg2, arg3)
+}
+
+// UpdateHostGroupFlags mocks base method.
+func (m *MockPmaxClient) UpdateHostGroupFlags(arg0 context.Context, arg1, arg2 string, arg3 *v100.HostFlags) (*v100.HostGroup, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateHostGroupFlags", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.HostGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateHostGroupFlags indicates an expected call of UpdateHostGroupFlags.
+func (mr *MockPmaxClientMockRecorder) UpdateHostGroupFlags(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostGroupFlags", reflect.TypeOf((*MockPmaxClient)(nil).UpdateHostGroupFlags), arg0, arg1, arg2, arg3)
+}
+
+// UpdateHostGroupHosts mocks base method.
+func (m *MockPmaxClient) UpdateHostGroupHosts(arg0 context.Context, arg1, arg2 string, arg3 []string) (*v100.HostGroup, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateHostGroupHosts", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.HostGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateHostGroupHosts indicates an expected call of UpdateHostGroupHosts.
+func (mr *MockPmaxClientMockRecorder) UpdateHostGroupHosts(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostGroupHosts", reflect.TypeOf((*MockPmaxClient)(nil).UpdateHostGroupHosts), arg0, arg1, arg2, arg3)
+}
+
+// UpdateHostGroupName mocks base method.
+func (m *MockPmaxClient) UpdateHostGroupName(arg0 context.Context, arg1, arg2, arg3 string) (*v100.HostGroup, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateHostGroupName", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.HostGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateHostGroupName indicates an expected call of UpdateHostGroupName.
+func (mr *MockPmaxClientMockRecorder) UpdateHostGroupName(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostGroupName", reflect.TypeOf((*MockPmaxClient)(nil).UpdateHostGroupName), arg0, arg1, arg2, arg3)
+}
+
+// UpdateHostInitiators mocks base method.
+func (m *MockPmaxClient) UpdateHostInitiators(arg0 context.Context, arg1 string, arg2 *v100.Host, arg3 []string) (*v100.Host, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateHostInitiators", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.Host)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateHostInitiators indicates an expected call of UpdateHostInitiators.
+func (mr *MockPmaxClientMockRecorder) UpdateHostInitiators(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostInitiators", reflect.TypeOf((*MockPmaxClient)(nil).UpdateHostInitiators), arg0, arg1, arg2, arg3)
+}
+
+// UpdateHostName mocks base method.
+func (m *MockPmaxClient) UpdateHostName(arg0 context.Context, arg1, arg2, arg3 string) (*v100.Host, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateHostName", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.Host)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateHostName indicates an expected call of UpdateHostName.
+func (mr *MockPmaxClientMockRecorder) UpdateHostName(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostName", reflect.TypeOf((*MockPmaxClient)(nil).UpdateHostName), arg0, arg1, arg2, arg3)
+}
+
+// UpdatePortGroup mocks base method.
+func (m *MockPmaxClient) UpdatePortGroup(arg0 context.Context, arg1, arg2 string, arg3 []v100.PortKey) (*v100.PortGroup, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdatePortGroup", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.PortGroup)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdatePortGroup indicates an expected call of UpdatePortGroup.
+func (mr *MockPmaxClientMockRecorder) UpdatePortGroup(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePortGroup", reflect.TypeOf((*MockPmaxClient)(nil).UpdatePortGroup), arg0, arg1, arg2, arg3)
+}
+
+// UpdateSnapshotPolicy mocks base method.
+func (m *MockPmaxClient) UpdateSnapshotPolicy(arg0 context.Context, arg1, arg2, arg3 string, arg4 map[string]interface{}) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateSnapshotPolicy", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateSnapshotPolicy indicates an expected call of UpdateSnapshotPolicy.
+func (mr *MockPmaxClientMockRecorder) UpdateSnapshotPolicy(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSnapshotPolicy", reflect.TypeOf((*MockPmaxClient)(nil).UpdateSnapshotPolicy), arg0, arg1, arg2, arg3, arg4)
+}
+
+// UpdateStorageGroup mocks base method.
+func (m *MockPmaxClient) UpdateStorageGroup(arg0 context.Context, arg1, arg2 string, arg3 interface{}) (*v100.Job, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateStorageGroup", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*v100.Job)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateStorageGroup indicates an expected call of UpdateStorageGroup.
+func (mr *MockPmaxClientMockRecorder) UpdateStorageGroup(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStorageGroup", reflect.TypeOf((*MockPmaxClient)(nil).UpdateStorageGroup), arg0, arg1, arg2, arg3)
+}
+
+// UpdateStorageGroupS mocks base method.
+func (m *MockPmaxClient) UpdateStorageGroupS(arg0 context.Context, arg1, arg2 string, arg3 interface{}) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateStorageGroupS", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateStorageGroupS indicates an expected call of UpdateStorageGroupS.
+func (mr *MockPmaxClientMockRecorder) UpdateStorageGroupS(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStorageGroupS", reflect.TypeOf((*MockPmaxClient)(nil).UpdateStorageGroupS), arg0, arg1, arg2, arg3)
+}
+
+// WaitOnJobCompletion mocks base method.
+func (m *MockPmaxClient) WaitOnJobCompletion(arg0 context.Context, arg1, arg2 string) (*v100.Job, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WaitOnJobCompletion", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*v100.Job)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// WaitOnJobCompletion indicates an expected call of WaitOnJobCompletion.
+func (mr *MockPmaxClientMockRecorder) WaitOnJobCompletion(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitOnJobCompletion", reflect.TypeOf((*MockPmaxClient)(nil).WaitOnJobCompletion), arg0, arg1, arg2)
+}
+
+// WithSymmetrixID mocks base method.
+func (m *MockPmaxClient) WithSymmetrixID(arg0 string) pmax.Pmax {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WithSymmetrixID", arg0)
+	ret0, _ := ret[0].(pmax.Pmax)
+	return ret0
+}
+
+// WithSymmetrixID indicates an expected call of WithSymmetrixID.
+func (mr *MockPmaxClientMockRecorder) WithSymmetrixID(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithSymmetrixID", reflect.TypeOf((*MockPmaxClient)(nil).WithSymmetrixID), arg0)
+}
diff --git a/pkg/symmetrix/mocks/roundtripper.go b/pkg/symmetrix/mocks/roundtripper.go
new file mode 100644
index 00000000..55cd2bc2
--- /dev/null
+++ b/pkg/symmetrix/mocks/roundtripper.go
@@ -0,0 +1,50 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/dell/csi-powermax/v2/pkg/symmetrix (interfaces: RoundTripperInterface)
+
+// Package mocks is a generated GoMock package.
+package mocks
+
+import (
+	http "net/http"
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockRoundTripperInterface is a mock of RoundTripperInterface interface.
+type MockRoundTripperInterface struct {
+	ctrl     *gomock.Controller
+	recorder *MockRoundTripperInterfaceMockRecorder
+}
+
+// MockRoundTripperInterfaceMockRecorder is the mock recorder for MockRoundTripperInterface.
+type MockRoundTripperInterfaceMockRecorder struct {
+	mock *MockRoundTripperInterface
+}
+
+// NewMockRoundTripperInterface creates a new mock instance.
+func NewMockRoundTripperInterface(ctrl *gomock.Controller) *MockRoundTripperInterface {
+	mock := &MockRoundTripperInterface{ctrl: ctrl}
+	mock.recorder = &MockRoundTripperInterfaceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockRoundTripperInterface) EXPECT() *MockRoundTripperInterfaceMockRecorder {
+	return m.recorder
+}
+
+// RoundTrip mocks base method.
+func (m *MockRoundTripperInterface) RoundTrip(arg0 *http.Request) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RoundTrip", arg0)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RoundTrip indicates an expected call of RoundTrip.
+func (mr *MockRoundTripperInterfaceMockRecorder) RoundTrip(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoundTrip", reflect.TypeOf((*MockRoundTripperInterface)(nil).RoundTrip), arg0)
+}
diff --git a/pkg/symmetrix/powermax.go b/pkg/symmetrix/powermax.go
index fd5f73bb..8879654a 100644
--- a/pkg/symmetrix/powermax.go
+++ b/pkg/symmetrix/powermax.go
@@ -39,6 +39,13 @@ var (
 	validSLO                 = [...]string{"Diamond", "Platinum", "Gold", "Silver", "Bronze", "Optimized", "None"}
 )
 
+// PmaxClient is the interface for Pmax
+//
+//go:generate mockgen -destination=mocks/pmaxclient.go -package=mocks github.com/dell/csi-powermax/v2/pkg/symmetrix PmaxClient
+type PmaxClient interface {
+	pmax.Pmax
+}
+
 // We need to implement look through caches so that the caller
 // is not bothered with updating the values in the cache
 
diff --git a/pkg/symmetrix/powermax_test.go b/pkg/symmetrix/powermax_test.go
index 241ff357..16d59d0f 100644
--- a/pkg/symmetrix/powermax_test.go
+++ b/pkg/symmetrix/powermax_test.go
@@ -15,10 +15,16 @@
 package symmetrix
 
 import (
+	"context"
+	"fmt"
+	"reflect"
 	"testing"
+	"time"
 
+	"github.com/dell/csi-powermax/v2/pkg/symmetrix/mocks"
 	pmax "github.com/dell/gopowermax/v2"
 	types "github.com/dell/gopowermax/v2/types/v100"
+	"github.com/golang/mock/gomock"
 )
 
 func TestGetPowerMaxClient(t *testing.T) {
@@ -74,3 +80,365 @@ func TestUpdate(t *testing.T) {
 		}
 	}
 }
+
+func TestCacheTime_IsValid(t *testing.T) {
+	tests := []struct {
+		name     string
+		cache    CacheTime
+		expected bool
+	}{
+		{
+			name:     "cache not initialized",
+			cache:    CacheTime{},
+			expected: false,
+		},
+		{
+			name:     "cache still valid",
+			cache:    CacheTime{CreationTime: time.Now(), CacheValidity: time.Hour},
+			expected: true,
+		},
+		{
+			name:     "cache expired",
+			cache:    CacheTime{CreationTime: time.Now().Add(-2 * time.Hour), CacheValidity: time.Hour},
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			actual := tt.cache.IsValid()
+			if actual != tt.expected {
+				t.Errorf("expected %v, but got %v", tt.expected, actual)
+			}
+		})
+	}
+}
+
+func TestReplicationCapabilitiesCache_Get(t *testing.T) {
+	tests := []struct {
+		name     string
+		cache    ReplicationCapabilitiesCache
+		ctx      context.Context
+		client   func() *mocks.MockPmaxClient
+		symID    string
+		expected *types.SymmetrixCapability
+		err      error
+	}{
+		{
+			name:  "cache not initialized",
+			cache: ReplicationCapabilitiesCache{},
+			ctx:   context.Background(),
+			client: func() *mocks.MockPmaxClient {
+				client := mocks.NewMockPmaxClient(gomock.NewController(t))
+				client.EXPECT().GetReplicationCapabilities(gomock.Any()).Times(1).Return(&types.SymReplicationCapabilities{
+					SymmetrixCapability: []types.SymmetrixCapability{{SymmetrixID: "symID"}},
+				}, nil)
+				return client
+			},
+			symID:    "symID",
+			expected: &types.SymmetrixCapability{SymmetrixID: "symID"},
+			err:      nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			actual, err := tt.cache.Get(tt.ctx, tt.client(), tt.symID)
+			if !reflect.DeepEqual(err, tt.err) {
+				t.Errorf("expected error %v, but got %v", tt.err, err)
+			}
+			if !reflect.DeepEqual(actual, tt.expected) {
+				t.Errorf("expected %v, but got %v", tt.expected, actual)
+			}
+		})
+	}
+}
+
+func TestGetSGName(t *testing.T) {
+	tests := []struct {
+		name                   string
+		applicationPrefix      string
+		serviceLevel           string
+		storageResourcePool    string
+		expectedStorageGroupID string
+	}{
+		{
+			name:                   "empty application prefix",
+			applicationPrefix:      "",
+			serviceLevel:           "serviceLevel",
+			storageResourcePool:    "storageResourcePool",
+			expectedStorageGroupID: "csi-clusterPrefix-serviceLevel-storageResourcePool-SG",
+		},
+		{
+			name:                   "non-empty application prefix",
+			applicationPrefix:      "applicationPrefix",
+			serviceLevel:           "serviceLevel",
+			storageResourcePool:    "storageResourcePool",
+			expectedStorageGroupID: "csi-clusterPrefix-applicationPrefix-serviceLevel-storageResourcePool-SG",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := &PowerMax{
+				SymID:         "symID",
+				ClusterPrefix: "clusterPrefix",
+				client:        mocks.NewMockPmaxClient(gomock.NewController(t)),
+			}
+
+			actual := p.GetSGName(tt.applicationPrefix, tt.serviceLevel, tt.storageResourcePool)
+			if actual != tt.expectedStorageGroupID {
+				t.Errorf("expected storage group ID %s, but got %s", tt.expectedStorageGroupID, actual)
+			}
+		})
+	}
+}
+
+func TestGetVolumeIdentifier(t *testing.T) {
+	tests := []struct {
+		name           string
+		volumeName     string
+		clusterPrefix  string
+		expectedResult string
+	}{
+		{
+			name:           "short volume name",
+			volumeName:     "short-volume-name",
+			clusterPrefix:  "cluster-prefix",
+			expectedResult: "csi-cluster-prefix-short-volume-name",
+		},
+		{
+			name:           "long volume name",
+			volumeName:     "this-is-a-very-long-volume-name-that-exceeds-the-maximum-length",
+			clusterPrefix:  "cluster-prefix",
+			expectedResult: "csi-cluster-prefix-this-is-a-very-long-voleeds-the-maximum-length",
+		},
+		{
+			name:           "empty volume name",
+			volumeName:     "",
+			clusterPrefix:  "cluster-prefix",
+			expectedResult: "csi-cluster-prefix-",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := &PowerMax{
+				SymID:         "symID",
+				ClusterPrefix: tt.clusterPrefix,
+				client:        mocks.NewMockPmaxClient(gomock.NewController(t)),
+			}
+
+			actual := p.GetVolumeIdentifier(tt.volumeName)
+			if actual != tt.expectedResult {
+				t.Errorf("expected %s, but got %s", tt.expectedResult, actual)
+			}
+		})
+	}
+}
+
+func TestSRPCache_Get(t *testing.T) {
+	tests := []struct {
+		name           string
+		cache          SRPCache
+		client         func() *mocks.MockPmaxClient
+		symID          string
+		expectedResult []string
+		expectedError  error
+	}{
+		{
+			name: "cache not initialized",
+			cache: SRPCache{
+				identifiers: []string{"srp1", "srp2"},
+				time: CacheTime{
+					CreationTime:  time.Now().Add(-1 * time.Hour),
+					CacheValidity: SRPCacheValidity,
+				},
+			},
+			client: func() *mocks.MockPmaxClient {
+				client := mocks.NewMockPmaxClient(gomock.NewController(t))
+				return client
+			},
+			symID:          "symID",
+			expectedResult: []string{"srp1", "srp2"},
+			expectedError:  nil,
+		},
+		{
+			name: "cache expired",
+			cache: SRPCache{
+				identifiers: []string{"srp1", "srp2"},
+				time: CacheTime{
+					CreationTime:  time.Now().Add(-25 * time.Hour),
+					CacheValidity: SRPCacheValidity,
+				},
+			},
+			client: func() *mocks.MockPmaxClient {
+				client := mocks.NewMockPmaxClient(gomock.NewController(t))
+				client.EXPECT().GetStoragePoolList(gomock.Any(), "symID").Return(&types.StoragePoolList{
+					StoragePoolIDs: []string{"srp3", "srp4"},
+				}, nil)
+				return client
+			},
+			symID:          "symID",
+			expectedResult: []string{"srp3", "srp4"},
+			expectedError:  nil,
+		},
+		{
+			name: "error from client",
+			cache: SRPCache{
+				identifiers: []string{"srp1", "srp2"},
+				time: CacheTime{
+					CreationTime:  time.Now().Add(-25 * time.Hour),
+					CacheValidity: SRPCacheValidity,
+				},
+			},
+			client: func() *mocks.MockPmaxClient {
+				client := mocks.NewMockPmaxClient(gomock.NewController(t))
+				client.EXPECT().GetStoragePoolList(gomock.Any(), "symID").Return(nil, fmt.Errorf("some error"))
+				return client
+			},
+			symID:          "symID",
+			expectedResult: nil,
+			expectedError:  fmt.Errorf("some error"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			actual, err := tt.cache.Get(context.Background(), tt.client(), tt.symID)
+			if !reflect.DeepEqual(err, tt.expectedError) {
+				t.Errorf("expected error %v, but got %v", tt.expectedError, err)
+			}
+			if !reflect.DeepEqual(actual, tt.expectedResult) {
+				t.Errorf("expected %v, but got %v", tt.expectedResult, actual)
+			}
+		})
+	}
+}
+
+func TestPowerMax_GetSRPs(t *testing.T) {
+	tests := []struct {
+		name           string
+		symID          string
+		client         func() *mocks.MockPmaxClient
+		expectedResult []string
+		expectedError  error
+	}{
+		{
+			name:  "cache not initialized",
+			symID: "symID",
+			client: func() *mocks.MockPmaxClient {
+				client := mocks.NewMockPmaxClient(gomock.NewController(t))
+				client.EXPECT().GetStoragePoolList(gomock.Any(), "symID").Return(&types.StoragePoolList{
+					StoragePoolIDs: []string{"srp1", "srp2"},
+				}, nil)
+				return client
+			},
+			expectedResult: []string{"srp1", "srp2"},
+			expectedError:  nil,
+		},
+		{
+			name:  "cache expired",
+			symID: "symID",
+			client: func() *mocks.MockPmaxClient {
+				client := mocks.NewMockPmaxClient(gomock.NewController(t))
+				client.EXPECT().GetStoragePoolList(gomock.Any(), "symID").Return(&types.StoragePoolList{
+					StoragePoolIDs: []string{"srp3", "srp4"},
+				}, nil)
+				return client
+			},
+			expectedResult: []string{"srp3", "srp4"},
+			expectedError:  nil,
+		},
+		{
+			name:  "error from client",
+			symID: "symID",
+			client: func() *mocks.MockPmaxClient {
+				client := mocks.NewMockPmaxClient(gomock.NewController(t))
+				client.EXPECT().GetStoragePoolList(gomock.Any(), "symID").Return(nil, fmt.Errorf("some error"))
+				return client
+			},
+			expectedResult: nil,
+			expectedError:  fmt.Errorf("some error"),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := &PowerMax{
+				SymID:  tt.symID,
+				client: tt.client(),
+				storageResourcePoolCache: SRPCache{
+					identifiers: []string{"srp1", "srp2"},
+					time: CacheTime{
+						CreationTime:  time.Now().Add(-25 * time.Hour),
+						CacheValidity: SRPCacheValidity,
+					},
+				},
+			}
+
+			actual, err := p.GetSRPs(context.Background())
+			if !reflect.DeepEqual(err, tt.expectedError) {
+				t.Errorf("expected error %v, but got %v", tt.expectedError, err)
+			}
+			if !reflect.DeepEqual(actual, tt.expectedResult) {
+				t.Errorf("expected %v, but got %v", tt.expectedResult, actual)
+			}
+		})
+	}
+}
+
+func TestPowerMax_GetServiceLevels(t *testing.T) {
+	tests := []struct {
+		name           string
+		expectedResult []string
+	}{
+		{
+			name:           "default service levels",
+			expectedResult: []string{"Diamond", "Platinum", "Gold", "Silver", "Bronze", "Optimized", "None"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := &PowerMax{
+				SymID:  "symID",
+				client: &mocks.MockPmaxClient{},
+			}
+
+			actual, err := p.GetServiceLevels()
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+			}
+			if !reflect.DeepEqual(actual, tt.expectedResult) {
+				t.Errorf("expected %v, but got %v", tt.expectedResult, actual)
+			}
+		})
+	}
+}
+
+func TestPowerMax_GetDefaultServiceLevel(t *testing.T) {
+	tests := []struct {
+		name           string
+		expectedResult string
+	}{
+		{
+			name:           "default service level",
+			expectedResult: "Optimized",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := &PowerMax{
+				SymID:  "symID",
+				client: &mocks.MockPmaxClient{},
+			}
+
+			actual := p.GetDefaultServiceLevel()
+			if !reflect.DeepEqual(actual, tt.expectedResult) {
+				t.Errorf("expected %v, but got %v", tt.expectedResult, actual)
+			}
+		})
+	}
+}