软件测试实验

软件测试实验

实验一 单元测试JUnit4基础

基础知识

• 包含必要的Package

  • 在测试类中用到了JUnit4框架，自然要把相应地org.junit.*包含进来,我们在进行单元测试的时候使用的一系列assertEquals方法就来自这个包.

    import static org.junit.Assert
    

  • 这是一个静态包含（static），也就是说，assertEquals是Assert类中的一系列的静态方法，一般的使用方式是Assert. assertEquals()，但是使用了静态包含后，前面的类名就可以省略了

• 测试类的声明

  • 测试类是一个独立的类，没有任何父类。
  • 测试类的名字也可以任意命名，没有任何局限性。
  • 我们不能通过类的声明来判断它是不是一个测试类，它与普通类的区别在于它内部的方法的声明

• 创建一个待测试的对象

  测试哪个类，那么你首先就要创建一个该类的对象,为了测试Calculator类，我们必须创建一个calculator对象

  private static Calculator calculator = new Calculator();
  

• 测试方法的声明

  在测试类中，并不是每一个方法都是用于测试的，你必须使用“标注”来明确表明哪些是测试方法

  • @Before

    使用了该元数据的方法在每个测试方法执行之前都要执行一次。

  • @After

    使用了该元数据的方法在每个测试方法执行之后要执行一次。

    @Before和@After标示的方法只能各有一个。这个相当于取代了JUnit以前版本中的setUp和tearDown方法，还可以继续叫这个名字。

  • @Test(expected=*.class)

    在JUnit4.0之前，对错误的测试，我们只能通过fail来产生一个错误，并在try块里面assertTrue（true）来测试。现在，通过@Test元数据中的expected属性。expected属性的值是一个异常的类型：

  • @Test(timeout=xxx):

    该元数据传入了一个时间（毫秒）给测试方法，如果测试方法在制定的时间之内没有运行完，则测试也失败

  • @ignore：

    该元数据标记的测试方法在测试中会被忽略。当测试的方法还没有实现，或者测试的方法已经过时，或者在某种条件下才能测试该方法（比如需要一个数据库联接，而在本地测试的时候，数据库并没有连接），那么使用该标签来标示这个方法。同时，你可以为该标签传递一个String的参数，来表明为什么会忽略这个测试方法。比如：@lgnore(“该方法还没有实现”)，在执行的时候，仅会报告该方法没有实现，而不会运行测试方法

实验内容

• 传统测试

  • 原类

    package lab1;
    
    import org.junit.Test;
    
    public class Circle {
    
      private double radius;
    
      Circle() {
        radius = 1.0;
      }
    
      Circle(double newRadius) {
        radius = newRadius;
      }
    
      double getPerimeter() {
        return 2 * radius * Math.PI;
      }
    
      double getArea() {
        return radius * radius * Math.PI;
      }
    
      public double getRadius() {
        return radius;
      }
      public void setRadius(double Radius) {
        this.radius = Radius;
      }
    }
    
    

  • 测试类

    public class TestCircle {
    	public static void main(String[] args) {
    		
    		Circle cir1 = new Circle();
    		System.out.println("测试默认构造，圆的半径为1.0=："+cir1.getRadius());
    		Circle cir2 = new Circle(3.0);
    		System.out.println("测试半径为3的构造圆，圆的半径为3.0=："+cir1.getRadius());
    		System.out.println("测试半径为1构造圆，圆的周长为："+cir1.getPerimeter());
    	}
    }
    

• junit测试

  • 原类

    public class Calculate {
    
      private static int result;
    
      public void add(int n) {
        result = result + n;
      }
    
      public void substract(int n){
        result=result-n;
      }
    
      public void multiply(int n){
        result=result*1;
      }
      public void divide(int n){
        result=result/n;
      }
    
      public void square(int n){
        result=n*n;
      }
    
      public void squareRoot(int n){
        for(;;);
      }
    
      public void clear(){
        result=0;
      }
    
      public int getResult(){
        return result;
      }
      public void setResult(int n){
        result=n;
      }
    }
    

  • 测试类

    import static org.junit.Assert.*;
    
    import org.junit.Before;
    import org.junit.Ignore;
    import org.junit.Test;
    
    /**
     * @Description:
     * @Author: duanyf
     * @DateTime: 2022/4/16 0016 15:31
     */
    public class CalculateTest {
      private static Calculate calculate=new Calculate();
      @Before
      public void setUp()throws Exception{
        calculate.clear();
      }
      @Test
      public void add() {
    //    calculate.setResult(0);
        calculate.add(2);
        calculate.add(2);
        assertEquals(4,calculate.getResult());
      }
    
      @Test
      public void substract() {
    //    calculate.setResult(0);
        calculate.add(10);
        calculate.substract(2);
        assertEquals(8,calculate.getResult());
      }
      @Ignore("mutiply() Not yet implemented")
      @Test
      public void multiply() {
    //    calculate.setResult(0);
        calculate.add(5);
        calculate.multiply(2);
        assertEquals(10,calculate.getResult());
      }
    
      @Test
      public void divide() {
    //    calculate.setResult(0);
        calculate.add(8);
        calculate.divide(2);
        assertEquals(4,calculate.getResult());
      }
    }
    

实验二 单元测试JUnit4进阶

• 编写BubbleSort类，实现冒泡排序

  public class BubbleSort {
    public void sort(int []a){
      int temp=0;
      for (int i = a.length-1; i >0; --i) {
        for (int j = 0; j < i; ++j) {
          if (a[j+1]<a[j]){
            temp=a[j];
            a[j]=a[j+1];
            a[j+1]=temp;
          }
        }
      }
    }
  }
  

• 编写BubbleSort测试类TestBubbleSort，实现测试，运行并查看结果

  public class TestBubbleSort {
    public static  void main(String[] args){
      int [] arr=new int[10];
      BubbleSort mySort=new BubbleSort();
      for (int i=0;i<arr.length;i++){
        int temp=(int)(Math.random()*10)+1;
        //将产生的数添加到数组中
        arr[i]=temp;
        System.out.println(arr[i]+" ");
        if((i+1)%10==0){
          System.out.println();
        }
      }
      mySort.sort(arr);
      for (int x=0;x< arr.length;x++){
        System.out.println(arr[x]+" ");
        if((x+1)%10==0){
          System.out.println();
        }
      }
    }
  }
  

• 立一个Junit测试用例类BubbleSortTest，用于测试BubbleSort
  1.测试该排序方法对10000个1-10000之间的随机整数进行排序，时间小于200毫秒，是否满足时间性能需求；
  2.测试该排序功能的正确性。

  import static org.junit.Assert.*;
  
  import org.junit.Before;
  import org.junit.Test;
  
  /**
   * @Description:
   * @Author: duanyf
   * @DateTime: 2022/4/23 0023 8:16
   */
  public class BubbleSortTest {
    private static BubbleSort bubbleSort=new BubbleSort();
    int [] arr=new int[10000];
    int [] intp={5,4,3,2,1};
    int [] exce={1,2,3,4,5};
  
  
    @Before
    public void setUp() throws Exception {
      for (int i=0;i<arr.length;i++){
        int temp=(int)(Math.random()*10000)+1;
        //将产生的数添加到数组中
        arr[i]=temp;
      }
    }
  
    @Test
    public void testsort() {
      bubbleSort.sort(intp);
      for (int i=0;i<intp.length;i++){
        assertEquals(exce[i],intp[i]);
      }
    }
  
    @Test(timeout = 200)
    public void sort() {
  
      bubbleSort.sort(arr);
    }
  }
  

• 添加Calculator类；简单实现加减乘除、平方、开方的计算器类，然后对这些功能进行Junit单元测试。这个类并不是很完美，并保留了一些Bug用于实验，这些Bug在注释中都有说明。

  public class Calculate {
  
    private static int result;
  
    public void add(int n) {
      result = result + n;
    }
  
    public void substract(int n){
      result=result-n;
    }
  
    public void multiply(int n){
      result=result*n;
    }
    public void divide(int n){
      result=result/n;
    }
  
    public void square(int n){
      result=n*n;
    }
  
    public void squareRoot(int n){
      for(;;);
    }
  
    public void clear(){
      result=0;
    }
  
    public int getResult(){
      return result;
    }
    public void setResult(int n){
      result=n;
    }
  }
  

• 限时测试：在Junit中对Calculator类的方法squareRoot进行限时测试，测试死循环
  测试异常：在Junit中对Calculator类的方法divide进行异常测试，测试除数为0时的异常处理

  import static org.junit.Assert.*;
  
  import org.junit.Before;
  import org.junit.Test;
  
  /**
   * @Description:
   * @Author: duanyf
   * @DateTime: 2022/4/23 0023 8:24
   */
  public class CalculateTest {
    private static Calculate calculate=new Calculate();
    @Before
    public void setUp() throws Exception {
      calculate.clear();
    }
  
    @Test
    public void add() {
      calculate.add(2);
      calculate.add(2);
      assertEquals(4,calculate.getResult());
    }
  
    @Test
    public void substract() {
      calculate.add(10);
      calculate.substract(2);
      assertEquals(8,calculate.getResult());
    }
  
    @Test
    public void multiply() {
      calculate.add(5);
      calculate.multiply(2);
      assertEquals(10,calculate.getResult());
    }
  
    @Test(expected = ArithmeticException.class)
    public void divide() {
  //    calculate.add(8);
      calculate.divide(0);
  //    assertEquals(4,calculate.getResult());
    }
  
    @Test
    public void square() {
      calculate.add(2);
      calculate.square(2);
      assertEquals(4,calculate.getResult());
    }
  
    @Test(timeout =2000)
    public void squareRoot() {
      calculate.squareRoot(4);
      assertEquals(2,calculate.getResult());
    }
  }
  

• square方法测试：编写AdvancedTest类，测试Calculator类的计算一个数的平方square方法，分三类：正数、0、负数测试一下这个函数。

  import static org.junit.Assert.*;
  
  import org.junit.Before;
  import org.junit.Test;
  
  /**
   * @Description:测试Calculator的square方法
   * @Author: duanyf
   * @DateTime: 2022/4/23 0023 8:37
   */
  public class AdvancedTest {
    public static  Calculate calculate=new Calculate();
    @Before
    public void setUp() throws Exception {
      calculate.clear();
    }
  
    @Test
    public void square1() {
      calculate.square(2);
      assertEquals(4,calculate.getResult());
    }
  
    @Test
    public void square2() {
      calculate.square(0);
      assertEquals(0,calculate.getResult());
    }
  
    @Test
    public void square3() {
      calculate.square(-3);
      assertEquals(9,calculate.getResult());
    }
  }
  

• 参数化测试：

  1. 定义了一个SquareTest类。并为这个类指定一个Runner，而不能使用默认的Runner了，@RunWith(Parameterized.class)这条语句就是为这个类指定了一个ParameterizedRunner。
  2. 定义一个待测试的类，并且定义两个变量，一个用于存放参数，一个用于存放期待的结果。
  3. 定义测试数据的集合data()方法，该方法可以任意命名，但是必须使用@Parameters标注进行修饰。其中的数据，是一个二维数组，数据两两一组，每组中的这两个数据，一个是参数，一个是你预期的结果。比如我们的第一组{2, 4}，2就是参数，4就是预期的结果。
  4. 构造函数，其功能就是对先前定义的两个参数进行初始化。参数要和上面的数据集合的顺序保持一致。如果前面的顺序是{参数，期待的结果}，那么你构造函数的顺序也要是“构造函数(参数， 期待的结果)。

  import static org.junit.Assert.*;
  
  import java.util.Arrays;
  import java.util.Collection;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.junit.runners.Parameterized;
  import org.junit.runners.Parameterized.Parameters;
  
  /**
   * @Description:对Calculate的square进行参数化测试
   * @Author: duanyf
   * @DateTime: 2022/4/23 0023 8:46
   */
  @RunWith(Parameterized.class)
  public class SquareTest {
    private static Calculate calculate=new Calculate();
    private int param;//存放参数
    private int result;//存放结果
  
    @Parameters
    public static Collection data(){
      //下方数组中的数据一个是参数一个是结果
      return Arrays.asList(new Object[][]{
          {2,4},
          {0,0},
          {-3,9},
      });
    }
  
    public SquareTest(int param,int result){
      this.param=param;
      this.result=result;
    }
  
    @Test
    public void square() {
      calculate.square(param);
      assertEquals(result,calculate.getResult());
    }
  }
  

实验三 Selenium功能测试

了解Selenium自动化测试工具；

• Selenium IDE简介

  Selenium IDE(集成开发环境)是Selenium Suite下的开源Web自动化测试工具。 与Selenium WebDriver和RC不同，它不需要任何编程逻辑来编写其测试脚本，而只需记录与浏览器的交互以创建测试用例。 之后，可以使用播放选项重新运行测试用例。Selenium IDE仅作为Mozilla Firefox和Chrome插件提供，它无法在Firefox和Chrome以外的浏览器上记录测试用例。记录的测试脚本也可以导出到C#，Java，Ruby或Python等编程语言。

• Selenium IDE功能

  • Selenium IDE的七个不同组件进行了分类，其中包括:菜单栏、工具栏、地址栏、测试案例窗格、测试脚本编辑器框、开始/停止录制按钮、日志，引用窗格。

    

  • 菜单栏

    菜单栏位于Selenium IDE界面的最顶部。 最常用的菜单栏模块包括:

    • 项目名 - 它用于重命名整个项目。

    

    • 打开项目 - 它用于从个人驱动器加载任何现有项目。

    

    • 保存项目 - 它用于保存当前正在处理的整个项目。

    

  • 工具栏

    工具栏包含用于控制测试用例执行的模块。 此外，它还为提供了调试测试用例的步骤功能。

    • 速度控制选项 - 它用于控制测试用例的执行速度。

    

    • 步骤功能 - 它用于进入步骤，通过测试用例一次运行一个命令。用于调试测试用例。

    

    • 运行测试 - 它用于运行当前选定的测试。 只加载一个测试，运行测试， 按钮和运行全部，按钮具有相同的效果。

    

    • 全部运行- 它用于在加载具有多个测试用例的测试套件时运行整个测试套件。

      

  • 地址栏

    此模块提供了一个下拉菜单，可以记住基本URL的所有先前值。 简单来说，基本URL地址栏会记住以前访问过的网站，以便以后导航变得容易。

    

  • 测试用例窗格

    测试用例窗格下同时提供所有记录的测试用例的列表，以便用户可以轻松地在测试用例之间进行选择。在测试用例窗格的底部，可以看到测试执行结果摘要，其中包括各种测试用例的通过/失败状态。测试用例窗格还包括导航面板等功能，允许用户在测试用例和测试套件之间导航。

    

  • 测试脚本编辑器框

    “测试脚本编辑器框”显示IDE记录的所有测试脚本和用户交互。 每个用户交互的显示顺序与执行顺序相同。 “编辑器”框分为三列:命令，目标和值。

    • 命令:可以将命令视为在浏览器元素上执行的实际操作/操作。 例如，如果要打开一个新URL，该命令是:open ,如果单击网页上的链接或按钮，则该命令为:click 。

    • 目标:Target 指定必须在其上执行操作的web元素以及locator属性。 例如，如果单击名yiibai.com 项，那么目标链接是 yiibai.com* 。

    • 值：值被视为可选字段，可在需要发送一些实际参数时使用。 例如，如果在文本框中输入电子邮件地址或密码，则该值将包含实际凭据。

      

  • 开始/停止录制按钮

    “记录”按钮记录浏览器的所有用户操作。

    

  • 日志，引用窗格

    日志窗格在执行期间显示运行时消息。 它提供IDE执行的操作的实时更新。 它可以分为四种类型：信息，错误，调试和警告。引用窗格在编辑器中显示当前所选selenese命令的完整详细信息。

    

• Selenium命令的类型

  Selenium命令基本上分为三类:操作、访问器和断言。

  • 操作

    操作(动作)是通常操纵应用程序状态的selenium命令。 执行操作会生成诸如单击此链接，选择该选项，键入此框等事件。如果操作失败或有错误，则停止执行当前测试。一些最常用的操作命令包括:

    

  • 访问器

    访问器是selenium命令，用于检查应用程序的状态并将结果存储在变量中。 它们还用于自动生成断言。一些最常用的访问器(Accessors)命令包括:

    

  • 断言

    断言是使测试人员能够验证应用程序状态的命令。 断言通常用于断言，验证和等待三种模式。一些最常用的断言命令是：

    

实验内容

• 下载安装谷歌浏览器；

• 在谷歌浏览器的谷歌商店安装selenium Ide；

• 使用selenium Ide对http://www.baidu.com进行测试；

  • 录制

    • 启动Firefox浏览器；

    • 单击浏览器右上角的Selenium图标，打开Selenium IDE；

    • 创建一个新的测试项目，将测试项目命名为:姓名+test；

    • 在测试用例窗格，将测试用例重命名为:baidutest；

    • 在地址栏设置baseURL为:https://www.baidu.com；

    • 点击:开始录制按钮可以开始记录测试用例；

    • 在测试打开的百度网站搜索栏中输入“软件测试”并点击“百度一下”；

    • 转到IDE并单击“停止录制”

    • 查看“测试编辑器”中的命令，目标和值。

      

  • 回放：在IDE的工具栏菜单上的按钮，点击“运行当前测试”。

    

  • 保存：单击菜单栏最右侧的保存按钮，保存测试项目。

  • 清除：鼠标右键单击测试脚本编辑器框，弹出菜单栏中点击清除所有的命令。

  • 打开项目：单击菜单栏打开按钮，打开测试项目。

  • 进行回放和设值：根据测试脚本运行情况，调整执行速度，或者对打开窗体的设值，保证测试通过。

    

• 使用selenium Ide对自选XX网站进行测试；

（1）、访问XX网站注册测试的账号和密码；

（2）、使用selenium Ide对登录过程进行录制测试脚本；

（3）、播放，运行脚本进行测试，并保证登录测试通过；

（4）、编辑测试脚本，添加“退出”的命令脚本；

（5）、播放，运行脚本进行测试，并保证登录和退出测试通过；

（6）、保存测试项目。

• 使用selenium Ide手动创建测试用例

（1）、启动Firefox浏览器。

（2）、单击浏览器右上角的Selenium图标。

（3）、它将启动Selenium IDE的默认界面。

（4）、输入项目名称为“手动测试”。

（5）、输入测试用例名称为：搜索测试 。

（6）、单击“测试脚本编辑器”框中的命令文本框。

（7）、在base URL地址栏中输入：https://www.baidu.com/

（8）、添加第一命令和目标，打开百度主页，如命令(Command)：open。目标(Target)：“https://www.baidu.com/”或者“/”。

（9）、添加第二个命令和目标，单击百度搜索引擎文本框。在Firefox 浏览器中访问百度主页，鼠标右键点击搜索输入框，弹出菜单中选择“检查元素”查看ID进行目标定位。

（10）、添加第三个命令，目标和值，在百度搜索文本框中键入指定的文本“Selenium”。

（11）、添加第四个命令和目标，单击“百度一下”按钮。

（12）、添加第五个命令，目标和值，使用断言验证搜索结果。如命令：assert text，目标：linkText=Selenium_百度百科，值：Selenium_百度百科。

（13）、运行测试脚本，查看和记录测试日志。

实验四 Selenium WebDrive功能测试

了解Selenium WebDrive

• Selenium WebDrive概述

  • Selenium WebDriver是Selenium Tool套件中最重要的组件， 最新版本“Selenium 3.0”与WebDriver API集成，提供更简单，更简洁的编程接口。在WebDriver中，可以使用任何支持的编程语言开发测试脚本，并且可以在大多数现代Web浏览器中直接运行，SeleniumWebDriver提供了一个编程接口来创建和执行测试用例。 编写测试脚本是为了识别网页上的Web元素，然后对这些元素执行所需的操作。WebDriver支持的语言包括C#，Java，Perl，PHP，Python和Ruby。Selenium WebDriver API提供编程语言和浏览器之间的通信工具。

  • WebDriver架构有四个基本组件:下图显示了Selenium WebDriver的体系结构表示

    

    • Selenium语言绑定/Selenium客户端库

      Selenium开发人员已经构建了语言绑定/Selenium客户端库以支持多种语言。 例如，如果要在java中使用浏览器驱动程序，请使用java绑定。 所有受支持的语言绑定都可以从Selenium的官方网站： https://www.seleniumhq.org/download/下载。

    • JSON有线协议

      JSON(JavaScript Object Notation)是一种用于在Web上交换数据的开放标准。 它支持对象和数组等数据结构。 因此，从JSON编写和读取数据很容易。JSON Wire Protocol提供了一种在服务器和客户端之间传输数据的传输机制。JSON Wire Protocol是各种REST Web服务的行业标准。

    • 浏览器驱动

      Selenium使用特定于每个浏览器的驱动程序，以便与浏览器建立安全连接，而不会泄露浏览器功能的内部逻辑。 浏览器驱动程序也特定于用于自动化的语言，如Java，C#等。当使用WebDriver执行测试脚本时，将在内部执行以下操作。生成HTTP请求并将其发送到每个Selenium命令的浏览器驱动程序。驱动程序通过HTTP服务器接收HTTP请求。HTTP Server决定执行在浏览器上执行的指令的所有步骤。执行状态将发送回HTTP Server，随后将其发送回自动化脚本。

    • 浏览器

      Selenium WebDriver支持的浏览器：Internet Explorer、Mozilla Firefox、Google Chrome、Safari。

• Selenium WebDrive安装配置

  ​ Selenium WebDriver安装过程分四个基本步骤完成:

  • 下载并安装Java 8或更高版本。
  • 下载并配置Eclipse或选择其它Java IDE。
  • 下载Selenium WebDriver Java客户端
  • 配置Selenium WebDriver

• Selenium WebDrive定位策略

  与Selenium IDE一样，WebDriver使用相同的定位策略集来指定特定Web元素的位置。因为，正在使用带有Java的WebDriver; 每个定位策略在Java中都有自己的命令来定位Web元素。WebDriver中使用的定位策略列表:

  

  通过单击鼠标右键，在弹出菜单中选择“查看元素”，选择相关元素查看ID。

  

• Selenium WebDrive方法

  • 获取网页

    获取网页有两种方法:

    1. 使用Get方法 driver.get("www.baidu.com");
    2. 使用Navigate方法 driver.navigate().to("https://www.baidu.com ");

  • 查找表单并发送用户输入

    driver.findElement(By.id("kw")).sendKeys("selenium");
    

  • 清除用户输入

    clear()方法用于从文本框中清除用户输入。

    driver.findElement(By.name("selenium")).clear();
    

  • 通过Web元素获取数据

    有时需要获取通过web元素写入的文本来执行某些断言和调试。使用getText()方法来获取通过任何web元素写入的数据。

    driver.findElement(By.id("kw")).getText();
    

  • 执行Click事件

    click()方法用于对任何Web元素执行单击操作。

    driver.findElement(By.id("su")).click();
    //或者
    driver.findElement(By.xpath("//input[@id='su']")).click();
    

  • 在浏览器历史记录中向后导航

    driver.navigate().back();
    

  • 在浏览器历史记录中向前导航

    driver.navigate().forward();
    

  • 刷新/重新加载网页

    driver.navigate().refresh();
    

  • 关闭浏览器

    driver.close();
    

  • 关闭浏览器和与驱动程序关联的其他所有其他窗口

    driver.quit();
    

  • 在Windows之间移动

    driver.switchTo().window("windowName");
    

  • 在 frame 之间移动

    driver.switchTo().frame("frameName");
    

  • 拖放

    使用Action类执行拖放操作。

    WebElement element = driver.findElement(By.name("source"));  
    WebElement target = driver.findElement(By.name("target")); 
    

  • 放置一个隐式等待

    //将在引发异常之前等待10秒,浏览器同步：
    driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
    //当前线程休眠,进入阻塞状态(暂停执行)与IterruptedException中断异常；
    Thread.sleep(1000);
    

  • 浏览器调整大小

    //浏览器最大化：
    driver.manage().window().maximize();
    //设定大小：
    driver.manage().window().setSize(new Dimension(1280, 780));
    

• 下载相关浏览器引擎和进行系统属性设置及实例化

  • 在Chrome浏览器上运行Selenium测试脚本
    在浏览器中打开URL: https://sites.google.com/a/chromium.org/chromedriver/downloads
    然后根据当前正在使用的操作系统单击相应的ChromeDriver下载版本。

  • 将系统属性“webdriver. chrome.driver” 设置为chromedriver.exe文件的路径并实例化

    // System Property for Chrome Driver 
    System.setProperty("webdriver.chrome.driver", "D:\\software\\webdriver\\chromedriver.exe");
    // Instantiate a ChromeDriver class. 
    WebDriver driver=new ChromeDriver(); 
    

• Selenium IDE导出Java Junit代码

  

  

实验内容(我使用的是谷歌)

1、搭建火狐浏览器的WebDriver测试环境：

（1）下载安装火狐浏览器；

（2）下载安装Selenium WebDriver Java客户端

（3）下载安装相应的GeckoDriver版本

2、启动Eclipse IDE并建立一个新的Java项目WebDriverTest，并进行Selenium WebDriver配置

3、新建一个java类BdTest，编写程序实现以下一个测试用例，尝试在Firefox浏览器中自动执行以下测试方案。

• 启动Firefox浏览器。
• 打开URL : www.baidu.com
• 单击“搜索”文本框
• 输入值“selenium”
• 单击“搜索”按钮。

4、BdTest类中，main方法代码要求如下：

（1）设置系统属性为gecko驱动

（2）声明变量和实例化

（3）放置一个隐式等待，将在引发异常之前等待10秒,浏览器同步

（4）打开百度网站

（5）浏览器最大化

（6）单击百度网站搜索框

（7）在搜索框中输入“selenium”

（8）单击百度一下

（9）关闭浏览器

package lab4;

import java.util.concurrent.TimeUnit;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

/**
 * @Description:
 * @Author: duanyf
 * @DateTime: 2022/5/21 0021 15:27
 */
public class Test {

  public static void main(String[] args) throws InterruptedException {
    testBaidu();
  }
  public static void testBaidu() throws InterruptedException {
    System.setProperty("webdriver.chrome.driver", "D:\\学无止境\\计算机工具\\chromedriver\\chromedriver.exe");
    WebDriver driver = new ChromeDriver(); //(Chrome浏览器)
    //放置一个隐式等待,将在引发异常之前等待10秒，浏览器同步
    driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
    //打开百度网站
    driver.navigate().to("https://www.baidu.com");
    //浏览器最大化
    driver.manage().window().maximize();
    //单击百度网站搜索框
    driver.findElement(By.id("kw")).click();
    //在搜索框中输入selenium
    driver.findElement(By.id("kw")).sendKeys("selenium");
    //点击百度一下
    driver.findElement(By.id("su")).click();
    Thread.sleep(3000);
    //关闭浏览器
    driver.close();
  }
}

5、使用Selenium IDE、Junit和WebDriver进行自动化测试，并查看记录测试结果；

（1）使用Selenium IDE打开百度网站的测试项目，导出java Junit测试代码。

package lab4;// Generated by Selenium IDE
import org.junit.Test;
import org.junit.Before;
import org.junit.After;
import static org.junit.Assert.*;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.core.IsNot.not;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.Dimension;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.interactions.Actions;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.Alert;
import org.openqa.selenium.Keys;
import java.util.*;
import java.net.MalformedURLException;
import java.net.URL;
public class BaidutestTest {
  private WebDriver driver;
  private Map<String, Object> vars;
  JavascriptExecutor js;
  @Before
  public void setUp() {
    System.setProperty("webdriver.chrome.driver", "D:\\学无止境\\计算机工具\\chromedriver\\chromedriver.exe");
    driver = new ChromeDriver();
    js = (JavascriptExecutor) driver;
    vars = new HashMap<String, Object>();
  }
  @After
  public void tearDown() {
    driver.quit();
  }
  @Test
  public void baidutest() {
    driver.get("https://www.baidu.com");
    driver.manage().window().setSize(new Dimension(1278, 680));
    driver.findElement(By.id("kw")).click();
    driver.findElement(By.id("kw")).sendKeys("软件测试");
    driver.findElement(By.id("kw")).sendKeys(Keys.ENTER);
    {
      WebElement element = driver.findElement(By.id("kw"));
      Actions builder = new Actions(driver);
      builder.moveToElement(element).perform();
    }
    {
      WebElement element = driver.findElement(By.tagName("body"));
      Actions builder = new Actions(driver);
      builder.moveToElement(element, 0, 0).perform();
    }
  }
}

（2）使用使用Selenium IDE打开XX网站的登录测试项目，导出java Junit测试代码。

package lab4;// Generated by Selenium IDE
import org.junit.Test;
import org.junit.Before;
import org.junit.After;
import static org.junit.Assert.*;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.core.IsNot.not;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.Dimension;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.interactions.Actions;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.Alert;
import org.openqa.selenium.Keys;
import java.util.*;
import java.net.MalformedURLException;
import java.net.URL;
public class Test2 {
  private WebDriver driver;
  private Map<String, Object> vars;
  JavascriptExecutor js;
  @Before
  public void setUp() {
    System.setProperty("webdriver.chrome.driver", "D:\\学无止境\\计算机工具\\chromedriver\\chromedriver.exe");
    driver = new ChromeDriver();
    js = (JavascriptExecutor) driver;
    vars = new HashMap<String, Object>();
  }
  @After
  public void tearDown() {
    driver.quit();
  }
  @org.junit.Test
  public void Test2() {
    driver.get("http://www.92ydl.com/");
    driver.manage().window().setSize(new Dimension(1278, 680));
    driver.findElement(By.id("ls_username")).click();
    driver.findElement(By.id("ls_username")).sendKeys("duanyf");
    driver.findElement(By.id("ls_password")).click();
    driver.findElement(By.id("ls_password")).sendKeys("自己填写密码");
    driver.findElement(By.cssSelector(".pn > em")).click();
//    driver.findElement(By.linkText("退出")).click();
  }
}

（3）WebDriverTest项目中打开以上两个类，完善代码，在Junit中运行测试。

实验五 Jmeter性能测试

了解Jmeter

原文链接：https://blog.csdn.net/pengjiangchun/article/details/105707405

• Jmeter主要元件

  • 测试计划：是使用 JMeter 进行测试的起点，它是其它 JMeter测试元件的容器

  • 线程组：代表一定数量的用户，它可以用来模拟用户并发发送请求。实际的请求内容在Sampler中定义，它被线程组包含。

  • 配置元件：维护Sampler需要的配置信息，并根据实际的需要修改请求的内容。

  • 前置处理器：负责在请求之前工作，常用来修改请求的设置

  • 定时器：负责定义请求之间的延迟间隔。

  • 取样器(Sampler)：是性能测试中向服务器发送请求，记录响应信息、响应时间的最小单元，如：HTTP Request Sampler、FTP Request Sample、TCP Request Sample、JDBC Request Sampler等，每一种不同类型的sampler 可以根据设置的参数向服务器发出不同类型的请求。

  • 后置处理器：负责在请求之后工作，常用获取返回的值。

  • 断言：用来判断请求响应的结果是否如用户所期望的。

  • 监听器：负责收集测试结果，同时确定结果显示的方式。

  • 逻辑控制器：可以自定义JMeter发送请求的行为逻辑，它与Sampler结合使用可以模拟复杂的请求序列。

• Jmeter元件的作用域和执行顺序

  • 元件作用域

    • 配置元件：影响其作用范围内的所有元件。

    • 前置处理器：在其作用范围内的每一个sampler元件之前执行。

    • 定时器：在其作用范围内的每一个sampler有效

    • 后置处理器：在其作用范围内的每一个sampler元件之后执行。

    • 断言：在其作用范围内的对每一个sampler元件执行后的结果进行校验。

    • 监听器：在其作用范围内对每一个sampler元件的信息收集并呈现。

      总结：从各个元件的层次结构判断每个元件的作用域。

  • 元件执行顺序

    配置元件->前置处理器->定时器->取样器->后置处理程序->断言->监听器

  • 注意事项：

    • 前置处理器、后置处理器和断言等组件只能对取样器起作用，因此，如果在它们的作用域内没有任何取样器，则不会被执行。
    • 如果在同一作用域内有多个同一类型的元件，则这些元件按照它们在测试计划中的上下顺序依次执行。

• 使用Jmeter进行接口测试的基本步骤如下：

  1.测试计划

  2.线程组

  3.HTTP Cookie管理器

  4.Http请求默认值

  5.Sampler(HTTP请求)

  6.断言

  7.监听器(查看结果树、图形结果、聚合报告等)

Jmeter进行接口测试流程步骤详解

• 测试计划

  打开Jmeter，在菜单左侧出现 “测试计划”。在这里测试计划我们可以把它理解成新建的空白项目，在这个空白项目下面可以添加一系列的接口。

  

• 线程组

  • 添加方法：右键点击测试计划->添加->线程(用户)->线程组。

  • 元件描述：一个线程组可以看做一个虚拟用户组，线程组中的每个线程都可以理解为一个虚拟用户。

    

    线程数：即虚拟用户数。设置多少个线程数也就是设置多少虚拟用户数

    Ramp-Up时间(秒)：设置虚拟用户数全部启动的时长。如果线程数为20,准备时长为10秒,那么需要10秒钟启动20个线程。也就是平均每秒启动2个线程。

    循环次数：每个线程发送请求的个数。如果线程数为20,循环次数为10,那么每个线程发送10次请求。总请求数为20*10=200。如果勾选了“永远”, 那么所有线程会一直发送请求,直到手动点击工具栏上的停止按钮,或者设置的线程时间结束。

• HTTP Cookie管理器

  添加方法：右键线程组->添加->配置元件->HTTP Cookie管理器。

  元件描述：HTTP Cookie管理器可以像浏览器一样存储和发送cookie，如果你要发送一个带cookie的http请求，cookie manager会自动存储该请求的cookies，并且后面如果发送同源站点的http请求时，都可以用这个cookies。

  

• HTTP请求默认值

  添加方法：右键线程组->添加->配置元件->HTTP请求默认值。

  元件描述：HTTP请求默认值是为了方便填写后续内容而设置。主要填写[服务器名称或IP]和[端口号]，后续的HTTP请求中就不用每次都填写IP地址和端口号了。

  

• HTTP请求

  添加方法：右键线程组->添加->Sampler->HTTP请求。

  元件描述：HTTP请求包括接口请求方法、请求路径和请求参数等。

  

  (1)名称：本属性用于标识一个取样器，建议使用一个有意义的名称。

  (2)注释：对于测试没有任何作用，仅用户记录用户可读的注释信息。

  (3)服务器名称或IP ：HTTP请求发送的目标服务器名称或IP地址。

  (4)端口号：目标服务器的端口号，默认值为80 。

  (5)协议：向目标服务器发送HTTP请求时的协议，可以是HTTP或者是HTTPS ，默认值为http 。

  (6)方法：发送HTTP请求的方法，可用方法包括GET、POST、HEAD、PUT、TRACE、OPTIONS、DELETE等。

  (7)路径：目标URL路径（不包括服务器地址和端口）

  (8)内容编码：内容的编码方式，默认值为iso8859

  (9)自动重定向：如果选中该选项，当发送HTTP请求后得到的响应是302/301时，JMeter 自动重定向到新的页面。

  (10)使用keep Alive ：保持jmeter 和目标服务器之间的活跃状态，默认选中

  (11)对Post使用multipart/from-data：当发送POST 请求时，使用multipart/from-data方法发送，默认不选中。

  (12)同请求一起发送参数 ： 在请求中发送URL参数，对于带参数的URL ，jmeter提供了一个简单的对参数化的方法。用户可以将URL中所有参数设置在本表中，表中的每一行是一个参数值对（对应RUL中的 名称1=值1）。

• 响应断言

  添加方法：右键HTTP请求->添加->取样器->HTTP请求。

  元件描述：检查接口是否访问成功。如果检查失败的话会提示找不到断言的内容，没提示的话就代表成功了。

  

• 增加监听器

  添加方法：线程组 ->右键添加 ->监听器 ->察看结果树。一般还会一并添加图形结果、聚合报告。

  元件描述：树状形式显示接口的访问结果，包括请求结果、请求内容、服务器的响应内容。

  

实验过程

• 均匀加载负载，模拟50个用户，Ramp-up Period（in seconds）为5秒，循环10次

• 均匀加载负载，模拟100个用户，Ramp-up Period（in seconds）为1秒，循环10次。进行测试

  

  

  

• 更换不同负载和模式：模拟1000个用户，Ramp-up Period（in seconds）为0秒，循环10次。进行测试

  

  

实验六 Appsan性能测试

原文链接：http://t.csdn.cn/35c0l

• 打开AppScan扫描工具

  

• 点击【创建新的扫描】，选择【常规扫描】，会显示【扫描配置向导】弹框

  

  

• 点击【完全扫描配置】到扫描配置页面，AppScan支持web service项目的安全检测，但是需要先按照GSC

  

• 扫描配置-URL和服务器：起始URL输入我们要扫描网站的地址，如果网站还包含其他域名，则在其他服务器和域进行添加

  

  

• 扫描配置-登录管理：扫描的网站不需要登录则登录方法选择无即可；

  

  若需要登录，则点击【记录】，默认使用appscan浏览器打开网站，输入账号密码登录成功后，登录序列就会被记录。

  

  

  

  登录且记录成功后，点击 标签 ”详细信息“ 可以查看到对于的操作和请求

  

• 扫描配置-环境定义：如果知道系统使用的环境可以自己定义，不知道则使用默认

  

• 扫描配置-排除路径和文件：对一些不需要的网址、图片、文件或者会影响扫描的网址做一个过滤操作。（可能会提高扫描速度和效率）

  

• 扫描配置-探索选项（冗余路径和深度路径可以进行适当的设置，其他选项可选择进行设置或者全部使用默认）

  

• 扫描配置-参数和cookie、自动表单填充、错误页面、多操作步骤、基于内容的结果：可使用默认配置（如有需要可进行配置）

  

• 扫描配置-Glass box：对系统安全性要求比较高可以进行配置（配置后扫描更准确，可能扫描出来的安全性问题较多）

  

• 扫描配置-通信和代理：可以配置线程数

  

• 扫描配置-测试策略和测试选项：可根据具体需要进行配置，不清楚直接选择缺省值即可。

  

• 扫描配置-其他选项：可根据需要进行配置，或者直接默认即可。以上选项设置完成后可保存为模板，下次可直接使用。

  

• 配置完成后，返回到配置向导主页，一直点击【下一步】到完成配置向导，即可进入扫描。

  

  

  

• 扫描结果分析：报告和扫描日志

  

  

• 查看扫描结果