private TestResponse FailureForSoftOffGetBladeMezzPassThroughMode(int bladeId)
        {
            TestCase testCase = new TestCase("FailureForSoftOffGetBladeMezzPassThroughMode", 24173);

            CmTestLog.Info(string.Format(
                "\n !!!!!!Verifying {0} Returns Failure for Server Blade Soft-Powered Off. WorkItemId: {1}!!!!!!",
                this.currentApi, testCase.WorkItemId));
            TestResponse response = new TestResponse();

            BladeMezzPassThroughModeResponse getBladeMezzResponse = new BladeMezzPassThroughModeResponse();
            this.TestChannelContext = this.ListTestChannelContexts[(int)WCSSecurityRole.WcsCmAdmin];

            // Soft-Power Off server blade
            BladeResponse bladeResponse = this.TestChannelContext.SetBladeOff(bladeId);
            if (bladeResponse.completionCode != CompletionCode.Success)
            {
                LogMessage.Message = string.Format(
                    "{0}: Unable to soft-power off server blade {1}",
                    this.currentApi, bladeId);
                LogMessage.Log(LogMessage.MessageType.Failure, ref response);
            }
            else
            {
                CmTestLog.Info(string.Format("Soft-powered off blade {0}. Thread sleeping for {1} seconds...",
                   bladeId, CmConstants.BladePowerOffSeconds));
                Thread.Sleep(TimeSpan.FromSeconds(CmConstants.BladePowerOffSeconds));

                // Call API and verify Failure
                getBladeMezzResponse = this.TestChannelContext.GetBladeMezzPassThroughMode(bladeId);
                if (getBladeMezzResponse.completionCode != CompletionCode.Failure)
                {
                    LogMessage.Message = string.Format(
                        "{0}: Command returns completion code {1} after blade {2} is soft-powered off",
                        this.currentApi, getBladeMezzResponse.completionCode, bladeId);
                    LogMessage.Log(LogMessage.MessageType.Failure, ref response);
                }
                else
                {
                    LogMessage.Message = string.Format(
                        "{0}: Command successfully returns completion code Failure after blade {1} is soft-powered off",
                        this.currentApi, bladeId);
                    LogMessage.Log(LogMessage.MessageType.Success, ref response);
                }
            }

            // Code clean-up. Soft-power on blade
            bladeResponse = this.TestChannelContext.SetBladeOn(bladeId);
            if (bladeResponse.completionCode != CompletionCode.Success)
            {
                LogMessage.Message = string.Format(
                    "{0}: Unable to soft-power on server blade {1}",
                    this.currentApi, bladeId);
                LogMessage.Log(LogMessage.MessageType.Failure, ref response);
                return response;
            }

            CmTestLog.Info(string.Format("Soft-powered on blade {0}. Thread sleeping for {1} seconds...",
                bladeId, CmConstants.BladePowerOnSeconds));
            Thread.Sleep(TimeSpan.FromSeconds(CmConstants.BladePowerOnSeconds));

            testCase.LogPassOrFail(ref response, this.currentApi);

            return response;
        }
        /// <summary>
        /// Get the Pass-through Mode for FPGA Mezzanine
        /// </summary>
        /// <param name="bladeId"></param>
        /// <returns>BladeMezzPassThroughModeResponse</returns>
        public BladeMezzPassThroughModeResponse GetBladeMezzPassThroughMode(int bladeId)
        {
            string apiName = "GetBladeMezzPassThroughMode";

            // Initialize Response
            Tracer.WriteInfo(string.Format("Received {0}(bladeId: {1})", apiName, bladeId));
            Tracer.WriteUserLog(string.Format("Invoked {0}(bladeId: {1})", apiName, bladeId));

            BladeMezzPassThroughModeResponse getPassThroughResponse = new BladeMezzPassThroughModeResponse();
            getPassThroughResponse.bladeNumber = bladeId;

            try
            {
                // Validate Request
                Contracts.ChassisResponse varResponse = ValidateRequest(apiName, bladeId);
                if (varResponse.completionCode != Contracts.CompletionCode.Success)
                {
                    getPassThroughResponse.completionCode = varResponse.completionCode;
                    getPassThroughResponse.statusDescription = varResponse.statusDescription;
                    return getPassThroughResponse;
                }

                // Invoke GetMezzPassThroughMode to send MasterWriteRead IPMI command to blade BMC
                bool passThroughMode;
                getPassThroughResponse.completionCode = ChassisManagerUtil.GetContractsCompletionCodeMapping(
                    (byte)WcsBladeMezz.GetMezzPassThroughMode(bladeId, out passThroughMode, apiName));

                // Set passThroughModeEnabled
                getPassThroughResponse.passThroughModeEnabled = passThroughMode;
            }
            catch (Exception ex)
            {
                Tracer.WriteError(string.Format("Exception occured in {0}(): {1}", apiName, ex));
                getPassThroughResponse.completionCode = Contracts.CompletionCode.Failure;
                getPassThroughResponse.statusDescription = getPassThroughResponse.completionCode.ToString() + ": " + ex.Message;
            }

            return getPassThroughResponse;
        }
        private TestResponse FailureForEmptyGetBladeMezzPassThroughMode(int bladeId)
        {
            TestCase testCase = new TestCase("FailureForEmptyGetBladeMezzPassThroughMode", 24170);

            CmTestLog.Info(string.Format("\n !!!!!!Verifying {0} Returns Failure for Empty Location. WorkItemId: {1}!!!!!!",
                this.currentApi, testCase.WorkItemId));
            TestResponse response = new TestResponse();

            BladeMezzPassThroughModeResponse getBladeMezzResponse = new BladeMezzPassThroughModeResponse();
            this.TestChannelContext = this.ListTestChannelContexts[(int)WCSSecurityRole.WcsCmAdmin];

            // Call API and verify Failure
            getBladeMezzResponse = this.TestChannelContext.GetBladeMezzPassThroughMode(bladeId);
            LogMessage.Message = string.Format(
                "{0}: Command for empty location with completion code {1} and blade Id {2}",
                    this.currentApi, getBladeMezzResponse.completionCode, bladeId);

            if (getBladeMezzResponse.completionCode != CompletionCode.Failure)
                LogMessage.Log(LogMessage.MessageType.Failure, ref response);
            else
                LogMessage.Log(LogMessage.MessageType.Success, ref response);

            testCase.LogPassOrFail(ref response, this.currentApi);

            return response;
        }
        private void CallAndVerifyGetBladeMezzPassThroughMode(int bladeId, ref TestResponse response,
            string passThroughModeEnabled)
        {
            BladeMezzPassThroughModeResponse getBladeMezzResponse = new BladeMezzPassThroughModeResponse();

            getBladeMezzResponse = this.TestChannelContext.GetBladeMezzPassThroughMode(bladeId);
            LogMessage.Message = string.Format(
                "{0}: Command returns completion code {1} and passThroughModeEnabled {2} for blade Id {3}",
                "GetBladeMezzPassThroughMode", getBladeMezzResponse.completionCode,
                getBladeMezzResponse.passThroughModeEnabled, bladeId);

            if (getBladeMezzResponse.completionCode != CompletionCode.Success)
                LogMessage.Log(LogMessage.MessageType.Failure, ref response);
            else if (passThroughModeEnabled != null &&
                getBladeMezzResponse.passThroughModeEnabled.ToString().ToLower() != passThroughModeEnabled)
                LogMessage.Log(LogMessage.MessageType.Failure, ref response);
            else
                LogMessage.Log(LogMessage.MessageType.Success, ref response);
        }
        private TestResponse AllGroupsCanExecuteGetBladeMezzPassThroughMode(int bladeId)
        {
            TestCase testCase = new TestCase("AllGroupsCanExecuteGetBladeMezzPassThroughMode", 24166);

            CmTestLog.Info(string.Format("\n !!!!!!Verifying {0} Can Be Executed By All Users. WorkItemId: {1}.!!!!!!",
                this.currentApi, testCase.WorkItemId));
            TestResponse response = new TestResponse();

            // Loop through different user types
            foreach (WCSSecurityRole roleId in Enum.GetValues(typeof(WCSSecurityRole)))
            {
                BladeMezzPassThroughModeResponse getBladeMezzResponse = new BladeMezzPassThroughModeResponse();

                // Use different user context
                this.TestChannelContext = this.ListTestChannelContexts[(int)roleId];

                // Get Pass Through Mode and verify
                getBladeMezzResponse = this.TestChannelContext.GetBladeMezzPassThroughMode(bladeId);

                LogMessage.Message = string.Format(
                        "{0}: Command returned completion code {1} for user {2} and blade Id {3}",
                        this.currentApi, getBladeMezzResponse.completionCode,
                        Enum.GetName(typeof(WCSSecurityRole), roleId), bladeId);

                if (getBladeMezzResponse.completionCode != CompletionCode.Success)
                    LogMessage.Log(LogMessage.MessageType.Failure, ref response);
                else
                    LogMessage.Log(LogMessage.MessageType.Success, ref response);
            }

            testCase.LogPassOrFail(ref response, this.currentApi);

            return response;
        }
        private TestResponse ParameterOutOfRangeBladeIdGetBladeMezzPassThroughMode()
        {
            TestCase testCase = new TestCase("ParameterOutOfRangeBladeIdGetBladeMezzPassThroughMode", 24177);

            CmTestLog.Info(string.Format(
                "\n !!!!!!Verifying {0} Returns ParameterOutOfRange for Invalid BladeId. WorkItemId: {1}!!!!!!",
                this.currentApi, testCase.WorkItemId));
            TestResponse response = new TestResponse();

            BladeMezzPassThroughModeResponse getBladeMezzResponse = new BladeMezzPassThroughModeResponse();
            this.TestChannelContext = this.ListTestChannelContexts[(int)WCSSecurityRole.WcsCmAdmin];

            foreach (int invalidValue in Enum.GetValues(typeof(InvalidBladeId)))
            {
                getBladeMezzResponse = this.TestChannelContext.GetBladeMezzPassThroughMode(invalidValue);
                LogMessage.Message = string.Format(
                        "{0}: Command returns completion code {1} for invalid Blade Id {2}",
                        this.currentApi, getBladeMezzResponse.completionCode, invalidValue);

                if (getBladeMezzResponse.completionCode != CompletionCode.ParameterOutOfRange)
                    LogMessage.Log(LogMessage.MessageType.Failure, ref response);
                else
                    LogMessage.Log(LogMessage.MessageType.Success, ref response);
            }

            testCase.LogPassOrFail(ref response, currentApi);

            return response;
        }
        /// <summary>
        /// command specific implementation 
        /// argVal command class member has all user-entered command argument indicators and parameter values
        /// Currently just prints all argument indicators and argument values
        /// </summary>
        internal override void commandImplementation()
        {
            BladeMezzPassThroughModeResponse myResponse = new BladeMezzPassThroughModeResponse();

            try
            {
                if (this.argVal.ContainsKey('i'))
                {
                    dynamic bladeId = null;
                    this.argVal.TryGetValue('i', out bladeId);
                    myResponse = WcsCli2CmConnectionManager.channel.GetBladeMezzPassThroughMode((int)bladeId);
                }
            }
            catch (Exception ex)
            {
                SharedFunc.ExceptionOutput(ex);
                return;
            }

            if (myResponse == null)
            {
                Console.WriteLine(WcsCliConstants.serviceResponseEmpty);
                return;
            }

            if (this.argVal.ContainsKey('i'))
            {

                if (ResponseValidation.ValidateBladeResponse(myResponse.bladeNumber, null, myResponse, false))
                {
                    if (myResponse.passThroughModeEnabled == true)
                        Console.WriteLine(WcsCliConstants.commandSuccess + " Blade " + myResponse.bladeNumber + ": Pass Through Mode Enabled");
                    else
                        Console.WriteLine(WcsCliConstants.commandSuccess + " Blade " + myResponse.bladeNumber + ": Pass Through Mode Not Enabled");
                }
            }
        }