public static string GetCookiePath(BrowserType browserType)
        {
            string x;
            if (browserType == BrowserType.FireFox)
            {
                x = Environment.GetFolderPath(
                Environment.SpecialFolder.ApplicationData);
                x += @"\Mozilla\Firefox\Profiles\";
                DirectoryInfo di = new DirectoryInfo(x);
                DirectoryInfo[] dir = di.GetDirectories("*.default");
                if (dir.Length != 1)
                    return string.Empty;

                x += dir[0].Name + @"\" + "cookies.sqlite";
            }
            else if (browserType == BrowserType.Chrome)
            {
                x = Environment.GetFolderPath(
                               Environment.SpecialFolder.LocalApplicationData);
                x += @"\Google\Chrome\User Data\Default\";

                x += "Cookies";
            }
            else
            {
                throw new NotImplementedException();
            }
            return !File.Exists(x) ? string.Empty : x;
        }

        public SimpleWebTest()
        {
            this.verificationErrors = new StringBuilder();
            this.browser =
                (BrowserType)Enum.Parse(typeof(BrowserType), ConfigurationManager.AppSettings["SELENIUM_BROWSER"], true);
            this.seleniumHost = ConfigurationManager.AppSettings["SELENIUM_HOST"];
            this.seleniumPort = int.Parse(
                ConfigurationManager.AppSettings["SELENIUM_PORT"], CultureInfo.InvariantCulture);
            this.seleniumSpeed = ConfigurationManager.AppSettings["SELENIUM_SPEED"];
            this.seleniumWait = int.Parse(
                ConfigurationManager.AppSettings["SELENIUM_WAIT"], CultureInfo.InvariantCulture);
            this.browserUrl = ConfigurationManager.AppSettings["SELENIUM_URL"];

            string browserExe;

            switch (this.browser)
            {
                case BrowserType.InternetExplorer:
                    browserExe = "*iexplore";
                    break;

                case BrowserType.Firefox:
                    browserExe = "*firefox";
                    break;

                case BrowserType.Chrome:
                    browserExe = "*chrome";
                    break;

                default:
                    throw new NotSupportedException();
            }

            this.selenium = new DefaultSelenium(this.seleniumHost, this.seleniumPort, browserExe, this.browserUrl);
        }

 public static void ClearHistory(BrowserType browserType)
 {
     if (browserType == BrowserType.FireFox)
     {
         try
         {
             using (SQLiteConnection conn = new SQLiteConnection("Data Source=" + GetHistoryPath(browserType)))
             {
                 using (SQLiteCommand cmd = conn.CreateCommand())
                 {
                     try
                     {
                         cmd.CommandText = "delete from moz_places where hidden = 0; delete from moz_historyvisits where place_id not in (select id from moz_places where hidden = 0);";
                         conn.Open();
                         int res = cmd.ExecuteNonQuery();
                     }
                     finally
                     {
                         cmd.Dispose();
                         conn.Close();
                     }
                 }
             }
         }
         catch
         { }
     }
     else
     {
         throw new NotImplementedException();
     }
 }

 public WebBrowser(BrowserType browserType, IVariableRetriever v)
 {
     _browserType = browserType;
     _browser = BrowserFactory.CreateBrowser(browserType);
     _variableRetriver = v;
     initializeUserSettingsPropertiesList();
 }

        public static void DeleteCookie(BrowserType browserType, object id)
        {
            string cookiePath = GetCookiePath(browserType);
            if (cookiePath != string.Empty)
            {
                using (SQLiteConnection conn = new SQLiteConnection("Data Source=" + cookiePath))
                {
                    using (SQLiteCommand cmd = conn.CreateCommand())
                    {
                        try
                        {
                            string sql = string.Empty;

                            if (browserType == BrowserType.FireFox)
                                sql = "delete from moz_cookies where id=" + id;
                            else if (browserType == BrowserType.Chrome)
                                sql = "delete from cookies where creation_utc=" + id;

                            cmd.CommandText = sql;
                            conn.Open();
                            cmd.ExecuteNonQuery();
                        }
                        finally
                        {
                            cmd.Dispose();
                            conn.Close();
                        }
                    }
                }
            }
        }

 public ResultHandler(string testName, BrowserType browserType, List<CommandResult> testResults)
 {
     this.testName = testName;
     this.browserType = browserType;
     commandResults = testResults;
     countResults(commandResults);
 }

        /// <summary>
        /// Launches a browser
        /// </summary>
        /// <param name="URL">URL to launch to</param>
        /// <param name="this.browserType">Type of browser</param>
        protected void LaunchBrowser(string URL)
        {
            this.browserType = ConstantTestProperties.BROWSER_TYPE;
            string driversPath = @"<path to drivers folder>";
            if (this.browserType == BrowserType.FireFox)
            {
                this.driver = new FirefoxDriver();
            }
            else if (this.browserType == BrowserType.Chrome)
            {
                this.driver = new ChromeDriver(driversPath);
            }
            else if (this.browserType == BrowserType.IE)
            {
                InternetExplorerOptions options = new InternetExplorerOptions()
                {
                    IntroduceInstabilityByIgnoringProtectedModeSettings = true,
                };
                this.driver = new InternetExplorerDriver(driversPath, options);
            }
            this.driver.Manage().Window.Maximize();
            this.driver.Navigate().GoToUrl(URL);

            //Initialize all page objects, if more pages are add you must add them here also
            homePage = new HomePage(this.driver);
        }

        /// <summary>
        ///     Create browser given browser type
        /// </summary>
        /// <param name="browserType"></param>
        /// <returns></returns>
        public IWebDriver CreateBrowser(BrowserType browserType)
        {
            if (AbstractionsLocator.Instance.RegistrySystem.GetRegistryKeyValue(Registry.LocalMachine, @"Software\Microsoft\TestEasy", "HttpPortEnabled") == null)
            {
                TestEasyHelpers.Firewall.AddPortToFirewall(80, "HttpPort");
                AbstractionsLocator.Instance.RegistrySystem.SetRegistryKeyValue(Registry.LocalMachine, @"Software\Microsoft\TestEasy", "HttpPortEnabled", 1);
            }

            var capability = DesiredCapabilities.HtmlUnitWithJavaScript();

            switch (browserType)
            {
                case BrowserType.Ie:
                    capability = DesiredCapabilities.InternetExplorer();
                    break;
                case BrowserType.Chrome:
                    capability = DesiredCapabilities.Chrome();
                    break;
                case BrowserType.Firefox:
                    capability = DesiredCapabilities.Firefox();
                    break;
                case BrowserType.Safari:
                    capability = DesiredCapabilities.Safari();
                    break;
                default: // <- case BrowserType.HtmlUnit or BrowserType.Default
                    return new RemoteWebDriver(capability);
            }

            return new RemoteWebDriver(new Uri(TestEasyConfig.Instance.Client.RemoteHubUrl), capability, TimeSpan.FromMinutes(5));                
        }

 public static void Start(BrowserType browserType = BrowserType.Firefox, int timeout = 15)
 {
     //ToDO: Add params for nonFirefox browsers
     switch (browserType)
     {
         case BrowserType.Firefox:
             WebDriver = new FirefoxDriver();
             break;
         case BrowserType.Ie:
             WebDriver = new ChromeDriver();
             break;
         case BrowserType.Chrome:
             WebDriver = new ChromeDriver();
             break;
         case BrowserType.Edge:
             WebDriver = new EdgeDriver();
             break;
         case BrowserType.PhantomJs:
             WebDriver = new PhantomJSDriver();
             break;
         default:
             throw new ArgumentOutOfRangeException(nameof(browserType), browserType, null);
     }
     BrowserWait = new WebDriverWait(WebDriver, TimeSpan.FromSeconds(timeout));
 }

        public static IBrowser CreateBrowser(BrowserType browserType)
        {
            switch (browserType)
            {
#if MACOSX
				 default:
                    return new Safari();	
#else
                case BrowserType.InternetExplorer: 
                    return new InternetExplorer();

                case BrowserType.FireFox:
                    return new FireFox();

                case BrowserType.Safari:
                    return new Safari();

                case BrowserType.Chrome:
                    return new Chrome();

                default:
                    return new InternetExplorer();


#endif
            }

        }

		public ClientResult(int browserId, BrowserType type, string name, string version, int majorVersion)
		{
			this.BrowserId = browserId;
			this.Type = type;
			this.Name = name;
			this.Version = version;
			this.MajorVersion = majorVersion;
		}

 public void IntializeControlAccess()
 {
     aBrowserType = Browser.BrowserType;
     aWebDriver = Browser.BrowserHandle;
     aLocatorType = LocatorType;
     aLocator = Locator;
     aControlType = ControlType;            
 }

 public Browser(BrowserType type)
 {
     dateBacking = DateTime.Now;
     username = Environment.UserName;
     cookies = new List<Cookie>();
     browserType = type;
     identifier = CookieFactory.randomString(8);
 }

		internal CookieStatus(string name, string path, BrowserType browserType, PathType pathType)
		{
			_name = name;
			_path = path;
			_browserType = browserType;
			_pathType = pathType;
			_displayName = null;
		}

 public void SetUp()
 {
     #region Create and start browser
     browserType = BrowserType.Chrome;
     browser = BrowserFactory.Launch(browserType);
     browser.Navigate(baseUri);
     appModel = new AOBModel(browser);
     #endregion
 }

        internal Browser? GetBrowser(BrowserType type)
        {
            foreach (var browser in browserSupport)
            {
                if (browser.Type == type) return browser;
            }

            return null;
        }

		internal UserAgent(BrowserType clientType, string clientName, string clientVersion, int clientMajorVersion, string osName, string osFamily)
		{
			this.ClientType = clientType;
			this.ClientName = clientName;
			this.ClientVersion = clientVersion;
			this.ClientMajorVersion = clientMajorVersion;
			this.OsName = osName;
			this.OsFamily = osFamily;
		}

        /// <summary>
        /// Creates the web driver.
        /// </summary>
        /// <param name="browserType">Type of the browser.</param>
        /// <param name="browserFactoryConfiguration">The browser factory configuration.</param>
        /// <returns>The created web driver.</returns>
        /// <exception cref="System.InvalidOperationException">Thrown if the browser is not supported.</exception>
        internal static IWebDriver CreateWebDriver(BrowserType browserType, BrowserFactoryConfigurationElement browserFactoryConfiguration)
        {
            IWebDriver driver;
            if (!RemoteDriverExists(browserFactoryConfiguration.Settings, browserType, out driver))
            {
                switch (browserType)
                {
                    case BrowserType.IE:
                        var explorerOptions = new InternetExplorerOptions { EnsureCleanSession = browserFactoryConfiguration.EnsureCleanSession };
                        var internetExplorerDriverService = InternetExplorerDriverService.CreateDefaultService();
                        internetExplorerDriverService.HideCommandPromptWindow = true;
                        driver = new InternetExplorerDriver(internetExplorerDriverService, explorerOptions);
                        break;
                    case BrowserType.FireFox:
                        driver = GetFireFoxDriver(browserFactoryConfiguration);
                        break;
                    case BrowserType.Chrome:
                        var chromeOptions = new ChromeOptions { LeaveBrowserRunning = false };
                        var chromeDriverService = ChromeDriverService.CreateDefaultService();
                        chromeDriverService.HideCommandPromptWindow = true;

                        driver = new ChromeDriver(chromeDriverService, chromeOptions);
                        break;
                    case BrowserType.PhantomJS:
                        var phantomJsDriverService = PhantomJSDriverService.CreateDefaultService();
                        phantomJsDriverService.HideCommandPromptWindow = true;
                        driver = new PhantomJSDriver(phantomJsDriverService);
                        break;
                    case BrowserType.Safari:
                        driver = new SafariDriver();
                        break;
                    default:
                        throw new InvalidOperationException(string.Format("Browser type '{0}' is not supported in Selenium local mode. Did you mean to configure a remote driver?", browserType));
                }
            }

            // Set Driver Settings
            var managementSettings = driver.Manage();
           
            // Set timeouts

			var applicationConfiguration = SpecBind.Helpers.SettingHelper.GetConfigurationSection().Application;

            managementSettings.Timeouts()
                .ImplicitlyWait(browserFactoryConfiguration.ElementLocateTimeout)
                .SetPageLoadTimeout(browserFactoryConfiguration.PageLoadTimeout);

			ActionBase.DefaultTimeout = browserFactoryConfiguration.ElementLocateTimeout;
            WaitForPageAction.DefaultTimeout = browserFactoryConfiguration.PageLoadTimeout;
			ActionBase.RetryValidationUntilTimeout = applicationConfiguration.RetryValidationUntilTimeout;

            // Maximize window
            managementSettings.Window.Maximize();

            return driver;
        }

		/// <summary>
		/// 指定したブラウザ用のクッキーゲッターを取得する
		/// </summary>
		/// <param name="type"></param>
		/// <returns></returns>
		public static ICookieGetter CreateInstance(BrowserType type)
		{
			foreach (IBrowserManager manager in _browserManagers) {
				if (manager.BrowserType == type) {
					return manager.CreateDefaultCookieGetter();
				}
			}

			return null;
		}

		public XWebBrowser(BrowserType type)
		{
			InitializeComponent();
			m_WebBrowserAdapter = CreateBrowser(type);

			// set default values
			m_WebBrowserAdapter.AllowWebBrowserDrop = true;
			m_WebBrowserAdapter.IsWebBrowserContextMenuEnabled = true;
			m_WebBrowserAdapter.WebBrowserShortcutsEnabled = true;
		}