Selenium二次封装-Java版本

 package com.yanfuchang.selenium.utils;

 import java.awt.AWTException;
 import java.awt.Robot;
 import java.awt.event.KeyEvent;
 import java.io.File;
 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import org.apache.commons.io.FileUtils;
 import org.openqa.selenium.Alert;
 import org.openqa.selenium.By;
 import org.openqa.selenium.Cookie;
 import org.openqa.selenium.Dimension;
 import org.openqa.selenium.JavascriptExecutor;
 import org.openqa.selenium.Keys;
 import org.openqa.selenium.NoAlertPresentException;
 import org.openqa.selenium.NoSuchElementException;
 import org.openqa.selenium.OutputType;
 import org.openqa.selenium.TakesScreenshot;
 import org.openqa.selenium.WebDriver;
 import org.openqa.selenium.WebDriverException;
 import org.openqa.selenium.WebElement;
 import org.openqa.selenium.chrome.ChromeDriver;
 import org.openqa.selenium.firefox.FirefoxDriver;
 import org.openqa.selenium.firefox.FirefoxProfile;
 import org.openqa.selenium.ie.InternetExplorerDriver;
 import org.openqa.selenium.interactions.Actions;
 import org.openqa.selenium.interactions.HasInputDevices;
 import org.openqa.selenium.interactions.Keyboard;
 import org.openqa.selenium.remote.DesiredCapabilities;
 import org.openqa.selenium.remote.RemoteWebDriver;
 import org.openqa.selenium.support.ui.ExpectedConditions;
 import org.openqa.selenium.support.ui.Select;
 import org.openqa.selenium.support.ui.WebDriverWait;

 /**
  *    基于selenium的二次封装
  */
 public class WebDriverUtil {
     private static WebDriver driver = null;
     private static Select select = null;
     private static Alert alert = null;
     private static WebElement element = null;
     private static List<WebElement> elementList = null;
     private static long timeOutInSeconds = 10;
     //--------------------自定义常量------------------------
     public final String LINE = "\r\n";
     public final String smile = "^_^";
     public final String sad = "*o*";

     public WebDriverUtil(long timeOutInSeconds) {
         WebDriverUtil.timeOutInSeconds = timeOutInSeconds;
     }

     public WebDriverUtil() {}

     /**
      *     指定浏览器打开URL
      */
     public static void openBrowser(String url, String browser) {
         driver = initBrowser(browser);
         driver.manage().timeouts().implicitlyWait(timeOutInSeconds, TimeUnit.SECONDS);
         driver.get(url);
     }
     /**
      *     指定浏览器打开URL
      */
     public static void openBrowser(String url) {
         driver = initBrowser();
         driver.get(url);
     }

     /**
      *    初始化浏览器，方式1
      *        Firefox
      */
     public static WebDriver initBrowser() {
         /*
          * 谷歌浏览器 System.setProperty("webdriver.chrome.driver",
          * "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chromedriver.exe");
          * WebDriver driver = new ChromeDriver(); driver.get("http://www.baidu.com/");
          */
         FirefoxProfile profile = new FirefoxProfile();
         profile.setPreference("browser.download.manager.showWhenStarting", false);// 是否显示下载进度框
         profile.setPreference("browser.offline-apps.notify", false);// 网站保存离线数据时不通知我
         profile.setPreference("browser.helperApps.alwaysAsk.force", false);// 应用程序设置不询问
         profile.setPreference("browser.download.folderList", 0);// 设置下载地址0是桌面；1是“我的下载”；2是自定义
         profile.setPreference("browser.helperApps.neverAsk.saveToDisk",
                 "application/octet-stream, application/vnd.ms-excel, text/csv, application/zip, application/msword");
         profile.setPreference("dom.webnotifications.enabled", false);// 允许通知
         WebDriver driver = new FirefoxDriver(profile);// 启动火狐浏览器
         driver.manage().window().maximize();// 设置窗口大小
         driver.manage().timeouts().pageLoadTimeout(20, TimeUnit.SECONDS);// 设置页面加载超时
         driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);// 设置查询组件等待时间
         return driver;
     }

     /**
      *     初始化浏览器，方式2
      *         (ie, ff, chrome)
      */
     private static WebDriver initBrowser(String browser) {
         switch (browser) {
         case "ie":
             System.setProperty("webdriver.ie.driver", ".\\Tools\\IEDriverServer.exe");
             driver = new InternetExplorerDriver();
             break;
         case "ff":
         case "firefox":
         case "Firefox":
         case "FireFox":
             /**
              *     FireFox安装方式为默认安装：
              *     FireFox版本小于48
              *         System.setProperty("webdriver.firefox.marionette", ".\\Tools\\geckodriver.exe");
              *     FireFox版本大于48，默认安装时可以试试，应该可以
              *         System.setProperty("webdriver.gecko.driver", ".\\Tools\\geckodriver.exe");
              */
             // FireFox安装方式为自定义安装
             System.setProperty("webdriver.firefox.bin", "D:\\ProgramFiles\\Mozilla Firefox\\firefox.exe");
             driver = new FirefoxDriver();
             break;
         case "chrome":
         case "Chrome":
             System.setProperty("webdriver.chrome.driver", ".\\Tools\\chromedriver.exe");
             driver = new ChromeDriver();
             break;
         default:
             try {
                 throw new Exception("浏览器错误!");
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
         return driver;
     }

     //----------------------------------------------------元素相关-----------------------------------------------------------------------------
     /**
      *     查找元素
      * @param by      传入一个类型        例如：name
      * @param byValue 传入一个类型值       例如：username
      */
     public WebElement findElement(String by, String byValue) {
         try {
             switch (by) {
             case "id":
                 element = driver.findElement(By.id(byValue));
                 break;
             case "name":
                 element = driver.findElement(By.name(byValue));
                 break;
             case "class":
                 element = driver.findElement(By.className(byValue));
                 break;
             case "tag":
                 element = driver.findElement(By.tagName(byValue));
             case "link":
                 element = driver.findElement(By.linkText(byValue));
                 break;
             case "partiallinktext":
                 element = driver.findElement(By.partialLinkText(byValue));
             case "css":
                 element = driver.findElement(By.cssSelector(byValue));
                 break;
             case "xpath":
                 element = driver.findElement(By.xpath(byValue));
                 break;
             default:
                 throw new RuntimeException("输入的定位类型未在程序中定义，类型为：" + byValue);
             }
         } catch (Exception e) {
             System.out.println("没有找到元素：" + byValue);
         }
         return element;
     }
     /**
      *     查找一组元素
      * @param by      传入一个类型        例如：name
      * @param byValue 传入一个类型值       例如：username
      */
     public List<WebElement> findElements(String by, String byValue) {
         try {
             switch (by) {
             case "id":
                 elementList = driver.findElements(By.id(byValue));
                 break;
             case "name":
                 elementList = driver.findElements(By.name(byValue));
                 break;
             case "class":
                 elementList = driver.findElements(By.className(byValue));
                 break;
             case "tag":
                 elementList = driver.findElements(By.tagName(byValue));
             case "link":
                 elementList = driver.findElements(By.linkText(byValue));
                 break;
             case "partiallinktext":
                 elementList = driver.findElements(By.partialLinkText(byValue));
             case "css":
                 elementList = driver.findElements(By.cssSelector(byValue));
                 break;
             case "xpath":
                 elementList = driver.findElements(By.xpath(byValue));
                 break;
             default:
                 throw new RuntimeException("输入的定位类型未在程序中定义，类型为：" + byValue);
             }
         } catch (Exception e) {
             System.out.println("没有找到元素：" + byValue);
         }
         return elementList;
     }

     /**
      *     获取单个元素
      */
     public WebElement findElementByXpath(String xpath) {
         return driver.findElement(By.xpath(xpath));
     }
     public WebElement findElementByTag(String tag) {
         return driver.findElement(By.tagName(tag));
     }
     public WebElement findElementById(String id) {
         return driver.findElement(By.id(id));
     }
     public WebElement findElementByClassName(String name) {
         return driver.findElement(By.className(name));
     }
     public WebElement findElementByText(String text) {
         return driver.findElement(By.linkText(text));
     }
     public WebElement findElementByPartialText(String text) {
         return driver.findElement(By.partialLinkText(text));
     }
     public WebElement findElementByName(String name) {
         return driver.findElement(By.name(name));
     }

     /**
      *    获取多个元素
      */
     public List<WebElement> findElementsByClassName(String className) {
         return driver.findElements(By.className(className));
     }
     public List<WebElement> findElementsByText(String text) {
         return driver.findElements(By.linkText(text));
     }
     public List<WebElement> findElementsByPartialText(String text) {
         return driver.findElements(By.partialLinkText(text));
     }
     public List<WebElement> findElementsById(String id) {
         return driver.findElements(By.id(id));
     }
     public List<WebElement> findElementsByTag(String tag) {
         return driver.findElements(By.tagName(tag));
     }

     /**
      *    获取一组元素中的指定元素
      */
     public WebElement FindByElements(By by, int index) {
         WebElement element = null;
         if (this.elementsExists(by)) {
             element = driver.findElements(by).get(index);
         }
         return element;
     }

     /**
      *     查找元素并点击
      * @param by      传入一个类型        例如：name
      * @param byValue 传入一个类型值       例如：username
      */
     public boolean findElementClick(String by, String byValue) {
         try {
             switch (by) {
             case "id":
                 driver.findElement(By.id(byValue)).click();
                 return true;
             case "name":
                 driver.findElement(By.name(byValue)).click();
                 return true;
             case "class":
                 driver.findElement(By.className(byValue)).click();
                 return true;
             case "tag":
                 driver.findElement(By.tagName(byValue)).click();
             case "link":
                 driver.findElement(By.linkText(byValue)).click();
                 return true;
             case "partiallinktext":
                 driver.findElement(By.partialLinkText(byValue)).click();
             case "css":
                 driver.findElement(By.cssSelector(byValue)).click();
                 return true;
             case "xpath":
                 driver.findElement(By.xpath(byValue)).click();
                 return true;
             default:
                 throw new RuntimeException("输入的定位类型未在程序中定义，类型为：" + byValue);
             }
         } catch (Exception e) {
             System.out.println("*****没有找到元素,类型为：:" + by + "属性值为：" + byValue + "  的元素或者该元素无法点击****");
             return false;
         }
     }

     /**
      *    定位元素并点击
      */
     public void findElementByIdAndClick(String id) {
         driver.findElement(By.id(id)).click();
     }
     public void findElementByNameAndClick(String name) {
         driver.findElement(By.name(name)).click();
     }
     public void findElementByTextAndClick(String text) {
         driver.findElement(By.linkText(text)).click();
     }
     public void findElementByPartiaTextAndClick(String text) {
         driver.findElement(By.partialLinkText(text)).click();
     }
     public void findElementByXpathAndClick(String xpath) {
         driver.findElement(By.xpath(xpath)).click();
     }
     public void findElementByClassNameAndClick(String name) {
         driver.findElement(By.className(name)).click();
     }

     /**
      *     查找元素并清除文本内容
      * @param by      传入一个类型        例如：name
      * @param byValue 传入一个类型值       例如：username
      */
     public boolean findElementClear(String by, String byValue) {
         try {
             switch (by) {
             case "id":
                 driver.findElement(By.id(byValue)).clear();
                 return true;
             case "name":
                 driver.findElement(By.name(byValue)).clear();
                 return true;
             case "class":
                 driver.findElement(By.className(byValue)).clear();
                 return true;
             case "tag":
                 driver.findElement(By.tagName(byValue)).clear();
                 return true;
             case "link":
                 driver.findElement(By.linkText(byValue)).clear();
                 return true;
             case "partiallinktext":
                 driver.findElement(By.partialLinkText(byValue)).clear();
                 return true;
             case "css":
                 driver.findElement(By.cssSelector(byValue)).clear();
                 return true;
             case "xpath":
                 driver.findElement(By.xpath(byValue)).clear();
                 return true;
             default:
                 throw new RuntimeException("输入的定位类型未在程序中定义，类型为：" + byValue);
             }
         } catch (Exception e) {
             System.out.println("*****没有找到元素,类型为：:" + by + "属性值为：" + byValue + "  的元素或者该元素没有输入值****");
             return false;
         }
     }

     /**
      *     查找元素并输入值
      * @param by      传入一个类型        例如：name
      * @param byValue 传入一个类型值       例如：username
      * @param key     填写要输入的值        例如：zhangsan
      */
     public boolean findElementSendKeys(String by, String byValue, String key) {
         try {
             switch (by) {
             case "id":
                 driver.findElement(By.id(byValue)).sendKeys(key);
                 return true;
             case "name":
                 driver.findElement(By.name(byValue)).sendKeys(key);
                 return true;
             case "class":
                 driver.findElement(By.className(byValue)).sendKeys(key);
                 return true;
             case "tag":
                 driver.findElement(By.tagName(byValue)).sendKeys(key);
                 return true;
             case "link":
                 driver.findElement(By.linkText(byValue)).sendKeys(key);
                 return true;
             case "partiallinktext":
                 driver.findElement(By.partialLinkText(byValue)).sendKeys(key);
             case "css":
                 driver.findElement(By.cssSelector(byValue)).sendKeys(key);
                 return true;
             case "xpath":
                 driver.findElement(By.xpath(byValue)).sendKeys(key);
                 return true;
             default:
                 throw new RuntimeException("输入的定位类型未在程序中定义，类型为：" + byValue);
             }
         } catch (Exception e) {
             System.out.println("*****没有找到元素,类型为：:" + by + "属性值为：" + byValue + "    的元素或者该元素无法输入****");
             return false;
         }
     }
     /**
      *     查找元素并输入值
      * @param by      传入一个类型        例如：name
      * @param byValue 传入一个类型值       例如：username
      * @param key     填写要输入的值        例如：zhangsan
      */
     public boolean findElementClearAndSendKeys(String by, String byValue, String key) {
         try {
             switch (by) {
             case "id":
                 findElementClear(by,byValue);
                 driver.findElement(By.id(byValue)).sendKeys(key);
                 return true;
             case "name":
                 findElementClear(by,byValue);
                 driver.findElement(By.name(byValue)).sendKeys(key);
                 return true;
             case "class":
                 findElementClear(by,byValue);
                 driver.findElement(By.className(byValue)).sendKeys(key);
                 return true;
             case "tag":
                 findElementClear(by,byValue);
                 driver.findElement(By.tagName(byValue)).sendKeys(key);
                 return true;
             case "link":
                 findElementClear(by,byValue);
                 driver.findElement(By.linkText(byValue)).sendKeys(key);
                 return true;
             case "partiallinktext":
                 findElementClear(by,byValue);
                 driver.findElement(By.partialLinkText(byValue)).sendKeys(key);
             case "css":
                 findElementClear(by,byValue);
                 driver.findElement(By.cssSelector(byValue)).sendKeys(key);
                 return true;
             case "xpath":
                 findElementClear(by,byValue);
                 driver.findElement(By.xpath(byValue)).sendKeys(key);
                 return true;
             default:
                 throw new RuntimeException("输入的定位类型未在程序中定义，类型为：" + byValue);
             }
         } catch (Exception e) {
             System.out.println("*****没有找到元素,类型为：:" + by + "属性值为：" + byValue + "    的元素或者该元素无法输入****");
             return false;
         }
     }

     /**
      *    定位元素并清空文本内容，输入相应的值
      */
     public void findElementByIdAndClearSendkeys(String id, String text) {
         driver.findElement(By.id(id)).clear();
         driver.findElement(By.id(id)).sendKeys(text);
     }
     public void findElementByIdAndClearSendkeys(String id, int num) {
         driver.findElement(By.id(id)).clear();
         driver.findElement(By.id(id)).sendKeys(num + "");
     }
     public void findElementByNameAndClearSendkeys(String name, String text) {
         driver.findElement(By.name(name)).clear();
         driver.findElement(By.name(name)).sendKeys(text);
     }
     public void findElementByNameAndClearSendkeys(String name, int num) {
         driver.findElement(By.name(name)).clear();
         driver.findElement(By.name(name)).sendKeys(num + "");
     }
     public void findElementByXpathAndClearSendkeys(String xpath, String text) {
         findElementByXpath(xpath).clear();
         findElementByXpath(xpath).sendKeys(text);
     }
     public void findElementByXpathAndClearSendkeys(String xpath, int num) {
         findElementByXpath(xpath).clear();
         findElementByXpath(xpath).sendKeys(num + "");
     }
     public void findElementByClassnameAndClearSendkeys(String classname, String text) {
         driver.findElement(By.className(classname)).clear();
         driver.findElement(By.className(classname)).sendKeys(text);
     }
     public void findElementByClassnameAndClearSendkeys(String classname, int num) {
         driver.findElement(By.className(classname)).clear();
         driver.findElement(By.className(classname)).sendKeys(num + "");
     }

     /**
      *    定位元素，并获取其文本内容
      */
     public String getTextByXpath(String xpath) {
         return findElementByXpath(xpath).getText();
     }
     public String getTextByClassName(String name) {
         return findElementByClassName(name).getText();
     }
     public String getTextById(String id) {
         return findElementById(id).getText();
     }
     public String getTextByName(String name) {
         return findElementByName(name).getText();
     }

     /**
      *     定位元素，并指定点击次数(连续点击)
      */
     public boolean clickById(String id, int clickCount) {
         try {
             for (int i = 0; i < clickCount; i++) {
                 driver.findElement(By.id(id)).click();
             }
             return true;
         } catch (Exception e) {
             System.out.println(e.getMessage());
             return false;
         }
     }
     public boolean clickByXpath(String xpath, int clickCount) {
         try {
             for (int i = 0; i < clickCount; i++) {
                 driver.findElement(By.xpath(xpath)).click();
             }
             return true;
         } catch (Exception e) {
             System.out.println(e.getMessage());
             return false;
         }
     }
     public boolean clickByCss(String css, int clickCount) {
         try {
             for (int i = 0; i < clickCount; i++) {
                 driver.findElement(By.cssSelector(css)).click();
             }
             return true;
         } catch (Exception e) {
             System.out.println(e.getMessage());
             return false;
         }
     }

     // 判断元素是否存在
     public boolean exists(By selector) {
         driver.manage().timeouts().implicitlyWait(3, TimeUnit.SECONDS);// 设置查询组件等待时间
         try {
             driver.findElement(selector);
             driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);// 设置查询组件等待时间
             return true;
         } catch (Exception e) {
             driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);// 设置查询组件等待时间
             return false;
         }
     }
     /**
      *     判断一个元素是否存在
      */
     public boolean isElementExist(By by) {
         try {
             driver.findElement(by);
             return true;
         } catch (NoSuchElementException e) {
             return false;
         }
     }

     /**
      *    判断一组元素是否存在
      */
     public boolean elementsExists(By by) {
         return (driver.findElements(by).size() > 0) ? true : false;
     }

 //---------------------------------------判断页面是否包含指定文本---------------------------------------------------------
     /**
      *     1、指定时间内等待直到页面包含文本字符串
      * @param text        期望出现的文本
      * @param seconds     超时时间
      * @return Boolean     检查给定文本是否存在于指定元素中, 超时则捕获抛出异常TimeoutException并返回false
      * @see org.openqa.selenium.support.ui.ExpectedConditions.textToBePresentInElement(WebElement
      *      element, String text)
      */
     public static Boolean waitUntilPageContainText(String text, long seconds) {
         try {
             return new WebDriverWait(driver, seconds)
                     .until(ExpectedConditions.textToBePresentInElement(driver.findElement(By.tagName("body")), text));
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }

     /**
      *     2、默认时间等待直到页面包含文本字符串
      * @param text 期望出现的文本
      * @return Boolean 检查给定文本是否存在于指定元素中, 超时则捕获抛出异常TimeoutException并返回false
      * @see org.openqa.selenium.support.ui.ExpectedConditions.textToBePresentInElement(WebElement
      *      element, String text)
      */
     public static Boolean waitUntilPageContainText(String text) {
         try {
             return new WebDriverWait(driver, timeOutInSeconds)
                     .until(ExpectedConditions.textToBePresentInElement(driver.findElement(By.tagName("body")), text));
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }

 //---------------------------------------元素判断---------------------------------------------------------
     /**
      *     1、指定时间内等待直到元素存在于页面的DOM上并可见, 可见性意味着该元素不仅被显示, 而且具有大于0的高度和宽度
      * @param locator 元素定位器
      * @param seconds 超时时间
      * @return Boolean 检查给定元素的定位器是否出现, 超时则捕获抛出异常TimeoutException并返回false
      * @see org.openqa.selenium.support.ui.ExpectedConditions.visibilityOfElementLocated(By
      *      locator)
      */
     public static Boolean waitUntilElementVisible(By locator, int seconds) {
         try {
             new WebDriverWait(driver, seconds).until(ExpectedConditions.visibilityOfElementLocated(locator));
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }

     /**
      *     2、默认时间内等待直到元素存在于页面的DOM上并可见, 可见性意味着该元素不仅被显示, 而且具有大于0的高度和宽度
      * @param locator 元素定位器
      * @return Boolean 检查给定元素的定位器是否出现, 超时则捕获抛出异常TimeoutException并返回false
      * @see org.openqa.selenium.support.ui.ExpectedConditions.visibilityOfElementLocated(By
      *      locator)
      */
     public static Boolean waitUntilElementVisible(By locator) {
         try {
             new WebDriverWait(driver, timeOutInSeconds).until(ExpectedConditions.visibilityOfElementLocated(locator));
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }

     /**
      *    判断元素是否显示
      */
     public boolean getDisplayStatById(String id) {
             return driver.findElement(By.id(id)).isDisplayed();
     }
     public boolean getDisplayStatByXpath(String xpath) {
             return driver.findElement(By.xpath(xpath)).isDisplayed();
     }
     public boolean getDisplayStatByCss(String css) {
         return driver.findElement(By.cssSelector(css)).isDisplayed();
     }
     /**
      *    判断元素是否可写
      */
     public boolean getEnableStatById(String id) {
         return driver.findElement(By.id(id)).isEnabled();
     }
     public boolean getEnableStatByXpath(String xpath) {
         return driver.findElement(By.xpath(xpath)).isEnabled();
     }
     public boolean getEnableStatByCss(String css) {
         return driver.findElement(By.cssSelector(css)).isEnabled();
     }
     /**
      *    判断元素是否选中
      */
     public boolean getSelectStatById(String id) {
         return driver.findElement(By.id(id)).isSelected();
     }
     public boolean getSelectStatByXpath(String xpath) {
         return driver.findElement(By.xpath(xpath)).isSelected();
     }
     public boolean getSelectStatByCss(String css) {
         return driver.findElement(By.cssSelector(css)).isSelected();
     }

     /**
      *     获取当前焦点所在页面元素的属性值(name,value,id,src等等)
      */
     public String getFocusAttributeValue(String attribute) {
         String value = "";
         try {
             Thread.sleep(333);
         } catch (Exception e) {
             e.printStackTrace();
         }
         value = driver.switchTo().activeElement().getAttribute(attribute);
         System.out.println("The focus Element's " + attribute + "attribute value is>>" + value);
         return value;
     }

     // 等待元素可用再点击
     public void waitForEnabledByXpathAndClick(String xpath) throws InterruptedException {
         boolean key = true;
         while (key) {
             if (findElementByXpath(xpath).isEnabled() && findElementByXpath(xpath).isDisplayed()) {
                 clickByJsByXpath(xpath);
                 key = false;
             } else {
                 sleep(0);
             }
         }
     }
     // 自定义等待时间
     public static void sleep(int key) throws InterruptedException {
         switch (key) {
         case 0:
             Thread.sleep(500);
             break;
         case 1:
             Thread.sleep(2000);
             break;
         case 2:
             Thread.sleep(5000);
             break;
         default:
             System.out.println("错误");
             break;
         }
     }

 //---------------------------------------下拉列表操作---------------------------------------------------------
     // 根据id获取下拉框，根据index选择选项
     public void findSelectByIdAndSelectByIndex(String id, int index) {
         Select select = new Select(findElementById(id));
         select.selectByIndex(index);
     }
     // 根据id获取下拉框，根据value选择选项
     public void findSelectByIdAndSelectByValue(String id, String value) {
         Select select = new Select(findElementById(id));
         select.selectByValue(value);
     }
     // 根据id获取下拉框，根据text选择选项
     public void findSelectByIdAndSelectByText(String id, String text) {
         Select select = new Select(findElementById(id));
         select.selectByVisibleText(text);
     }

     // 根据classname获取下拉框，根据text选择选项
     public void findSelectByClassNameAndSelectByText(String name, String text) {
         Select select = new Select(findElementByClassName(name));
         select.selectByVisibleText(text);
     }
     // 根据classname获取下拉框，根据Value选择选项
     public void findSelectByClassNameAndSelectByValue(String name, String value) {
         Select select = new Select(findElementByClassName(name));
         select.selectByValue(value);
     }
     // 根据classname获取下拉框，根据index选择选项
     public void findSelectByClassNameAndSelectByIndex(String name, int index) {
         Select select = new Select(findElementByClassName(name));
         select.selectByIndex(index);
     }

     // 根据name获取下拉框，根据text选择选项
     public void findSelectByNameAndSelectByText(String name, String text) {
         Select select = new Select(findElementByName(name));
         select.selectByVisibleText(text);
     }
     // 根据name获取下拉框，根据Value选择选项
     public void findSelectByNameAndSelectByValue(String name, String value) {
         Select select = new Select(findElementByName(name));
         select.selectByValue(value);
     }
     // 根据name获取下拉框，根据index选择选项
     public void findSelectByNameAndSelectByIndex(String name, int index) {
         Select select = new Select(findElementByName(name));
         select.selectByIndex(index);
     }

     /**
      *     定位select并选中对应text的option
      * @param locator
      * @param text
      * @see org.openqa.selenium.support.ui.Select.selectByVisibleText(String text)
      */
     public static void selectByText(By locator, String text) {
         select = new Select(driver.findElement(locator));
         select.selectByVisibleText(text);
     }

     /**
      *     定位select并选中对应index的option
      * @param locator
      * @param index
      * @see org.openqa.selenium.support.ui.Select.selectByIndex(int index)
      */
     public static void selectByIndex(By locator, int index) {
         select = new Select(driver.findElement(locator));
         select.selectByIndex(index);
     }

     /**
      *    定位select并选中对应value值的option
      * @param locator  定位select的选择器
      * @param value       option 中的value值
      * @see org.openqa.selenium.support.ui.Select.selectByValue(String value)
      */
     public static void selectByValue(By locator, String value) {
         select = new Select(driver.findElement(locator));
         select.selectByValue(value);
     }

 //---------------------------------------弹框操作---------------------------------------------------------
     // 判断是否有弹框
     public boolean isAlertPresent() {
         try {
             alert = driver.switchTo().alert();
             return true;
         } catch (NoAlertPresentException Ex) {
             return false;
         }
     }
     // 接受弹出框
     public void acceptAlert() {
         if (this.isAlertPresent()) {
             alert.accept();
         }
     }
     // 取消弹出框
     public void dimissAlert() {
         if (this.isAlertPresent()) {
             alert.dismiss();
         }
     }
     // 获取弹出内容
     public String getAlertText() {
         String text = null;
         if (this.isAlertPresent()) {
             text = alert.getText();
         } else {
             // todo:log;
         }
         return text;
     }
     // 弹出对话框输入文本字符串
     public void inputTextToAlert(String text) {
         if (this.isAlertPresent()) {
             alert.sendKeys(text);
         } else {
             // todo:log;
         }
     }

 //---------------------------------------窗口和iframe---------------------------------------------------------
     /**
      *     切换到当前页面
      */
     public static void switchToCurrentPage() {
         String handle = driver.getWindowHandle();
         for (String tempHandle : driver.getWindowHandles()) {
             if (tempHandle.equals(handle)) {
                 driver.close();
             } else {
                 driver.switchTo().window(tempHandle);
             }
         }
     }
     /**
      *     切换到指定title的窗口
      */
     public void switchToWindow(String windowTtitle) {
         Set<String> windowHandles = driver.getWindowHandles();
         for (String handler : windowHandles) {
             driver.switchTo().window(handler);
             String title = driver.getTitle();
             if (windowTtitle.equals(title)) {
                 break;
             }
         }
     }

     /**
      *     切换至父级frame
      * @see org.openqa.selenium.WebDriver.TargetLocator.parentFrame()
      */
     public static void switchToParentFrame() {
         driver.switchTo().parentFrame();
     }

     /**
      *     切换默认最外层frame或者窗口
      * @return 这个驱动程序聚焦在顶部窗口/第一个frame上
      * @see org.openqa.selenium.WebDriver.TargetLocator.defaultContent()
      */
     public static void switchToDefault() {
         driver.switchTo().defaultContent();
     }

     /**
      *    切换到指定iframe
      */
     public void switchToFrameById(String frameId) {
         driver.switchTo().frame(frameId);
     }
     public void switchToFrameByIndex(int index) {
         driver.switchTo().frame(index);
     }
     public void switchToframeByElement(By locator) {
         driver.switchTo().frame(driver.findElement(locator));
     }

     /**
      *     提交表单
      * @see org.openqa.selenium.WebElement.submit()
      */
     public static void submitForm(By locator) {
         driver.findElement(locator).submit();
     }

     /**
      *     上传文件
      */
     public static void uploadFile(By locator, String filePath) {
         driver.findElement(locator).sendKeys(filePath);
     }

 //---------------------------------------JS操作---------------------------------------------------------
     // JS点击指定元素
     public void clickByJs(WebElement element) {
          ((JavascriptExecutor) driver).executeScript("arguments[0].click()", element);
     }

     // 定位元素触发JS点击事件
     public void clickByJsByXpath(String xpath) {
         clickByJs(driver.findElement(By.xpath(xpath)));
     }
     public void clickByJsByText(String text) {
         clickByJs(findElementByText(text));
     }
     public void clickByJsById(String id) {
         clickByJs(findElementById(id));
     }
     public void clickByJsByClassName(String name) {
         clickByJs(findElementByClassName(name));
     }
     public void clickByJsByName(String name) {
         clickByJs(findElementByName(name));
     }

     // 滚动到窗口最上方
     public void scrollToTop() {
         ((JavascriptExecutor) driver).executeScript("window.scrollTo(0,0);");
     }
     // 滚动到页面底部
     public void scrollToBottom(String id) {
         ((JavascriptExecutor) driver).executeScript("window.scrollTo(0,10000);");
     }
     // 滚动到某个元素
     public void scrollToElement(WebElement element) {
         JavascriptExecutor js = (JavascriptExecutor) driver;
         js.executeScript("arguments[0].scrollIntoView(true);", element);
     }
     // js给指定元素value赋值
     public void inputTextByJs(String text, WebElement element) {
         JavascriptExecutor js = (JavascriptExecutor) driver;
         js.executeScript("arguments[0].value=" + text + "\"", element);
     }
     // js使元素隐藏元素显示
     public void makeElementDisplay(WebElement element) {
         JavascriptExecutor js = (JavascriptExecutor) driver;
         js.executeScript("arguments[0].style=arguments[1]", element, "display: block;");
     }

 //---------------------------------------浏览器操作---------------------------------------------------------
     /**
      *     关闭当前浏览器
      */
     public static void closeCurrentBrowser() {
         driver.close();
     }
     /**
      *     关闭所有selenium驱动打开的浏览器
      */
     public static void closeAllBrowser() {
         driver.quit();
     }
     /**
      *     最大化浏览器
      */
     public static void maxBrowser() {
         driver.manage().window().maximize();
     }

     /**
      *     自定义设置浏览器尺寸
      */
     public static void setBrowserSize(int width, int heigth) {
         driver.manage().window().setSize(new Dimension(width, heigth));
     }

     /**
      *     获取网页的title值
      */
     public String getTitle() {
         return driver.getTitle();
     }

     /**
      *     获取当前url字符串
      */
     public static String getURL() {
         return driver.getCurrentUrl();
     }

     /**
      *    上一个页面(点击浏览器返回)
      */
     public static void returnToPreviousPage() {
         driver.navigate().back();
     }

     /**
      *     下一个页面(如果没有下一个页面则什么都不做)
      *     浏览器上的前进
      */
     public static void forwardToNextPage() {
         driver.navigate().forward();
     }

     /**
      *     刷新页面
      */
     public static void refreshPage() {
         driver.navigate().refresh();
     }

     // 强制刷新页面
     public void refresh() {
         Actions ctrl = new Actions(driver);
         ctrl.keyDown(Keys.CONTROL).perform();
         try {
             pressKeyEvent(KeyEvent.VK_F5);
         } catch (AWTException e) {
             e.printStackTrace();
         }
         ctrl.keyUp(Keys.CONTROL).perform();
     }

     /**
      *     判断是否加载有JQuery
      */
     public Boolean JQueryLoaded() {
         Boolean loaded;
         JavascriptExecutor js = (JavascriptExecutor) driver;
         try {
             loaded = (Boolean) js.executeScript("return" + "JQuery()!=null");
         } catch (WebDriverException e) {
             loaded = false;
         }
         return loaded;
     }
 //---------------------------------------屏幕截图---------------------------------------------------------
     public void screenShot(WebDriver driver) {
         String dir_name = "screenshot";
         if (!(new File(dir_name).isDirectory())) {
             new File(dir_name).mkdir();
         }
         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd-HHmmss");
         String time = sdf.format(new Date());
         try {
             File source_file = (((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE));// 执行截屏
             FileUtils.copyFile(source_file, new File(dir_name + File.separator + time + ".png"));
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
     // 截图命名为当前时间保存桌面
     public void takeScreenshotByNow() throws IOException {
         File srcFile = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd-HHmmss");
         String time = sdf.format(new Date());
         String file = "C:\\Users\\zhangsan\\Desktop\\picture\\" + time + ".png";
         FileUtils.copyFile(srcFile, new File(file));
     }
     // 截图重命名保存至桌面
     public void takeScreenshotByName(String name) throws IOException {
         File srcFile = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
         String file = "C:\\Users\\zhangsan\\Desktop\\picture\\" + name + ".png";
         FileUtils.copyFile(srcFile, new File(file));
     }

 //---------------------------------------键盘操作---------------------------------------------------------
     // 获取键盘
     public Keyboard getKeyboard() {
         return ((HasInputDevices) driver).getKeyboard();
     }
     // 模拟crtrl+F5
     public void refreshWithCtrlF5() {
         getKeyboard().sendKeys(Keys.CONTROL, Keys.F5);
     }
     /**
      *     按物理按键(KeyEvent类中查找相关的常量)
      *     例子：
      *        Robot robot = new Robot();
      *         robot.keyPress(KeyEvent.VK_ENTER);//按下enter键
      */
     public void pressKeyEvent(int keycode) throws AWTException {
         Robot robot = new Robot();
         robot.keyPress(keycode);
     }

 //---------------------------------------鼠标操作---------------------------------------------------------
     // 鼠标悬浮指定元素并点击
     public void moveToElementById(String id) {
         Actions actions = new Actions(driver);
         actions.moveToElement(findElementById(id)).perform();
     }
     public void moveToElementByClassName(String name) {
         Actions actions = new Actions(driver);
         actions.moveToElement(findElementByClassName(name)).perform();
     }

     // 鼠标右键点击
     public void RightClickWebElement(String id) {
         Actions actions = new Actions(driver);
         actions.contextClick(findElementById(id)).perform();
     }
     // 鼠标双击
     public void DoubleClickWebElement(String id) {
         Actions actions = new Actions(driver);
         actions.doubleClick(findElementById(id)).perform();
     }

     /**
      *    模拟点击键盘上的键：
      *        keyDown()按下
      *        keyUp()抬起,松开
      *
      *    常见的键：
      *        Keys.SHIFT    Keys.ALT   Keys.Tab
      */
     public void ClickCtrl(String id) {
         Actions actions = new Actions(driver);
         actions.keyDown(Keys.CONTROL);//按下control键
         actions.keyUp(Keys.CONTROL);//松开control键
     }

     /**
      *    模拟键盘输入关键字到输入框
      */
     public void sendText(By by,String text) {
         Actions actions = new Actions(driver);
         actions.sendKeys(driver.findElement(by),text).perform();
     }

     /**
      *    模拟鼠标移动到指定元素,并点击
      */
     public void moveToElementAndClick(By by,String text) {
         Actions actions = new Actions(driver);
         actions.moveToElement(driver.findElement(by)).click().perform();
     }

     /**
      *    模拟鼠标点击和释放
      */
     public void clickHoldAndRelease(By by) {
         Actions actions = new Actions(driver);
         actions.clickAndHold(driver.findElement(by)).perform();
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         actions.release(driver.findElement(by)).perform();
     }

 //---------------------------------------Cookie操作---------------------------------------------------------
     /**
      *     获取当前域所有的cookies
      * @return Set&lt;Cookie> 当前的cookies集合
      * @see org.openqa.selenium.WebDriver.Options.getCookies()
      */
     public static Set<Cookie> getAllCookies() {
         return driver.manage().getCookies();
     }
     // 输出cookies信息
     public void outputCookie() {
         Set<Cookie> cookie = driver.manage().getCookies();
         System.out.println(cookie);
     }
     //添加cookie信息
     public void addCookie(Map<String, String> args) {
         Set<String> keys = args.keySet();
         for (String key : keys) {
             driver.manage().addCookie(new Cookie(key, args.get(key)));
         }
     }
     /**
      *     用给定的name和value创建默认路径的Cookie并添加, 永久有效
      * @param name
      * @param value
      * @see org.openqa.selenium.WebDriver.Options.addCookie(Cookie cookie)
      * @see org.openqa.selenium.Cookie.Cookie(String name, String value)
      */
     public static void addCookie(String name, String value) {
         driver.manage().addCookie(new Cookie(name, value));
     }

     /**
      *     用给定的name和value创建指定路径的Cookie并添加, 永久有效
      * @param name  cookie名称
      * @param value cookie值
      * @param path  cookie路径
      */
     public static void addCookie(String name, String value, String path) {
         driver.manage().addCookie(new Cookie(name, value, path));
     }
     /**
      *     根据cookie名称删除cookie
      * @param name cookie的name值
      * @see org.openqa.selenium.WebDriver.Options.deleteCookieNamed(String name)
      */
     public static void deleteCookie(String name) {
         driver.manage().deleteCookieNamed(name);
     }
     /**
      *     删除当前域的所有Cookie
      * @see org.openqa.selenium.WebDriver.Options.deleteAllCookies()
      */
     public static void deleteAllCookies() {
         driver.manage().deleteAllCookies();
     }

     /**
      *     根据名称获取指定cookie
      * @param name cookie名称
      * @return Map&lt;String, String>, 如果没有cookie则返回空, 返回的Map的key值如下:
      *         <ul>
      *         <li><tt>name</tt> <tt>cookie名称</tt>
      *         <li><tt>value</tt> <tt>cookie值</tt>
      *         <li><tt>path</tt> <tt>cookie路径</tt>
      *         <li><tt>domain</tt> <tt>cookie域</tt>
      *         <li><tt>expiry</tt> <tt>cookie有效期</tt>
      *         </ul>
      * @see org.openqa.selenium.WebDriver.Options.getCookieNamed(String name)
      */
     public static Map<String, String> getCookieByName(String name) {
         Cookie cookie = driver.manage().getCookieNamed(name);
         if (cookie != null) {
             Map<String, String> map = new HashMap<String, String>();
             map.put("name", cookie.getName());
             map.put("value", cookie.getValue());
             map.put("path", cookie.getPath());
             map.put("domain", cookie.getDomain());
             map.put("expiry", cookie.getExpiry().toString());
             return map;
         }
         return null;
     }

 //---------------------------------------远程---------------------------------------------------------
     /**
      *     进入测试，打开浏览器，输入网址，打开网页
      *
      * @param remoteUrl 远程服务器地址
      * @param pageUrl   测试页面地址
      */
     public boolean startTest(String remoteUrl, String pageUrl) {
         try {
             try {
                 driver = new RemoteWebDriver(new URL(remoteUrl), DesiredCapabilities.firefox());
             } catch (MalformedURLException e) {
                 e.printStackTrace();
             }
             driver.get(pageUrl);
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             System.out.println(e.getMessage());
             return false;
         }
     }

     /**
      *     进入测试，打开浏览器，输入网址，打开网页
      * @param explore   调用的浏览器，需要启动不同的server
      *                     如：firefox，需要运行selenium-server-standalone-2.33.0.jar。
      *                        IE，则需运行IEDriverServer.exe
      * @param remoteUrl 远程服务器地址
      * @param pageUrl   测试页面地址
      */
     public boolean startTest(String explore, String remoteUrl, String pageUrl) {
         try {
             try {
                 if ("f".equals(explore)) {
                     System.out.println("firefox");
                     driver = new RemoteWebDriver(new URL(remoteUrl), DesiredCapabilities.firefox());
                 } else if ("ie".equals(explore)) {
                     System.out.println("internet explorer");
                     DesiredCapabilities cap = DesiredCapabilities.internetExplorer();
                     driver = new RemoteWebDriver(new URL(remoteUrl), cap);
                 } else {
                     System.out.println("firefox");
                     driver = new RemoteWebDriver(new URL(remoteUrl), DesiredCapabilities.firefox());
                 }
             } catch (Exception e) {
                 e.printStackTrace();
             }
             driver.get(pageUrl);
             return true;
         } catch (Exception e) {
             System.out.println(e.getMessage());
             return false;
         }
     }
 }