软件测试总结

怼烎@ 2022-07-21 01:29 298阅读 0赞

之前实习做过一段时间测试，现做个总结；

实习测试的是一款CM系统（case 系统），来记录IT部门处理的维修，服务，反馈，预定服务等case；b/s架构，人少小项目，实习时间短，去了已经快完工，主要测试VPN登陆，提交邮件反馈，系统内存分析有无内存泄露等；（eclipse MAT插件）

白盒黑盒都做；

白盒利用：逻辑覆盖法和基本路径法进行设计，给定的人测试逻辑，代码测试各个模块功能，

黑盒主要验证其功能；实现能不能打通；case优先级，备注乱码，邮件自动查找，case跟踪等

1.        接受测试任务，进行需求分析；

2.        按照测试计划搭建测试环境，并保证测试环境的可靠性；

3.        按照测试计划编写测试用例，保证测试用例合理有效；

4.        按照测试用例执行测试，及时发现缺陷，并使用工具进行管理缺陷；

5.        编写和提交测试报告，保证测试进度按计划完成；

6.        参与审核其他测试工程师的测试用例和报告；

7.        学习和推广使用新的测试技术和工具；

8.        负责组织搭建，管理和维护部门的测试环境（测试环境管理和维护方向适用）；

9.        参与自动化测试框架设计，各产品自动化测试的设计、实现与维护（自动化测试方向适用）；

10.    负责组织对产品进行压力测试（压力测试方向适用）；

11.    搭建与维护部门的配置管理环境，制定配置管理工具并指导部门成员使用；进行配置管理流程规范和配置管理工具的宣贯、引导和培训（配置管理方向适用）。

junit测试 from http://blog.csdn.net/wangpeng047/article/details/9631193

1.自动生成测试用例

几乎所有程序员都听说过Junit的大名，但不知真正懂得运用它的人有多少，我便是其中的一个小白。

知道Junit是用来测试的，但却把“宝刀”当成了“菜刀”用。为了从此不再菜鸟，特此总结整理了下Junit的知识点。

**一、建立Junit测试类**

1. 右击test测试包，选择New-->Oher...

![Center][]

2. 在窗口中找到Junit，选择Junit Test Case

![Center 1][]

3. 输入名称(Name)，命名规则一般建议采用：类名+Test。Browse...选择要测试的类，这里是StudentService。

![Center 2][]

4. 勾选要测试的方法

![Center 3][]

5. 生成后，效果如下：

![Center 4][]

这里import static是引入Assert类中静态属性或静态方法的写法。原来要Assert.fail()，现在只需直接fial()即可，即省略了Assert。

其实不通过Junit新建向导来建立也可以，随便建立一个新类后，只需在方法上加入@Test注解即可。

**二主要方法：**

**二、核心——断言**

断言是编写测试用例的核心实现方式，即期望值是多少，测试的结果是多少，以此来判断测试是否通过。

1. 断言核心方法

<table style="color:rgb(0,0,0); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td>assertArrayEquals(expecteds, actuals)</td> 
   <td>查看两个数组是否相等。</td> 
  </tr> 
  <tr> 
   <td>assertEquals(expected, actual)</td> 
   <td>查看两个对象是否相等。类似于字符串比较使用的equals()方法</td> 
  </tr> 
  <tr> 
   <td>assertNotEquals(first, second)</td> 
   <td>查看两个对象是否不相等。</td> 
  </tr> 
  <tr> 
   <td>assertNull(object)</td> 
   <td>查看对象是否为空。</td> 
  </tr> 
  <tr> 
   <td>assertNotNull(object)</td> 
   <td>查看对象是否不为空。</td> 
  </tr> 
  <tr> 
   <td>assertSame(expected, actual)</td> 
   <td>查看两个对象的引用是否相等。类似于使用“==”比较两个对象</td> 
  </tr> 
  <tr> 
   <td>assertNotSame(unexpected, actual)</td> 
   <td>查看两个对象的引用是否不相等。类似于使用“!=”比较两个对象</td> 
  </tr> 
  <tr> 
   <td>assertTrue(condition)</td> 
   <td>查看运行结果是否为true。</td> 
  </tr> 
  <tr> 
   <td>assertFalse(condition)</td> 
   <td>查看运行结果是否为false。</td> 
  </tr> 
  <tr> 
   <td>assertThat(actual, matcher)</td> 
   <td>查看实际值是否满足指定的条件</td> 
  </tr> 
  <tr> 
   <td>fail()</td> 
   <td>让测试失败</td> 
  </tr> 
 </tbody> 
</table>

2. 示例

import static org.hamcrest.CoreMatchers.*;
    import static org.junit.Assert.*;
    
    import java.util.Arrays;
    
    import org.hamcrest.core.CombinableMatcher;
    import org.junit.Test;
    
    public class T2 {
    
    	  @Test
    	  public void testAssertArrayEquals() {
    	    byte[] expected = "trial".getBytes();
    	    byte[] actual = "trial".getBytes();
    	    org.junit.Assert.assertArrayEquals("failure - byte arrays not same", expected, actual);
    	  }
    
    	  @Test
    	  public void testAssertEquals() {
    	    org.junit.Assert.assertEquals("failure - strings not same", 5l, 5l);
    	  }
    
    	  @Test
    	  public void testAssertFalse() {
    	    org.junit.Assert.assertFalse("failure - should be false", false);
    	  }
    
    	  @Test
    	  public void testAssertNotNull() {
    	    org.junit.Assert.assertNotNull("should not be null", new Object());
    	  }
    
    	  @Test
    	  public void testAssertNotSame() {
    	    org.junit.Assert.assertNotSame("should not be same Object", new Object(), new Object());
    	  }
    
    	  @Test
    	  public void testAssertNull() {
    	    org.junit.Assert.assertNull("should be null", null);
    	  }
    
    	  @Test
    	  public void testAssertSame() {
    	    Integer aNumber = Integer.valueOf(768);
    	    org.junit.Assert.assertSame("should be same", aNumber, aNumber);
    	  }
    
    	  // JUnit Matchers assertThat
    	  @Test
    	  public void testAssertThatBothContainsString() {
    	    org.junit.Assert.assertThat("albumen", both(containsString("a")).and(containsString("b")));
    	  }
    
    	  @Test
    	  public void testAssertThathasItemsContainsString() {
    	    org.junit.Assert.assertThat(Arrays.asList("one", "two", "three"), hasItems("one", "three"));
    	  }
    
    	  @Test
    	  public void testAssertThatEveryItemContainsString() {
    	    org.junit.Assert.assertThat(Arrays.asList(new String[] { "fun", "ban", "net" }), everyItem(containsString("n")));
    	  }
    
    	  // Core Hamcrest Matchers with assertThat
    	  @Test
    	  public void testAssertThatHamcrestCoreMatchers() {
    	    assertThat("good", allOf(equalTo("good"), startsWith("good")));
    	    assertThat("good", not(allOf(equalTo("bad"), equalTo("good"))));
    	    assertThat("good", anyOf(equalTo("bad"), equalTo("good")));
    	    assertThat(7, not(CombinableMatcher.<Integer> either(equalTo(3)).or(equalTo(4))));
    	    assertThat(new Object(), not(sameInstance(new Object())));
    	  }
    }

**三、核心——注解**

1. 说明

<table style="color:rgb(0,0,0); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
  <tr> 
   <td>@Before</td> 
   <td>初始化方法</td> 
  </tr> 
  <tr> 
   <td>@After</td> 
   <td>释放资源</td> 
  </tr> 
  <tr> 
   <td>@Test</td> 
   <td>测试方法，在这里可以测试期望异常和超时时间</td> 
  </tr> 
  <tr> 
   <td>@Ignore</td> 
   <td>忽略的测试方法</td> 
  </tr> 
  <tr> 
   <td>@BeforeClass</td> 
   <td>针对所有测试，只执行一次，且必须为static void</td> 
  </tr> 
  <tr> 
   <td>@AfterClass</td> 
   <td>针对所有测试，只执行一次，且必须为static void</td> 
  </tr> 
  <tr> 
   <td>@RunWith</td> 
   <td>指定测试类使用某个运行器</td> 
  </tr> 
  <tr> 
   <td>@Parameters</td> 
   <td>指定测试类的测试数据集合</td> 
  </tr> 
  <tr> 
   <td>@Rule</td> 
   <td>允许灵活添加或重新定义测试类中的每个测试方法的行为</td> 
  </tr> 
  <tr> 
   <td>@FixMethodOrder</td> 
   <td>指定测试方法的执行顺序</td> 
  </tr> 
 </tbody> 
</table>

2. 执行顺序

一个测试类单元测试的执行顺序为：

@BeforeClass –> @Before –> @Test –> @After –> @AfterClass

每一个测试方法的调用顺序为：

@Before –> @Test –> @After

3. 示例

import static org.junit.Assert.*;
    
    import org.junit.*;
    
    public class T3 {
    
    	@BeforeClass
    	public static void setUpBeforeClass() throws Exception {
    		System.out.println("in BeforeClass================");
    	}
    
    	@AfterClass
    	public static void tearDownAfterClass1() throws Exception {
    		System.out.println("in AfterClass=================");
    	}
    
    	@Before
    	public void before1() {
    		System.out.println("in Before");
    	}
    
    	@After
    	public void after() {
    		System.out.println("in After");
    	}
    
    	@Test(timeout = 10000)//time 
    	public void testadd() {
    		JDemo a = new JDemo();
    		assertEquals(6, a.add(3, 3));
    		System.out.println("in Test ----Add");
    	}
    
    	@Test
    	public void testdivision() {
    		JDemo a = new JDemo();
    		assertEquals(1, a.division(6, 2));//和设置不同抛出失败
    		System.out.println("in Test ----Division");
    	}
    
    	@Ignore
    	@Test
    	public void test_ignore() {
    		JDemo a = new JDemo();
    		assertEquals(6, a.add(1, 5));
    		System.out.println("in test_ignore");
    	}
    
    	@Test
    	public void teest_fail() {
    		fail();//输出fail
    	}
    }
    
    class JDemo extends Thread {
    
    	int result;
    
    	public int add(int a, int b) {
    		try {
    			sleep(1000);
    			result = a + b;
    		} catch (InterruptedException e) {
    		}
    		return result;
    	}
    
    	public int division(int a, int b) {
    		return result = a / b;
    	}
    }

![Center 5][]

in BeforeClass================  
in Before  
in Test ----Add  
in After  
in Before  
in After  
in Before  
in After  
in AfterClass=================

四、实例总结

1. 参数化测试

有时一个测试方法，不同的参数值会产生不同的结果，那么我们为了测试全面，会把多个参数值都写出来并一一断言测试，这样有时难免费时费力，这是我们便可以采用参数化测试来解决这个问题。参数化测试就好比把一个“输入值，期望值”的集合传入给测试方法，达到一次性测试的目的。