实验二-160-曾元鹏

被测代码链接：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	输入值			执行路径	预期输出	实际输出
	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	输入值			执行路径	预期输出	实际输出
	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	输入值			执行路径	预期输出	实际输出
	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

 

第五个条件：

编号	a*a+b*b==c*c	b*b+c*c==a*a	c*c+a*a==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	输入值			执行路径	预期输出	实际输出
	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) 测试小结：

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

 

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