HpToolsLauncher.Helper.ValidateFiles C# (CSharp) Method

        public static List<string> ValidateFiles(IEnumerable<string> tests)
        {
            List<string> validTests = new List<string>();
            foreach (string test in tests)
            {
                if (!File.Exists(test) && !Directory.Exists(test))
                {
                    ConsoleWriter.WriteLine(string.Format(">>>> File/Folder not found: '{0}'", test));
                    Launcher.ExitCode = Launcher.ExitCodeEnum.Failed;
                }
                else
                {
                    validTests.Add(test);
                }
            }
            return validTests;
        }

        /// <summary>
        /// creates the correct runner according to the given type
        /// </summary>
        /// <param name="runType"></param>
        /// <param name="ciParams"></param>
        IAssetRunner CreateRunner(TestStorageType runType, JavaProperties ciParams)
        {
            IAssetRunner runner = null;

            switch (runType)
            {
            case TestStorageType.Alm:
                //check that all required parameters exist
                foreach (string param1 in requiredParamsForQcRun)
                {
                    if (!_ciParams.ContainsKey(param1))
                    {
                        ConsoleWriter.WriteLine(string.Format(Resources.LauncherParamRequired, param1));
                        return(null);
                    }
                }

                //parse params that need parsing
                double dblQcTimeout = int.MaxValue;
                if (!double.TryParse(_ciParams["almTimeout"], out dblQcTimeout))
                {
                    ConsoleWriter.WriteLine(Resources.LauncherTimeoutNotNumeric);
                    dblQcTimeout = int.MaxValue;
                }

                ConsoleWriter.WriteLine(string.Format(Resources.LuancherDisplayTimout, dblQcTimeout));

                QcRunMode enmQcRunMode = QcRunMode.RUN_LOCAL;
                if (!Enum.TryParse <QcRunMode>(_ciParams["almRunMode"], true, out enmQcRunMode))
                {
                    ConsoleWriter.WriteLine(Resources.LauncherIncorrectRunmode);
                    enmQcRunMode = QcRunMode.RUN_LOCAL;
                }
                ConsoleWriter.WriteLine(string.Format(Resources.LauncherDisplayRunmode, enmQcRunMode.ToString()));

                //go over testsets in the parameters, and collect them
                List <string> sets = GetParamsWithPrefix("TestSet");

                if (sets.Count == 0)
                {
                    ConsoleWriter.WriteLine(Resources.LauncherNoTests);
                    return(null);
                }

                //create an Alm runner
                runner = new AlmTestSetsRunner(_ciParams["almServerUrl"],
                                               _ciParams["almUserName"],
                                               Decrypt(_ciParams["almPassword"], secretkey),
                                               _ciParams["almDomain"],
                                               _ciParams["almProject"],
                                               dblQcTimeout,
                                               enmQcRunMode,
                                               _ciParams["almRunHost"],
                                               sets);
                break;

            case TestStorageType.FileSystem:

                //get the tests
                IEnumerable <string> tests = GetParamsWithPrefix("Test");

                IEnumerable <string>        jenkinsEnvVariablesWithCommas = GetParamsWithPrefix("JenkinsEnv");
                Dictionary <string, string> jenkinsEnvVariables           = new Dictionary <string, string>();
                foreach (string var in jenkinsEnvVariablesWithCommas)
                {
                    string[] nameVal = var.Split(",;".ToCharArray());
                    jenkinsEnvVariables.Add(nameVal[0], nameVal[1]);
                }
                //parse the timeout into a TimeSpan
                TimeSpan timeout = TimeSpan.MaxValue;
                if (_ciParams.ContainsKey("fsTimeout"))
                {
                    string strTimoutInSeconds = _ciParams["fsTimeout"];
                    if (strTimoutInSeconds.Trim() != "-1")
                    {
                        int intTimoutInSeconds = 0;
                        int.TryParse(strTimoutInSeconds, out intTimoutInSeconds);
                        timeout = TimeSpan.FromSeconds(intTimoutInSeconds);
                    }
                }
                ConsoleWriter.WriteLine("Launcher timeout is " + timeout.ToString(@"dd\:\:hh\:mm\:ss"));

                //LR specific values:
                //default values are set by JAVA code, in com.hpe.application.automation.tools.model.RunFromFileSystemModel.java

                int pollingInterval = 30;
                if (_ciParams.ContainsKey("controllerPollingInterval"))
                {
                    pollingInterval = int.Parse(_ciParams["controllerPollingInterval"]);
                }
                ConsoleWriter.WriteLine("Controller Polling Interval: " + pollingInterval + " seconds");

                TimeSpan perScenarioTimeOutMinutes = TimeSpan.MaxValue;
                if (_ciParams.ContainsKey("PerScenarioTimeOut"))
                {
                    string strTimoutInMinutes = _ciParams["PerScenarioTimeOut"];
                    //ConsoleWriter.WriteLine("reading PerScenarioTimeout: "+ strTimoutInMinutes);
                    if (strTimoutInMinutes.Trim() != "-1")
                    {
                        int intTimoutInMinutes = 0;
                        if (int.TryParse(strTimoutInMinutes, out intTimoutInMinutes))
                        {
                            perScenarioTimeOutMinutes = TimeSpan.FromMinutes(intTimoutInMinutes);
                        }
                        //ConsoleWriter.WriteLine("PerScenarioTimeout: "+perScenarioTimeOutMinutes+" minutes");
                    }
                }
                ConsoleWriter.WriteLine("PerScenarioTimeout: " + perScenarioTimeOutMinutes.ToString(@"dd\:\:hh\:mm\:ss") + " minutes");

                char[]        delim = { '\n' };
                List <string> ignoreErrorStrings = new List <string>();
                if (_ciParams.ContainsKey("ignoreErrorStrings"))
                {
                    if (_ciParams.ContainsKey("ignoreErrorStrings"))
                    {
                        ignoreErrorStrings.AddRange(Array.ConvertAll(_ciParams["ignoreErrorStrings"].Split(delim, StringSplitOptions.RemoveEmptyEntries), ignoreError => ignoreError.Trim()));
                    }
                }

                if (tests == null || tests.Count() == 0)
                {
                    WriteToConsole(Resources.LauncherNoTestsFound);
                }

                List <string> validTests = Helper.ValidateFiles(tests);

                if (tests != null && tests.Count() > 0 && validTests.Count == 0)
                {
                    ConsoleWriter.WriteLine(Resources.LauncherNoValidTests);
                    return(null);
                }

                //--MC connection info
                McConnectionInfo mcConnectionInfo = new McConnectionInfo();
                if (_ciParams.ContainsKey("MobileHostAddress"))
                {
                    string mcServerUrl = _ciParams["MobileHostAddress"];

                    if (!string.IsNullOrEmpty(mcServerUrl))
                    {
                        //url is something like http://xxx.xxx.xxx.xxx:8080
                        string[] strArray = mcServerUrl.Split(new Char[] { ':' });
                        if (strArray.Length == 3)
                        {
                            mcConnectionInfo.MobileHostAddress = strArray[1].Replace("/", "");
                            mcConnectionInfo.MobileHostPort    = strArray[2];
                        }

                        //mc username
                        if (_ciParams.ContainsKey("MobileUserName"))
                        {
                            string mcUsername = _ciParams["MobileUserName"];
                            if (!string.IsNullOrEmpty(mcUsername))
                            {
                                mcConnectionInfo.MobileUserName = mcUsername;
                            }
                        }

                        //mc password
                        if (_ciParams.ContainsKey("MobilePassword"))
                        {
                            string mcPassword = _ciParams["MobilePassword"];
                            if (!string.IsNullOrEmpty(mcPassword))
                            {
                                mcConnectionInfo.MobilePassword = Decrypt(mcPassword, secretkey);
                            }
                        }

                        //ssl
                        if (_ciParams.ContainsKey("MobileUseSSL"))
                        {
                            string mcUseSSL = _ciParams["MobileUseSSL"];
                            if (!string.IsNullOrEmpty(mcUseSSL))
                            {
                                mcConnectionInfo.MobileUseSSL = int.Parse(mcUseSSL);
                            }
                        }

                        //Proxy enabled flag
                        if (_ciParams.ContainsKey("MobileUseProxy"))
                        {
                            string useProxy = _ciParams["MobileUseProxy"];
                            if (!string.IsNullOrEmpty(useProxy))
                            {
                                mcConnectionInfo.MobileUseProxy = int.Parse(useProxy);
                            }
                        }


                        //Proxy type
                        if (_ciParams.ContainsKey("MobileProxyType"))
                        {
                            string proxyType = _ciParams["MobileProxyType"];
                            if (!string.IsNullOrEmpty(proxyType))
                            {
                                mcConnectionInfo.MobileProxyType = int.Parse(proxyType);
                            }
                        }


                        //proxy address
                        if (_ciParams.ContainsKey("MobileProxySetting_Address"))
                        {
                            string proxyAddress = _ciParams["MobileProxySetting_Address"];
                            if (!string.IsNullOrEmpty(proxyAddress))
                            {
                                // data is something like "16.105.9.23:8080"
                                string[] strArray4ProxyAddr = proxyAddress.Split(new Char[] { ':' });
                                if (strArray.Length == 2)
                                {
                                    mcConnectionInfo.MobileProxySetting_Address = strArray4ProxyAddr[0];
                                    mcConnectionInfo.MobileProxySetting_Port    = int.Parse(strArray4ProxyAddr[1]);
                                }
                            }
                        }

                        //Proxy authentication
                        if (_ciParams.ContainsKey("MobileProxySetting_Authentication"))
                        {
                            string proxyAuthentication = _ciParams["MobileProxySetting_Authentication"];
                            if (!string.IsNullOrEmpty(proxyAuthentication))
                            {
                                mcConnectionInfo.MobileProxySetting_Authentication = int.Parse(proxyAuthentication);
                            }
                        }

                        //Proxy username
                        if (_ciParams.ContainsKey("MobileProxySetting_UserName"))
                        {
                            string proxyUsername = _ciParams["MobileProxySetting_UserName"];
                            if (!string.IsNullOrEmpty(proxyUsername))
                            {
                                mcConnectionInfo.MobileProxySetting_UserName = proxyUsername;
                            }
                        }

                        //Proxy password
                        if (_ciParams.ContainsKey("MobileProxySetting_Password"))
                        {
                            string proxyPassword = _ciParams["MobileProxySetting_Password"];
                            if (!string.IsNullOrEmpty(proxyPassword))
                            {
                                mcConnectionInfo.MobileProxySetting_Password = Decrypt(proxyPassword, secretkey);
                            }
                        }
                    }
                }

                // other mobile info
                string mobileinfo = "";
                if (_ciParams.ContainsKey("mobileinfo"))
                {
                    mobileinfo = _ciParams["mobileinfo"];
                }

                if (_ciParams.ContainsKey("fsUftRunMode"))
                {
                    string uftRunMode = "Fast";
                    uftRunMode = _ciParams["fsUftRunMode"];
                    runner     = new FileSystemTestsRunner(validTests, timeout, uftRunMode, pollingInterval, perScenarioTimeOutMinutes, ignoreErrorStrings, jenkinsEnvVariables, mcConnectionInfo, mobileinfo);
                }
                else
                {
                    runner = new FileSystemTestsRunner(validTests, timeout, pollingInterval, perScenarioTimeOutMinutes, ignoreErrorStrings, jenkinsEnvVariables, mcConnectionInfo, mobileinfo);
                }

                break;

            default:
                runner = null;
                break;
            }
            return(runner);
        }