实验二+043+杨晨宇

最新推荐文章于 2023-10-27 00:36:31 发布

转载最新推荐文章于 2023-10-27 00:36:31 发布 · 132 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/1033YCY/p/6706887.html

一、实验目的

掌握基于覆盖理论与基本路径的基本白盒测试方法和实践

二、实验要求

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

三、实验内容

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

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

包括的内容有：

1) 被测原代码

被测源码：http://www.cnblogs.com/zenghongyu/p/6626206.html

2）依据覆盖技术，测试用例列表：

（I）：语句覆盖：

A-B-C-D

A-B-C-E-F

A-B-C-E-G-H

A-B-C-E-G-I

用例ID	输入值			执行路径	预期输出	实际输出	是否通过
用例ID	A	B	X	执行路径
1	-1	-1	-1	A-B-C-D	-1	-1	-1
2	5	5	5	A-B-C-E-F	49.0	49.0	是
3	10	20	50	A-B-C-E-G-H	160.0	160.0	是
4	20	100	100	A-B-C-E-G-I	540.0	540.0	是

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

A-B-C-D

A-B-C-E-F

A-B-C-E-G-H

A-B-C-E-G-I

A-B-D

用例ID	输入值			执行路径	预期输出	实际输出	是否通过
用例ID	A	B	X	执行路径
1	-1	-1	-1	A-B-C-D	-1	-1	-1
2	1	1	1	A-B-C-E-F	9.8	9.8	是
3	10	10	100	A-B-C-E-G-H	205.0	205.0	是
4	30	20	50	A-B-C-E-G-I	460.0	460.0	是
5	a	10	20	A-B-D	-1	-1	是
6	5.00	5.00	5.00	A-B-C-E-F	49.0	-1	否

III）路径覆盖：

A-B-C-D

A-B-C-E-F

A-B-C-E-G-H

A-B-C-E-G-

A-B-D

因路径与判定覆盖相同，故使用判定覆盖测试用例

（IV）条件覆盖：各个条件取真或假的可能至少执行一次

编号	Hp为整	Shell为整	Protecter为整	输入是否为整形	路径
1	F	F	F	F	B-D
2	F	F	T	F	B-D
3	F	T	F	F	B-D
4	T	F	F	F	B-D
5	T	T	F	F	B-D
6	T	F	T	F	B-D
7	F	T	T	F	B-D
8	T	T	T	T	B-C

编号	Ht_int<0	Shell_int<0	Protecter_int<0	`hp_int<0\|\|shell_int<0\|\|protector_int<0`	路径
1	F	F	F	F	C-E
2	T	F	F	T	C-D
3	F	T	F	T	C-D
4	F	F	T	T	C-D
5	F	T	T	T	C-D
6	T	F	T	T	C-D
7	T	T	F	T	C-D
8	T	T	T	T	C-D

编号	Result<1000	覆盖路径
1	T	E-F
2	F	E-G

编号	Result>=1000	Result<=1800	Result>=1000 &&Result<=1800	覆盖路径
1	T	F	F	G-I
2	T	T	T	G-H

用例ID	输入值			执行路径	预期输出	实际输出	是否通过
用例ID	A	B	X	执行路径
1	-1	-1	-1	A-B-C-D	-1	-1	是
2	5	5	5	A-B-C-E-F	49.0	49.0	是
3	10	20	50	A-B-C-E-G-H	160.0	160.0	是
4	20	100	100	A-B-C-E-G-I	540.0	540.0	是
5	a	10.0	20	A-B-D	-1	-1	是
6	5.00	5.00	5.00	A-B-C-E-F	49.0	-1	否

因为被测程序没有退出功能，以回到1作为终点

3）相应Junit测试脚本、执行结果

语句测试

package Java_1;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
public class PhoneSaleTestSentence {
 @Test
 public void testSentence1() {
  assertEquals("49.0", PhoneSale.commission("5", "5", "5"));
 }
 @Test
 public void testSentence2() {
  assertEquals("160.0", PhoneSale.commission("10", "20", "50"));
 }
 @Test
 public void testSentence3() {
  assertEquals("540.0", PhoneSale.commission("20", "100", "100"));
 }
 @Test
 public void testSentence4() {
  assertEquals("-1", PhoneSale.commission("-1", "-1", "-1"));
 }
}

语句测试通过

　　2、判定覆盖

package Java_1;
import static org.junit.Assert.assertEquals;
import org.junit.Before;
import org.junit.Test;
public class PhoneSaleTestJudge {
 @Before
 public void setUp() throws Exception {
 }
 @Test
 public void testJudeg1() {
  assertEquals("-1", PhoneSale.commission("-1", "-1", "-1"));
 }
 @Test
 public void testJudeg2() {
  assertEquals("9.8", PhoneSale.commission("1", "1", "1"));
 }
 @Test
 public void testJudeg3() {
  assertEquals("205.0", PhoneSale.commission("10", "10", "100"));
 }
 @Test
 public void testJudeg4() {
  assertEquals("460.0", PhoneSale.commission("30", "20", "50"));
 }
 @Test
 public void testJudeg5() {
  assertEquals("-1", PhoneSale.commission("a", "10", "20"));
 }
 @Test
 public void testJudeg6() {
  assertEquals("49.0", PhoneSale.commission("5.00", "5.00", "5.00"));
 }
}

　条件覆盖和条件/判定、基本路径选取测试用例相同如下

package Java_1;

import static org.junit.Assert.assertEquals;

import org.junit.Before;
import org.junit.Test;

public class PhoneSaleTestConditon {

	@Before
	public void setUp() throws Exception {
	}

	@Test
	public void testCondition1() {
		assertEquals("-1", PhoneSale.commission("-10", "-10", "-10"));
	}

	@Test
	public void testCondition2() {
		assertEquals("100.0", PhoneSale.commission("0", "100", "0"));
	}

	@Test
	public void testCondition3() {
		assertEquals("205.0", PhoneSale.commission("15", "50", "0"));
	}

	@Test
	public void testCondition4() {
		assertEquals("840.0", PhoneSale.commission("50", "50", "50"));
	}

}

条件测试用例通过

4，组合用例

package Java_1;

public class PhoneSaleTestGroup {
 @Before
 public void setUp() throws Exception {
 }
 @Test
 public void testgroup1() {
  assertEquals("-1", PhoneSale.commission("-10", "-10", "10"));
 }
 @Test
 public void testgroup2() {
  assertEquals("-1", PhoneSale.commission("-10", "10", "-10"));
 }
 @Test
 public void testgroup3() {
  assertEquals("-1", PhoneSale.commission("10", "-10", "-10"));
 }
 @Test
 public void testgroup4() {
  assertEquals("-1", PhoneSale.commission("-10", "10", "10"));
 }
 @Test
 public void testgroup5() {
  assertEquals("-1", PhoneSale.commission("10", "-10", "10"));
 }
 @Test
 public void testgroup6() {
  assertEquals("-1", PhoneSale.commission("10", "10", "-10"));
 }
 @Test
 public void testgroup7() {
  assertEquals("9.8", PhoneSale.commission("1", "1", "1"));
 }
 @Test
 public void testgroup8() {
  assertEquals("205.0", PhoneSale.commission("10", "10", "100"));
 }
 @Test
 public void testgroup9() {
  assertEquals("460.0", PhoneSale.commission("30", "20", "50"));
 }
}

组合覆盖测试用例通过

4）给出测试参数化和打包测试的脚本，并生成执行结果

测试参数化

package Java_1;

import static org.junit.Assert.assertEquals;

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;

@RunWith(Parameterized.class)
public class PhoneSaleTest1 {
	private String ph;
	private String sh;
	private String pr;
	private String result;

	@Parameters
	public static Collection<Object[]> data() {
		return Arrays.asList(new Object[][] { { "5", "5", "5", "49.0" }, { "10", "20", "50", "160.0" },
				{ "20", "100", "100", "540.0" }, { "10", "-10", "10", "-1" }, { "1", "1", "1", "9.8" },
				{ "10", "10", "100", "205.0" }, { "30", "20", "50", "460.0" }, { "-10", "-10", "-10", "-1" },
				{ "0", "100", "0", "100.0" }, { "15", "50", "0", "205.0" }, { "50", "50", "50", "840.0" },
				{ "10", "10", "-10", "-1" }, { "10", "-10", "10", "-1" }, { "-10", "10", "10", "-1" },
				{ "10", "-10", "-10", "-1" }, { "-10", "10", "-10", "-1" }, { "-10", "-10", "10", "-1" }, });
	}

	public PhoneSaleTest1(String ph, String sh, String pr, String result) {
		this.ph = ph;
		this.sh = sh;
		this.pr = pr;
		this.result = result;
	}

	@Test
	public void testCommission() {
		assertEquals(result, PhoneSale.commission(ph, sh, pr));
	}

}

打包测试的脚本，并生成执行结果

package Java_1;

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

@RunWith(Suite.class)
@SuiteClasses({ PhoneSaleTest1.class, PhoneSaleTestConditon.class, PhoneSaleTestGroup.class, PhoneSaleTestJudge.class,
		PhoneSaleTestSentence.class })
public class AllTests {

}

4、测试小结：

测试找到的缺陷清单
当输入浮点型整数时如（10.0 10.0 10.0）结果与预期结果不同。
对源代码的修改建议
2、建议把函数返回值设置浮点型，把参数设置为整型
测试总结与心得体会
通过本次测试把白盒测试的几种覆盖测试的定义和具体方法复习了一遍，包括语句覆盖、判定覆盖、条件覆盖、判定/条件覆盖、组合覆盖、路径覆盖，基本路径测试方法。同时学习了JUNIT4的几种基本方法，包括参数化测试和打包测试。

转载于:https://www.cnblogs.com/1033YCY/p/6706887.html