public static bool Run() { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ string expectedCoefficients = ""; string tableValues = ""; //Referenzwerte kommen von Jochen oder Manuel von PC-F bool isPassed = Execution.Container.SelectTabBaseSettings(); isPassed &= Flows.ConfigureBaseSettings.BaseConfiguration("Fine tuning settings", string.Empty, string.Empty, string.Empty, string.Empty); isPassed &= Execution.Container.SelectTabLiquidProperties(); isPassed &= AssertFunctions.AreEqual(true, Validation.CheckAvailabilityOfTabPages.IsLiquidPropertiesTabPageAvailable(), "Verify that Liquid properties tab is active."); isPassed &= Execution.SetTableValues.SetValues(StringToListConverter.Run(tableValues)); isPassed &= AssertFunctions.AreEqual(true, DeviceFunctionLoader.CoDIA.ConcentrationV2.Functions.MenuArea.Toolbar.Validation.IsCalculationButtonEnabled.Run(), "Verifies that calculate button is enabled."); isPassed &= Execution.CoefficientsOverview.CompareCoefficients("0.01", StringToStringArrayConverter.Run(expectedCoefficients)); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_EnterDataForFineTuning passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_EnterDataForFineTuning failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
public static bool Run() { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = Execution.Container.SelectTabBaseSettings(); isPassed &= Flows.ConfigureBaseSettings.BaseConfiguration("Predefined liquid", string.Empty, string.Empty, string.Empty, string.Empty); isPassed &= AssertFunctions.AreEqual(true, DeviceFunctionLoader.CoDIA.ConcentrationV2.Functions.MenuArea.Toolbar.Validation.IsCalculationButtonEnabled.Run(), "Verifies that calculate button is enabled."); isPassed &= AssertFunctions.AreEqual(true, Validation.CheckAvailabilityOfTabPages.IsBaseSettingsTabPageAvailable(), "Verifies that Base settings tab is active."); isPassed &= AssertFunctions.AreEqual(false, Validation.CheckAvailabilityOfTabPages.IsReferenceValuesTabPageAvailable(), "Verifies that Reference Values tab is inactive."); isPassed &= AssertFunctions.AreEqual(true, Validation.CheckAvailabilityOfTabPages.IsLiquidPropertiesTabPageAvailable(), "Verifies that Liquid properties tab is active."); isPassed &= AssertFunctions.AreEqual(true, Validation.CheckAvailabilityOfTabPages.IsCoefficientOverviewTabPageAvailable(), "Verifies that Coefficients overview tab is active."); isPassed &= AssertFunctions.AreEqual(true, Validation.CheckAvailabilityOfTabPages.IsExpertResultsTabPageAvailable(), "Verifies that expert results tab is active."); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_ConfigureCalculationBaseToPredefinedLiquid passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_ConfigureCalculationBaseToPredefinedLiquid failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
/// <summary> /// Selects tank type 'Spherical tank' and configures its parameter if needed. Use empty strings if you do not want to configure a parameter. /// </summary> /// <param name="height"> /// The height. /// </param> /// <param name="diameter"> /// The diameter. /// </param> /// <returns> /// <c>true</c> if configuration was successful, <c>false</c> otherwise. /// </returns> public bool Run(string height, string diameter) { bool result = Execution.SelectTab.Run(1); result &= Execution.SetTankType.Run("Spherical tank"); if (this.IsValid(height)) { result &= Execution.ConfigureTankParameter.SetSphericalTankHeight(height); result &= AssertFunctions.AreEqual(height, Execution.ConfigureTankParameter.GetSphericalTankHeight(), "Checking whether the height has been set correctly."); } if (this.IsValid(diameter)) { result &= Execution.ConfigureTankParameter.SetSphericalTankDiameter(diameter); result &= AssertFunctions.AreEqual(diameter, Execution.ConfigureTankParameter.GetSphericalTankDiameter(), "Checking whether the diameter has been set correctly."); } if (result) { Log.Info(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Configuring finished successfully."); } else { Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "An error occurred during configuring."); } return(result); }
public static bool Run() { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = Flows.New.Run(); isPassed &= AssertFunctions.AreEqual(true, Validation.IsNewButtonEnabled.Run(), "Checking that new button is enabled"); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CreateNewConcentration passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CreateNewConcentration failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
public static bool Run() { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = CommonFlows.WriteDataToDevice.Run(); isPassed &= AssertFunctions.AreEqual(string.Empty, CommonFlows.GetCriticalError.Run()[0], "Checking that there is no critical error."); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_FdtDownload passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_FdtDownload failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
public static bool Run(string fileName) { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = Flows.Import.Run(fileName); isPassed &= Execution.Container.SelectTabExpertResults(); Execution.TakeScreenshotOfModule.Run(); isPassed &= AssertFunctions.AreEqual(string.Empty, CommonFlows.GetCriticalError.Run()[0], "Checking that there is no critical error."); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_ImportConcentrationFile passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_ImpTC_ImportConcentrationFileort failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
public static bool Run() { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = Flows.New.Run(); isPassed &= Execution.Container.SelectTabCoefficientsOverview(); isPassed &= AssertFunctions.AreEqual(false, Execution.CoefficientsOverview.AreCalculatedCoefficientsAvailable(), "Verify that coefficients are not displayed anymore after pressing the 'New' button."); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_DeleteConcentrationData passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_DeleteConcentrationData failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
public static bool Run(string fileName, int timeoutInMilliseconds) { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = CommonFlows.PrintDeviceInformation.Run(fileName, timeoutInMilliseconds); isPassed &= AssertFunctions.AreEqual(string.Empty, CommonFlows.GetCriticalError.Run()[0], "Checking that there is no critical error."); /*TODO: * - Vergleiche Dokument mit Referenzwerten aus einem Referenzdokument * - Parameterwerte Online sind gedruckt * - Einheiten sind gedruckt * - Angewählte Module wurden gedruckt */ if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_FdtPrint passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_FdtPrint failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
public static bool Run() { StartUp(); bool isPassed = Flows.SelectMode.Run(2); // Online vs .deh isPassed &= Flows.LoadDataset2.Run(); isPassed &= Flows.Compare.Run(600000); isPassed &= AssertFunctions.AreEqual(string.Empty, CommonFlows.GetCriticalError.Run()[0], "Checking that there is no critical error."); // TODO: Validate comparison result if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CompareOnlineWithDehFile passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CompareOnlineWithDehFile failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
public static bool Run(string pathToDehFile, int timeUntilCancelingInMilliseconds) { StartUp(); bool isPassed = Flows.SelectMode.Run(2); // Online vs .deh isPassed &= Flows.LoadDataset2.Run(pathToDehFile); isPassed &= Flows.CancelCompare.Run(timeUntilCancelingInMilliseconds); Execution.TakeScreenshotOfModule.Run(); isPassed &= AssertFunctions.AreEqual(string.Empty, CommonFlows.GetCriticalError.Run()[0], "Checking that there is no critical error."); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CancelCompareOnlineWithDehFile passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CancelCompareOnlineWithDehFile failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
public static bool Run() { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ string[] expectedCoefficients = { "-6.8590", "13.8082", "-10.1612", "3.7286", "-0.5164", "0.4027", "42.0713", "-46.4358", "-0.0638", "-0.3975", "0.2037", "1.2887" }; bool isPassed = Flows.Calculate.Run(); isPassed &= AssertFunctions.AreEqual(string.Empty, CommonFlows.GetCriticalError.Run()[0], "Checking that there is no critical error."); isPassed &= Execution.Container.SelectTabCoefficientsOverview(); isPassed &= Execution.CoefficientsOverview.AreCalculatedCoefficientsAvailable(); isPassed &= Execution.CoefficientsOverview.CompareCoefficients("0.01", expectedCoefficients); isPassed &= Execution.Container.SelectTabExpertResults(); Execution.TakeScreenshotOfModule.Run(); Log.Info(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Please have a look at the screenshot to verify Concentration Expert Results"); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CalculateCoefficientsAndCheckOutput passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CalculateCoefficientsAndCheckOutput failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
/// <summary> /// Selects tank type 'Modular tank' and configures its parameter if needed. Use empty strings if you do not want to configure a parameter. /// </summary> /// <param name="height"> /// The height. /// </param> /// <param name="view"> /// The view. /// </param> /// <returns> /// <c>true</c> if configuration was successful, <c>false</c> otherwise. /// </returns> public bool Run(string height, string view) { bool result = Execution.SelectTab.Run(1); result &= Execution.SetTankType.Run("Modular tank"); if (height != string.Empty) { result &= Execution.ConfigureTankParameter.SetModularTankHeight(height); result &= AssertFunctions.AreEqual(height, Execution.ConfigureTankParameter.GetModularTankHeight(), "Checking whether the height has been set correctly."); } if (view != string.Empty) { result &= Execution.ConfigureTankParameter.SetModularTankView(view); result &= AssertFunctions.AreEqual(view, Execution.ConfigureTankParameter.GetModularTankView(), "Checking whether the view has been set correctly."); } if (result) { Log.Info(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Configuring finished successfully."); } else { Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "An error occurred during configuring."); } return(result); }
public static bool Run() { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = AssertFunctions.AreEqual(false, Validation.CheckAvailabilityOfTabPages.IsLiquidPropertiesTabPageAvailable(), "Verify that Liquid Properties tab is not active."); isPassed &= AssertFunctions.AreEqual(true, Validation.CheckAvailabilityOfTabPages.IsBaseSettingsTabPageAvailable(), "Verify that Base settings tab is active."); isPassed &= AssertFunctions.AreEqual(true, Validation.CheckAvailabilityOfTabPages.IsCoefficientOverviewTabPageAvailable(), "Verify that Coefficient Overview tab is active."); isPassed &= AssertFunctions.AreEqual(true, Validation.CheckAvailabilityOfTabPages.IsExpertResultsTabPageAvailable(), "Verify that Expert Results tab is active."); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CheckTabPageAvailabilityDefault passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CheckTabPageAvailabilityDefault failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
public static bool Run() { StartUp(); bool isPassed = Flows.SelectMode.Run(3); isPassed &= Flows.LoadDataset1.Run(); isPassed &= Flows.LoadDataset2.Run(); isPassed &= Flows.CancelCompare.Run(2000); Execution.TakeScreenshotOfModule.Run(); isPassed &= AssertFunctions.AreEqual(string.Empty, CommonFlows.GetCriticalError.Run()[0], "Checking that there is no critical error."); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CancelCompareDehWithDeh passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CancelCompareDehWithDeh failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
public static bool Run(string pathToSilWhgParameter) { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = Execution.SilWhgFunctions.NavigateToSilWhgWizard(pathToSilWhgParameter); isPassed &= Validation.SilWhg.WaitUntilSilSequenceStartPageIsShown(15000); isPassed &= AssertFunctions.AreEqual(true, Validation.SilWhg.IsSilSequenceStartPageShown(), "Determining whether SIL/WHG sequence start page is shown."); isPassed &= AssertFunctions.AreEqual(false, Validation.SilWhg.IsCancelButtonActive(), "Determining whether Cancel button is inactive."); isPassed &= AssertFunctions.AreEqual(false, Validation.SilWhg.IsNextButtonActive(), "Determining whether Next button is inactive."); isPassed &= AssertFunctions.AreEqual("Valid", Execution.Application.GetParameter("Set write protection:").ParameterState.ToString(), "Determining whether Set write protection: text field is available."); Execution.TakeScreenshotOfModule.OnlineParameterization(); isPassed &= DeviceFunctionLoader.CoDIA.Parameterization.Functions.MenuArea.Toolbar.Execution.GoToHomeLocation.Run(); isPassed &= Validation.SilWhg.WaitUntilSilSequenceStartPageIsDisappeared(15000); Execution.TakeScreenshotOfModule.OnlineParameterization(); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_ReturnToHomeFromWhgSequence passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_ReturnToHomeFromWhgSequence failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
public static bool Run() { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = Flows.Calculate.Run(); isPassed &= AssertFunctions.AreEqual(string.Empty, CommonFlows.GetCriticalError.Run()[0], "Checking that there is no critical error."); isPassed &= Execution.Container.SelectTabCoefficientsOverview(); isPassed &= Execution.CoefficientsOverview.AreCalculatedCoefficientsAvailable(); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CalculateCoefficients passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CalculateCoefficients failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
/// <summary> /// The execute shared functions. /// </summary> /// <param name="comparingAccuracy"> /// The comparing accuracy. /// </param> /// <param name="expectedCoefficients"> /// The expected coefficients. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> private static bool ExecuteSharedFunctions(string comparingAccuracy, string expectedCoefficients) { bool isPassed; isPassed = Execution.Container.SelectTabCoefficientsOverview(); isPassed &= AssertFunctions.AreEqual(true, Execution.CoefficientsOverview.AreCalculatedCoefficientsAvailable(), AssertMessage); isPassed &= AssertFunctions.AreEqual(true, Execution.CoefficientsOverview.CompareCoefficients(comparingAccuracy, StringToStringArrayConverter.Run(expectedCoefficients)), "Verify that coefficients have been loaded correctly."); isPassed &= Execution.Container.SelectTabExpertResults(); Execution.TakeScreenshotOfModule.Run(); return(isPassed); }
public static bool Run(string pathToSilWhgParameter, string silWhgCode, int timeoutForCanceling, int timeoutForNextButton) { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = Execution.SilWhgFunctions.NavigateToSilWhgWizard(pathToSilWhgParameter); isPassed &= Validation.SilWhg.WaitUntilSilSequenceStartPageIsShown(timeoutForCanceling); isPassed &= AssertFunctions.AreEqual(true, Validation.SilWhg.IsSilSequenceStartPageShown(), "Determining whether SIL sequence start page is shown."); isPassed &= AssertFunctions.AreEqual(false, Validation.SilWhg.IsCancelButtonActive(), "Determining whether Cancel button is inactive."); isPassed &= AssertFunctions.AreEqual(false, Validation.SilWhg.IsNextButtonActive(), "Determining whether Next button is inactive."); isPassed &= AssertFunctions.AreEqual("Valid", Execution.Application.GetParameter("Set write protection:").ParameterState.ToString(), "Determining whether Set write protection: text field is available."); Execution.TakeScreenshotOfModule.OnlineParameterization(); isPassed &= Execution.SilWhgFunctions.SetSilWhgParameter("Set write protection:", silWhgCode); isPassed &= Validation.SilWhg.WaitUntilNextButtonIsActive(timeoutForNextButton); isPassed &= Execution.SilWhgFunctions.Next(); isPassed &= AssertFunctions.AreEqual(false, Validation.SilWhg.IsNavigationTreeShown(), "Determining whether Navigation tree is not visible any longer."); isPassed &= AssertFunctions.AreEqual(true, Validation.SilWhg.IsCancelButtonActive(), "Determining whether Cancel button is active."); isPassed &= AssertFunctions.AreEqual(false, Validation.SilWhg.IsNextButtonActive(), "Determining whether Next button is inactive."); isPassed &= AssertFunctions.AreEqual(true, Validation.SilWhg.IsPreviousButtonActive(), "Determining whether Previous button is active."); Execution.TakeScreenshotOfModule.OnlineParameterization(); isPassed &= Execution.SilWhgFunctions.SetSilWhgParameter("Commissioning:", "Expert mode"); isPassed &= Validation.SilWhg.WaitUntilNextButtonIsActive(timeoutForNextButton); isPassed &= Execution.SilWhgFunctions.Next(); isPassed &= AssertFunctions.AreEqual(true, Validation.SilWhg.IsCancelButtonActive(), "Determining whether Cancel button is active."); isPassed &= AssertFunctions.AreEqual(true, Validation.SilWhg.IsPreviousButtonActive(), "Determining whether Previous button is active."); isPassed &= Execution.SilWhgFunctions.Cancel(); isPassed &= Validation.SilWhg.WaitUntilCancelingIsFinished(timeoutForCanceling); isPassed &= AssertFunctions.AreEqual(true, Validation.SilWhg.IsSilSequenceStartPageShown(), "Determining whether SIL sequence start page is shown."); isPassed &= AssertFunctions.AreEqual(true, Validation.SilWhg.IsNavigationTreeShown(), "Determining whether Navigation tree is visible again."); Execution.TakeScreenshotOfModule.OnlineParameterization(); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CancelSilSequence passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CancelSilSequence failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
/// <summary> /// Opens the tab Settings and configures the General Settings parameter. Use string.empty if you want to skip a parameter. /// </summary> /// <param name="linearizationType">The linearization type.</param> /// <param name="emptyCalibration">The empty calibration.</param> /// <param name="fullCalibration">The full calibration.</param> /// <param name="distanceUnit">The distance unit.</param> /// <param name="levelUnit">The level unit.</param> /// <returns><c>true</c> if configuration successful, <c>false</c> otherwise.</returns> public bool Run(string linearizationType, string emptyCalibration, string fullCalibration, string distanceUnit, string levelUnit) { bool result = Execution.SelectTab.Run(2); var pattern = new Regex(@"\W"); if (linearizationType != string.Empty) { result &= Execution.ConfigureSettingsTab.SetGeneralSettingsLinearizationType(linearizationType); string testValue = pattern.Replace(linearizationType, string.Empty); string referenceValue = pattern.Replace(Execution.ConfigureSettingsTab.GetGeneralSettingsLinearizationType(), string.Empty); result &= AssertFunctions.AreEqual(testValue, referenceValue, "Checking whether the linearizationType has been set correctly."); } if (emptyCalibration != string.Empty) { result &= Execution.ConfigureSettingsTab.SetGeneralSettingsEmptyCalibration(emptyCalibration); result &= AssertFunctions.AreEqual(emptyCalibration, Execution.ConfigureSettingsTab.GetGeneralSettingsEmptyCalibration(), "Checking whether the empty calibration has been set correctly."); } if (fullCalibration != string.Empty) { result &= Execution.ConfigureSettingsTab.SetGeneralSettingsFullCalibration(fullCalibration); result &= AssertFunctions.AreEqual(fullCalibration, Execution.ConfigureSettingsTab.GetGeneralSettingsFullCalibration(), "Checking whether the full calibration has been set correctly."); } if (distanceUnit != string.Empty) { result &= Execution.ConfigureSettingsTab.SetGeneralSettingsDistanceUnit(distanceUnit); result &= AssertFunctions.AreEqual(distanceUnit, Execution.ConfigureSettingsTab.GetGeneralSettingsDistanceUnit(), "Checking whether the distanceUnit has been set correctly."); } if (levelUnit != string.Empty) { result &= Execution.ConfigureSettingsTab.SetGeneralSettingsLevelUnit(levelUnit); result &= AssertFunctions.AreEqual(levelUnit, Execution.ConfigureSettingsTab.GetGeneralSettingsLevelUnit(), "Checking whether the levelUnit has been set correctly."); } if (result) { Log.Info(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Configuring settings finished successfully."); } else { Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "An error occurred. Configuration was not successful."); } return(result); }
public static bool Run() { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ // Dummy-Values um Änderungen in der Berechnung festzustellen string expectedCoefficients = "-0.0533;-1.3581;3.4876;-2.0645;0.3985;0.0000;0.0000;0.0000;0.0000;0.0000;0.0000;0.0000"; string tableValues = "5;-10;0.5;10;0;0.6;15;10;0.7;20;20;0.8;25;30;0.9;30;40;1;35;50;1.1;40;60;1.2;45;70;1.3;50;75;1.4;55;80;1.5;60;85;1.6;65;90;1.7;70;95;1.8"; // TODO: // Referenzwerte kommen von Jochen oder Manuel von PC-F bool isPassed = true; // = Execution.Container.SelectTabBaseSettings(); isPassed &= Flows.ConfigureBaseSettings.BaseConfiguration("Liquid properties", string.Empty, string.Empty, string.Empty, string.Empty); isPassed &= AssertFunctions.AreEqual(true, Validation.CheckAvailabilityOfTabPages.IsLiquidPropertiesTabPageAvailable(), "Verify that Liquid properties tab is active."); isPassed &= Execution.Container.SelectTabLiquidProperties(); Execution.LiquidProperties.InputFormat = "List"; Execution.TakeScreenshotOfModule.Run(); isPassed &= Execution.SetTableValues.SetValues(StringToListConverter.Run(tableValues)); isPassed &= Execution.LiquidProperties.Recalculate(); isPassed &= Execution.Container.SelectTabCoefficientsOverview(); isPassed &= Execution.CoefficientsOverview.CompareCoefficients("0.01", StringToStringArrayConverter.Run(expectedCoefficients)); isPassed &= Execution.Container.SelectTabLiquidProperties(); Log.Info(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Please have a look at the screenshot to verify Concentration Table Validity"); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CalculateCoefficients passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CalculateCoefficients failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
/// <summary> /// Opens the tab Settings and configures the User Settings parameter. /// </summary> /// <param name="unitAfterLinearization">The unit after linearization.</param> /// <returns><c>true</c> if configuration successful, <c>false</c> otherwise.</returns> public bool Run(string unitAfterLinearization) { bool result = Execution.SelectTab.Run(2); if (this.IsValid(unitAfterLinearization)) { result &= Execution.ConfigureSettingsTab.SetUserSettingsUnitAfterLinearization(unitAfterLinearization); result &= AssertFunctions.AreEqual(unitAfterLinearization, Execution.ConfigureSettingsTab.GetUserSettingsUnitAfterLinearization(), "Checking whether the unitAfterLinearization has been set correctly."); } if (result) { Log.Info(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Configuring user settings finished successfully."); } else { Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "An error occurred. Configuration was not successful."); } return(result); }
public static bool Run(int row, int column, string referenceValue) { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = AssertFunctions.AreEqual(referenceValue, Execution.GetValuesFromTable.SingleValue(row, column), "Checking whether table value matches reference value."); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CompareTableValue passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CompareTableValue failed."); } TearDown(); return(isPassed); }
public static bool Run(string value) { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = AssertFunctions.AreEqual(true, Execution.Information.CheckIfInfoContains(value), "Checking whether the Historom module info message contains a specified string."); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CheckHistoromInfoMessage passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CheckHistoromInfoMessage failed."); } TearDown(); return(isPassed); }
public static bool Run() { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = AssertFunctions.AreEqual(true, Validation.IsCalculateButtonInactive.Run(), "Button 'Calculate should be inactive'."); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_IsCalculateButtonInactive passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_IsCalculateButtonInactive failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
public static bool Run(string expectedNamurStatus) { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = AssertFunctions.AreEqual(expectedNamurStatus, Execution.GetNamurStatusFromHeader.Run(), "Comparing the actual Namur-Status to a reference status."); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CheckNamurStatus passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CheckNamurStatus failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
public static bool Run() { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool isPassed = AssertFunctions.AreEqual(false, Validation.CheckAvailabilityOfTabPages.IsReferenceValuesTabPageAvailable(), "Verify that Reference Values tab is inactive."); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CheckThatAllFieldsInBaseSettingsAreGrayed passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CheckThatAllFieldsInBaseSettingsAreGrayed failed."); Log.Screenshot(); } TearDown(); return(isPassed); }
public static bool Run(string pathToParameter, bool shouldExist) { StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ bool result = Validation.IsParameterExisting.Run(pathToParameter); bool isPassed = AssertFunctions.AreEqual(shouldExist, result, string.Format("Verify expectation ({0}) for existence of parameter {2} and result ({1}).", shouldExist, result, pathToParameter)); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_IsParameterExisting passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_IsParameterExisting failed."); } TearDown(); return(isPassed); }
/// <summary> /// Selects tank type 'cylindrical tank standing' and configures its parameter if needed. Use empty strings if you do not want to configure a parameter. /// </summary> /// <param name="height"> /// The height. /// </param> /// <param name="diameter"> /// The diameter. /// </param> /// <param name="length"> /// The length. /// </param> /// <param name="ceilingType"> /// The ceiling Type. /// </param> /// <param name="bottomType"> /// The bottom Type. /// </param> /// <param name="wallThickness"> /// The wall Thickness. /// </param> /// <param name="ceilingHeight"> /// The ceiling Height. /// </param> /// <param name="ceilingWidth"> /// The ceiling Width. /// </param> /// <param name="bottomHeight"> /// The bottom Height. /// </param> /// <param name="bottomWidth"> /// The bottom Width. /// </param> /// <returns> /// <c>true</c> if configuration was successful, <c>false</c> otherwise. /// </returns> public bool Run(string height, string diameter, string length, string ceilingType, string bottomType, string wallThickness, string ceilingHeight, string ceilingWidth, string bottomHeight, string bottomWidth) { bool result = Execution.SelectTab.Run(1); result &= Execution.SetTankType.Run("Cylindrical tank standing"); if (this.IsValid(height)) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankStandingHeight(height); result &= AssertFunctions.AreEqual(height, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankStandingHeight(), "Checking whether the height has been set correctly."); } if (this.IsValid(diameter)) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankStandingInternalDiameter(diameter); result &= AssertFunctions.AreEqual(diameter, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankStandingInternalDiameter(), "Checking whether the diameter has been set correctly."); } if (this.IsValid(length)) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankStandingLength(length); result &= AssertFunctions.AreEqual(length, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankStandingLength(), "Checking whether the length has been set correctly."); } if (this.IsValid(ceilingType)) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankStandingCeilingType(ceilingType); result &= AssertFunctions.AreEqual(ceilingType, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankStandingCeilingType(), "Checking whether the ceilingType has been set correctly."); } if (this.IsValid(bottomType)) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankStandingBottomType(bottomType); result &= AssertFunctions.AreEqual(bottomType, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankStandingBottomType(), "Checking whether the bottomType has been set correctly."); } if (this.IsValid(wallThickness)) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankStandingWallThickness(wallThickness); result &= AssertFunctions.AreEqual(wallThickness, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankStandingWallThickness(), "Checking whether the wallThickness has been set correctly."); } if (this.IsValid(ceilingHeight)) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankStandingCeilingHeight(ceilingHeight); result &= AssertFunctions.AreEqual(ceilingHeight, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankStandingCeilingHeight(), "Checking whether the ceilingHeight has been set correctly."); } if (this.IsValid(ceilingWidth)) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankStandingCeilingWidth(ceilingWidth); result &= AssertFunctions.AreEqual(ceilingWidth, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankStandingCeilingWidth(), "Checking whether the ceilingWidth has been set correctly."); } if (this.IsValid(bottomHeight)) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankStandingBottomHeight(bottomHeight); result &= AssertFunctions.AreEqual(bottomHeight, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankStandingBottomHeight(), "Checking whether the bottomHeight has been set correctly."); } if (this.IsValid(bottomWidth)) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankStandingBottomWidth(bottomWidth); result &= AssertFunctions.AreEqual(bottomWidth, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankStandingBottomWidth(), "Checking whether the bottomWidth has been set correctly."); } if (result) { Log.Info(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Configuring finished successfully."); } else { Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "An error occurred during configuring."); } return(result); }
/// <summary> /// Selects tank type 'Horizontal cylindrical tank' and configures its parameter if needed. Use empty strings if you do not want to configure a parameter. /// </summary> /// <param name="height"> /// The height. /// </param> /// <param name="diameter"> /// The diameter. /// </param> /// <param name="length"> /// The length. /// </param> /// <param name="angle"> /// The angle. /// </param> /// <param name="endTypeRight"> /// The end Type Right. /// </param> /// <param name="endTypeLeft"> /// The end Type Left. /// </param> /// <param name="wallThickness"> /// The wall Thickness. /// </param> /// <param name="changePosition"> /// The change Position. /// </param> /// <returns> /// <c>true</c> if configuration was successful, <c>false</c> otherwise. /// </returns> public bool Run(string height, string diameter, string length, string angle, string endTypeRight, string endTypeLeft, string wallThickness, string changePosition) { bool result = Execution.SelectTab.Run(1); result &= Execution.SetTankType.Run("Horizontal cylindrical tank"); if (height != string.Empty) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankHeight(height); result &= AssertFunctions.AreEqual(height, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankHeight(), "Checking whether the height has been set correctly."); } if (diameter != string.Empty) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankDiameter(diameter); result &= AssertFunctions.AreEqual(diameter, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankDiameter(), "Checking whether the diameter has been set correctly."); } if (length != string.Empty) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankLength(length); result &= AssertFunctions.AreEqual(length, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankLength(), "Checking whether the length has been set correctly."); } if (angle != string.Empty) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankAngle(angle); result &= AssertFunctions.AreEqual(angle, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankAngle(), "Checking whether the angle has been set correctly."); } if (endTypeRight != string.Empty) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankEndTypeRight(endTypeRight); result &= AssertFunctions.AreEqual(endTypeRight, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankEndTypeRight(), "Checking whether the endTypeRight has been set correctly."); } if (endTypeLeft != string.Empty) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankEndTypeLeft(endTypeLeft); result &= AssertFunctions.AreEqual(endTypeLeft, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankEndTypeLeft(), "Checking whether the endTypeLeft has been set correctly."); } if (wallThickness != string.Empty) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankWallThickness(wallThickness); result &= AssertFunctions.AreEqual(wallThickness, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankWallThickness(), "Checking whether the wallThickness has been set correctly."); } if (changePosition != string.Empty) { result &= Execution.ConfigureTankParameter.SetHorizontalCylindricalTankChangePosition(changePosition); result &= AssertFunctions.AreEqual(changePosition, Execution.ConfigureTankParameter.GetHorizontalCylindricalTankChangePosition(), "Checking whether the changePosition has been set correctly."); } if (result) { Log.Info(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Configuring finished successfully."); } else { Log.Error(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "An error occurred during configuring."); } return(result); }
public static bool Run() { // TC_CheckFineTuningGuiBehaviour // Set Calculation Base to Fine Tuning // Read Coefficients from Device // Check user notification for success // Select Tab Coefficients Overview // Check Coefficients from Device for != nan // Select Tab Liquid Properties // Check control Recalculate for enabled state = false // Enter values into table // Check control Recalculate for enabled state = true // Recalculate Coefficients // Check user notification for success // Select Tab Coefficients Overview // Check calculated Coefficients for != nan const string Description = "Description of TC_CheckFineTuningGuiBehaviour: \r\n " + "-------------------------------------------------- \r\n " + "- Set Calculation Base to Fine Tuning \r\n " + "- Read Coefficients from Device \r\n " + "-> Check user notification for success \r\n " + "- Select Tab Coefficients Overview \r\n " + "-> Check Coefficients from Device for != nan \r\n " + "- Select Tab Liquid Properties \r\n " + "-> Check control Recalculate for enabled state = false \r\n " + "- Enter values into table \r\n " + "-> Check control Recalculate for enabled state = true \r\n " + "- Recalculate Coefficients \r\n " + "-> Check user notification for success \r\n " + "- Select Tab Coefficients Overview \r\n " + "-> Check calculated Coefficients for != nan \r\n "; Log.Info(LogInfo.Namespace(MethodBase.GetCurrentMethod()), Description); StartUp(); /* Add your TestFramework calls here, for example: * EH.PCPS.TestAutomation.CommonHostApplicationLayerLoader.CommonFlows.OpenHostApplication.Run(pathToApplication); * EH.PCPS.TestAutomation.DeviceFunctionLoader.CoDIA.Parameterization.Flows.OpenModuleOnline.Run(); */ // TC_CheckFineTuningGuiBehaviour // Set Calculation Base to Fine Tuning // Read Coefficients from Device // Check user notification for success // Select Tab Coefficients Overview // Check Coefficients from Device for != nan // Select Tab Liquid Properties // Check control Recalculate for enabled state = false // Enter values into table // Check control Recalculate for enabled state = true // Recalculate Coefficients // Check user notification for success // Select Tab Coefficients Overview // Check calculated Coefficients for != nan const string TableValues = "1;1;1;2;2;2;3;3;3;4;4;4;5;5;5;6;6;6;7;7;7;8;8;8;9;9;9;10;10;10;11;11;11;12;12;12"; bool isPassed = false; isPassed = AssertFunctions.AreEqual(true, Validation.CheckAvailabilityOfTabPages.IsBaseSettingsTabPageAvailable(), "Verify that Base Settings tab is active."); isPassed &= Execution.Container.SelectTabBaseSettings(); isPassed &= Flows.ConfigureBaseSettings.BaseConfiguration("Fine tuning settings", string.Empty, string.Empty, string.Empty, string.Empty); isPassed &= Flows.Read.Run(); // Todo: // isPassed &= Check user notification for success isPassed &= AssertFunctions.AreEqual(true, Validation.CheckAvailabilityOfTabPages.IsCoefficientOverviewTabPageAvailable(), "Verify that Coefficients Overview tab is active."); isPassed &= Execution.Container.SelectTabCoefficientsOverview(); isPassed &= Execution.CoefficientsOverview.AreReadCoefficientsAvailable(); isPassed &= AssertFunctions.AreEqual(true, Validation.CheckAvailabilityOfTabPages.IsLiquidPropertiesTabPageAvailable(), "Verify that Liquid Properties tab is active."); isPassed &= Execution.Container.SelectTabLiquidProperties(); // Todo: // Check control Recalculate for enabled state = false isPassed &= Execution.SetTableValues.SetValues(StringToListConverter.Run(TableValues)); // Todo: // Check control Recalculate for enabled state = true isPassed &= Execution.LiquidProperties.Recalculate(); // Todo: // Check user notification for success isPassed &= AssertFunctions.AreEqual(true, Validation.CheckAvailabilityOfTabPages.IsCoefficientOverviewTabPageAvailable(), "Verify that Coefficients Overview tab is active."); isPassed &= Execution.Container.SelectTabCoefficientsOverview(); isPassed &= Execution.CoefficientsOverview.AreCalculatedCoefficientsAvailable(); if (isPassed) { Log.Success(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CheckFineTuningGuiBehaviour passed."); } else { Log.Failure(LogInfo.Namespace(MethodBase.GetCurrentMethod()), "Test case TC_CheckFineTuningGuiBehaviour failed."); Log.Screenshot(); } TearDown(); return(isPassed); }