实验二-160-曾元鹏

最新推荐文章于 2022-12-17 23:56:13 发布

转载最新推荐文章于 2022-12-17 23:56:13 发布 · 129 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/ypzeng/p/6706300.html

文章标签：

#测试

本文介绍了一个用于测试三角形分类的程序及其多种白盒测试技术的应用，包括语句覆盖、判定覆盖、条件覆盖、路径覆盖等，并给出了具体的测试用例及JUnit测试脚本。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

被测代码链接：http://www.cnblogs.com/WuYeqian/p/6618858.html

一、实验目的

掌握覆盖测试的基本方法和实践

二、实验要求

运用逻辑覆盖测试的覆盖准则设计被测程序的测试用例，并运行测试用例检查程序的正确与否，给出程序缺陷小结。

三、实验内容

（1）设计某程序的路径覆盖测试用例，如路径覆盖、条件覆盖、分支覆盖、循环覆盖等

伪代码程序如下：

9 public static String triangle(int a,int b,int c){

10 if(a<1 || a>100 ||b<1 || b>100|| c<1|| c>100){

11 return t1;

12 }

13 else if(a>=b+c ||b>=a+c||c>=a+b){

14 return t2;

15 }

16 else if(a==b &&b==c &&c==a){

17 return t3;

18 }

19 else if(a==b ||b==c ||c==a){

20 return t4;

21 }

22 else if(a*a+b*b==c*c ||b*b+c*c==a*a ||c*c+a*a==b*b){

23 return t5;

24 }

25 else {

26 return t6;

27 }

28 }

DD-路径（只压缩链路经）

程序图节点	DD-路径
9	A
10	B
11.12.13	C
14	D
15.16.17	E
18	F
19.20	G
21	H
22.23	I
24	J
25.26	K
27.28.29	L
30	M

（I）语句覆盖：

A-B-D-F-H-J-L-M 和A-B-D-F-H-J-K-M

A-B-D-F-H-I-M 和 A-B-D-F-G-M

A-B-D-E-M 和 A-B-C-M

测试用例：

用例ID	输入值			执行路径	预期输出	实际输出
用例ID	a	b	c	执行路径	X	Y
1	5	7	8	A-B-D-F-H-J-L-M	一般三角形	一般三角形
2	3	5	4	A-B-D-F-H-J-K-M	直角三角形	直角三角形
3	5	6	6	A-B-D-F-H-I-M	等腰三角形	等腰三角形
4	30	30	30	A-B-D-F-G-M	等边三角形	等边三角形
5	5	5	15	A-B-D-E-M	不构成三角形	不构成三角形
6	120	55	30	A-B-C-M	边值不在范围	边值不在范围

（II）分支覆盖（判断覆盖）：

A-B-C-M（1.左）

A-B-D-E-M（1.右，2.左）

A-B-D-E-G-M（1.右，2.右，3左）

A-B-D-F-H-I-M（1.右，2.右，3右，4左）

A-B-D-F-H-J-K-M（1.右，2.右，3右，4右，5左）

A-B-D-F-H-J-L-M（1.右，2.右，3右，4右，5右）

测试用例：

用例ID	输入值			执行路径	预期输出	实际输出
用例ID	A	B	C	执行路径	X	Y
1	20	30	110	A-B-C-M	边值不在范围	边值不在范围
2	10	22	10	A-B-D-E-M	不构成三角形	不构成三角形
3	70	70	70	A-B-D-E-G-M	等边三角形	等边三角形
4	30	50	30	A-B-D-F-H-I-M	等腰三角形	等腰三角形
5	5	12	13	A-B-D-F-H-J-K-M	直角三角形	直角三角形
6	50	60	55	A-B-D-F-H-J-L-M	一般三角形	一般三角形

（III）路径覆盖：

A-B-C-M（1.左）

A-B-D-E-M（1.右，2.左）

A-B-D-E-G-M（1.右，2.右，3左）

A-B-D-F-H-I-M（1.右，2.右，3右，4左）

A-B-D-F-H-J-K-M（1.右，2.右，3右，4右，5左）

A-B-D-F-H-J-L-M（1.右，2.右，3右，4右，5右）

测试用例：

用例ID	输入值			执行路径	预期输出	实际输出
用例ID	A	B	C	执行路径	X	Y
1	22	33	130	A-B-C-M	边值不在范围	边值不在范围
2	30	22	60	A-B-D-E-M	不构成三角形	不构成三角形
3	5	5	5	A-B-D-E-G-M	等边三角形	等边三角形
4	25	40	25	A-B-D-F-H-I-M	等腰三角形	等腰三角形
5	12	5	13	A-B-D-F-H-J-K-M	直角三角形	直角三角形
6	6	3	5	A-B-D-F-H-J-L-M	一般三角形	一般三角形

（IV）条件覆盖：各个条件取真或假的可能至少执行一次（(F/T表示真假都一样)）

第一个条件：

编号	a<1	a>100	b<1	b>100	c<1	c>100	覆盖路径
1	T	F/T	F/T	F/T	F/T	F/T	A-B-C-M
2	F/T	T	F/T	F/T	F/T	F/T	A-B-C-M
3	F/T	F/T	T	F/T	F/T	F/T	A-B-C-M
4	F/T	F/T	F/T	T	F/T	F/T	A-B-C-M
5	F/T	F/T	F/T	F/T	T	F/T	A-B-C-M
6	F/T	F/T	F/T	F/T	F/T	T	A-B-C-M
7	F	F	F	F	F	F	A-B-D

第二个条件：

编号	a>=b+c	b>=a+c	c>=a+b	覆盖路径
1	T	F/T	F/T	A-B-D-E-M
2	F/T	T	F/T	A-B-D-E-M
3	F/T	F/T	T	A-B-D-E-M
4	F	F	F	A-B-D-F

第三个条件：

编号	a==b	b==c	c==a	覆盖路径
1	T	T	T	A-B-D-F-G-M
2	F	T/F	F/T	A-B-D-F-H
3	F/T	F	F/T	A-B-D-E-M
4	F/T	F/T	F	A-B-D-F

第四个条件：

编号	a==b	b==c	c==a	覆盖路径
1	T	T/F	F	A-B-D-F-H-I-M
2	T	F	F/T	A-B-D-F-H-I-M
3	F/T	T	F	A-B-D-F-H-I-M
4	F	T	F/T	A-B-D-F-H-I-M
	F/T	F	T	A-B-D-F-H-I-M
	F	F/T	T	A-B-D-F-H-I-M
	F	F	F	A-B-D-F-H-J

第五个条件：

编号	aa+bb==c*c	bb+cc==a*a	cc+aa==b*b	覆盖路径
1	T	F/T	F/T	A-B-D-F-H-J-K-M
2	F/T	T	F/T	A-B-D-F-H-J-K-M
3	F/T	F/T	T	A-B-D-F-H-J-K-M
4	F	F	F	A-B-D-F-H-J-L-M

测试用例：

用例ID	输入值			执行路径	预期输出	实际输出
用例ID	A	B	C	执行路径	X	Y
1	22	33	130	A-B-C-M	边值不在范围	边值不在范围
2	30	22	60	A-B-D-E-M	不构成三角形	不构成三角形
3	5	5	5	A-B-D-F-G-M	等边三角形	等边三角形
4	25	40	25	A-B-D-F-H-I-M	等腰三角形	等腰三角形
5	12	5	13	A-B-D-F-H-J-K-M	直角三角形	直角三角形
6	6	3	5	A-B-D-F-H-J-L-M	一般三角形	一般三角形

（2）根据各位同学自己的被测程序，分别作出各类白盒测试技术的用例设计和相应的Junit脚本。

所有的覆盖的技术：语句覆盖、判定覆盖、条件覆盖、判定/条件覆盖、组合覆盖、路径覆盖，基本路径测试方法

1) 被测原代码

public class Client {

	public static void main(String[] args) throws Exception {
		new Menu();
	}

}

public class IsInteger {
	public static boolean IsNum(String str)
	       {
	        if(str==null)
	         {
	           return false;
	         }
	        else{
	            try{
	             @SuppressWarnings("unused")
	             int num=Integer.valueOf(str);//把字符串强制转换为数字 
	             return true;//是数字,返回true
	             }catch (Exception e) {
	              return false;
	             }
	         }
	     }
}

public class Menu {
	private static Scanner in = new Scanner(System.in);
	     public Menu() throws Exception
	     {
	          while(true){
	              this.show();
	         }
	     }
	     @SuppressWarnings("resource")
	     public void show() throws Exception{
	         
	         System.out.println("======三角形种类=====");
	         System.out.println("[1] 进行三角形类型判断");
	         System.out.println("[e] 退出。");
	         while (in.hasNext()) {
	        String i = in.nextLine();
	         switch(i){
	             case "1":{
	                 int i_a,i_b,i_c;
	                 System.out.println("请输入三角形的三条边：");        
	                 do {
	                     Scanner scana=new Scanner(System.in);             
	                     String a=scana.next();
	                     Scanner scanb=new Scanner(System.in); 
	                     String b=scanb.next();                
	                     Scanner scanc=new Scanner(System.in);
	                     String c=scanc.next();
	                     if(IsInteger.IsNum(a)&&IsInteger.IsNum(b)&&IsInteger.IsNum(c))
	                    {
	                         i_a = Integer.parseInt(a);
	                          i_b = Integer.parseInt(b);
	                         i_c = Integer.parseInt(c);
	                          System.out.println(Sort.triangle(i_a, i_b, i_c));
	                          break;
	                     }
	                     else{
	                        System.out.println("输入不是整数！请重请输入三角形的三条边：");
	                    }
	                 } while (true);    
	                 System.out.println("==========请继续选择===========");
	                 System.out.println("[1] 进行三角形类型判断");
	                 System.out.println("[e] 退出。");    
	                 break ;
	         }    
	             case "e":{
	                 System.exit(1) ;        // 系统退出
	                 break ;
	            }
	             default:{
	                 System.out.println("请选择正确的操作！") ;
	             }
	         }
	     }
	     }
}

public class Sort {
	
	static String t1="边的值不在范围内";
	static String t2="不构成三角形";
	static String t3="等边三角形";
	static String t4="等腰三角形";
	static String t5="直角三角形";
	static String t6="一般三角形";
	public static String triangle(int a,int b,int c){    
	if(a<1 || a>100 ||b<1 || b>100|| c<1|| c>100)
	         {
	             return t1;
	         }
	         else if(a>=b+c ||b>=a+c||c>=a+b)
	         {
	             return t2;
	         }
	         else if(a==b &&b==c &&c==a){
	             return t3;
	         }
	         else if(a==b ||b==c ||c==a){
	             return t4;
	         }
	         else if(a*a+b*b==c*c ||b*b+c*c==a*a ||c*c+a*a==b*b){
	             return t5;
	         }
	         else {
	             return t6;
	         }
	     }
}

2）依据覆盖技术的测试用例：

public class test01 {

	@Before
	public void setUp() throws Exception {
	}

	@Test
	public void testTriangle() {
		assertEquals("一般三角形", otherTest.Sort.triangle(20, 30, 15));
		assertEquals("直角三角形", otherTest.Sort.triangle(3, 4, 5));
		assertEquals("等边三角形", otherTest.Sort.triangle(20, 20, 20));
		assertEquals("等腰三角形", otherTest.Sort.triangle(30, 30, 15));
		assertEquals("边的值不在范围内", otherTest.Sort.triangle(120, 30, 15));
		assertEquals("不构成三角形", otherTest.Sort.triangle(50, 20, 10));
	}
	
	// 语句覆盖
	@Test
	      public void statementTest() {
	          assertEquals("边的值不在范围内", otherTest.Sort.triangle(120, 30, 15));
	          assertEquals("不构成三角形", otherTest.Sort.triangle(10, 20, 10));
	          assertEquals("等边三角形", otherTest.Sort.triangle(3, 3, 3));
	          assertEquals("等腰三角形", otherTest.Sort.triangle(5, 5, 7));
	          assertEquals("直角三角形", otherTest.Sort.triangle(3, 4, 5));
	          assertEquals("一般三角形", otherTest.Sort.triangle(60, 50, 55));
	      }
	// 判定覆盖
	@Test
	public void judgeTest1() {
	  
		assertEquals("边的值不在范围内", otherTest.Sort.triangle(120, 30, 15));
	}
	@Test
    public void judgeTest2() {

		 assertEquals("不构成三角形", otherTest.Sort.triangle(10, 20, 10));
    }
	@Test
    public void judgeTest3() {

		assertEquals("等边三角形", otherTest.Sort.triangle(3, 3, 3));
    }
	@Test
    public void judgeTest4() {

		assertEquals("等腰三角形", otherTest.Sort.triangle(5, 5, 7));
    }
	@Test
    public void judgeTest5() {

		assertEquals("直角三角形", otherTest.Sort.triangle(3, 4, 5));
    }
	@Test
    public void judgeTest6() {

		 assertEquals("一般三角形", otherTest.Sort.triangle(60, 50, 55));
    }
	//条件覆盖
	 @Test
	 public void conditionTest1() {
	     assertEquals("边的值不在范围内",otherTest.Sort.triangle(101, 50, 55));
	 }
	 @Test
	 public void conditionTest2() {
		 assertEquals("不构成三角形", otherTest.Sort.triangle(20, 30, 80));
	 }
	 @Test
	 public void conditionTest3() {
	     assertEquals("等边三角形",otherTest.Sort.triangle(55, 55, 55));
	 }
	 @Test
	 public void conditionTest4() {
	     assertEquals("等腰三角形",otherTest.Sort.triangle(55, 50, 55));
	 }
	 @Test
	 public void conditionTest5() {
	     assertEquals("直角三角形",otherTest.Sort.triangle(6, 10,8));
	 }
	 @Test
	 public void conditionTest6() {
	     assertEquals("一般三角形",otherTest.Sort.triangle(20,10, 15));
	 }
	 public void conditionTest7() {
	     assertEquals("边的值不在范围内",otherTest.Sort.triangle(10, 120, 55));
	 }
	 public void conditionTest8() {
	     assertEquals("边的值不在范围内",otherTest.Sort.triangle(10, 50, 130));
	 }
	 public void conditionTest9() {
	     assertEquals("等腰三角形",otherTest.Sort.triangle(11, 11,10));
	 }
	 //路径覆盖
	 @Test
	 public void pathTest1() {
	     assertEquals("边的值不在范围内",otherTest.Sort.triangle(0, 0, 150));
	 }
	 @Test
	 public void pathTest2() {
		 assertEquals("不构成三角形", otherTest.Sort.triangle(20, 30, 80));
	 }
	 @Test
	 public void pathTest3() {
		 assertEquals("等边三角形",otherTest.Sort.triangle(55, 55, 55));
	 }
	 @Test
	 public void pathTest4() {
		 assertEquals("等腰三角形",otherTest.Sort.triangle(55, 50, 55));
	 }
	 @Test
	 public void pathTest5() {
		 assertEquals("直角三角形",otherTest.Sort.triangle(6, 10,8));
	 }
	 @Test
	 public void pathTest6() {
		 assertEquals("一般三角形",otherTest.Sort.triangle(20,10, 15));
	 }
}

4) 测试小结：

第一部分：需对代码的划分结构进行修改，使得作图更为方便，同时也可使解题的思路更为清晰。对测试用例的选择有着很多的，还需进一步进行规划，找出具有代表性的用例进行测试。

第二部分，在测试中未找到出错的缺陷，在选取用例时希望能更具代表性。

转载于:https://www.cnblogs.com/ypzeng/p/6706300.html