JavaSE（八）JUnit单元测试、正则表达式

JUnit单元测试

JUnit测试

单元测试

1）单元测试是针对最小的功能单元编写测试代码
2）Java程序最小的功能单元是方法
3）单元测试就是针对单个Java方法的测试

测试驱动开发TDD：Test-Driven Development

JUnit的设计：

1）TestCase：一个TestCase表示一个测试
2）TestSuite：一个TestSuite包含一组TestCase，表示一组测试
3）TestFixture：一个TestFixture表示一个测试环境
4）TestResult：用于收集测试结果
5）TestRunner：用于运行测试
6）TestListener：用于监听测试过程，收集测试数据
7）Assert：用于断言测试结果是否正确

版本	JUnit 3.x	JUnit 4.x	JUnit 5.x
JDK	<1.5	>=1.5	>=1.8
class	class MyTest extends TestCass{}	class MyTest{}	class MyTest{}
method	public testAbc(){}	@Test public abc(){}	@Test public abc(){}

使用Assert断言

1）assertEquals
2）assertArrayEquals
3）assertNull
4）assertTrue
5）assertFalse
6）assertNotEquals
7）assertNotNull

如何编写单元测试

1）一个TestCase包含一组相关的测试方法
2）每个测试方法必须完全独立
3）测试代码必须非常简单
4）不能为测试代码再编写测试
5）测试需要覆盖各种输入条件，特别是边界条件

JUnit使用

使用Before和After

Test Fixture：初始化测试资源称为Fixture
@Before和@After

1）在@Before方法中初始化测试资源
2）在@After方法中释放测试资源

@BeforeClass和@AfterClass静态方法

1）在执行所有@Test方法前执行@BeforeClass静态方法
2）在执行所有@Test方法后执行@AfterClass静态方法
静态字段的状态会影响到所有的@Test

理解JUnit执行测试的生命周期

invokeBeforeClass(CalculatorTest.class); // @BeforeClass
for(Method testMethod : findTestMethods(CalculatorTest.class)){
	CalculatorTest test = new CalculatorTest(); // new 
	test.setUp(); // @Before
	testMethod.invoke(test); // @Test
	test.tearDown(); // @After
}
invokeAfterClass(CalculatorTest.class); // @AfterClass

@Before：初始化测试对象，例如：input = new FileInputStream();
@After：销毁@Before创建的测试对象，例如：input.close();
@BeforeClass：初始化非常耗时的资源，例如：创建数据库
@AfterClass：清理@BeforeClass创建的资源，例如：删除数据库

异常测试

测试异常可以使用@Test(excepted=Exception.class)

1）如果抛出了指定类型的异常，测试成功
2）如果没有抛出指定类型的异常，或者抛出的异常类型不对，测试失败

对可能发生的每种类型的异常进行测试

参数化测试

Parameterized Test：参数化测试可以把测试数据统一管理
可以用测试数据对同一个测试方法反复测试

@RunWith(Parameterized.class)
public class AbsTest{
	@Parameters
	public static Collection<?> data(){
		return Arrays.asList(new Object[][]{
			{0, 0}, {1, 1}, {-1, 1}
		});
	}
	int input;
	int expected;
	public AbsTest(int input, int expected){
		this.input = input;
		this.expected = expected;
	}
	@Test
	public void testAbs(){
		int r = Math.abs(this.input);
		assertEquals(this.expected, r);
	}
}

超时测试

可以为JUnit的单个测试设置超时：

@Test(timeout=1000)
public void testTimeCost(){}

超时测试不能取代性能测试和压力测试

正则表达式

简介

正则表达式（Regular Expression）：一套规则，用来匹配字符串
使用正则表达式可以快速判断给定的字符串是否符合匹配规则
Java内建正则表达式引擎java.util.regex

// 判断年份是否是19xx年
//     /19\d\d/    或者   /19\d{2}/
// 在java中
System.out.println("1912".matches("19\\d\\d")); // true
System.out.println("1990".matches("19\\d{2}")); // true
// 编写方法和测试用例
public class Is1900s {
	public static boolean is19xx(String s){
		if(s == null){
			return false;
		}
//		return s.matches("19\\d\\d");
		return s.matches("19\\d{2}");
	}
}
public class Is1900sTest {
	@Test
	public void testIs19xx() {
		assertTrue(Is1900s.is19xx("1900"));
		assertTrue(Is1900s.is19xx("1901"));
		assertTrue(Is1900s.is19xx("1911"));
		assertTrue(Is1900s.is19xx("1932"));
		assertTrue(Is1900s.is19xx("1949"));
		assertTrue(Is1900s.is19xx("1998"));
		assertTrue(Is1900s.is19xx("1999"));
		
		assertFalse(Is1900s.is19xx(null));
		assertFalse(Is1900s.is19xx(""));
		assertFalse(Is1900s.is19xx(" "));
		assertFalse(Is1900s.is19xx("19"));
		assertFalse(Is1900s.is19xx("190A"));
		assertFalse(Is1900s.is19xx("19001"));
		assertFalse(Is1900s.is19xx("1900s"));
		assertFalse(Is1900s.is19xx("2900"));
		assertFalse(Is1900s.is19xx("A900"));
	}
}

匹配规则

从左向右进行匹配

1）精确匹配
2）\d：0-9
3）\D：非\d
4）\s：空格，Tab键
5）\S：非\s
6）\w：a-z、A-Z、0-9、_
7）\W：非\w
8）*：任意字符
9）+：1到多，至少一个字符
10）?：0个或1个字符
11）{n}：n个字符
12）{m, n}：大于等于m个，小于等于n个字符
13）{n, }：至少n个字符

练习

编写正则表达式判断用户输入QQ号是否合法（合法QQ号是5~10位数字）

// 先写出正则  /^[1-9]\d{4, 9}/
@Test
public void testIsQQ(){
	assertTrue(isQQ("12345"));
	assertTrue(isQQ("123456"));
	assertTrue(isQQ("5642145"));
	assertTrue(isQQ("42341551"));
	assertTrue(isQQ("897900564"));
	assertTrue(isQQ("8979005643"));
	
	assertFalse(isQQ(null));
	assertFalse(isQQ(""));
	assertFalse(isQQ(" "));
	assertFalse(isQQ("12"));
	assertFalse(isQQ("123"));
	assertFalse(isQQ("1234"));
	assertFalse(isQQ("12345678910"));
	assertFalse(isQQ("02345910"));
	assertFalse(isQQ("a278910"));
	assertFalse(isQQ(" 278910"));
	assertFalse(isQQ("_278910"));
}

public boolean isQQ(String s){
	//   /^[1-9]\d{4, 9}/
	if(s == null){
		return false;
	}
	return s.matches("^[1-9]\\d{4,9}$");// {4,9}中不能写空格例如{4, 9}
}

复杂匹配规则

1）^：字符串开头（区分[^]中的取反）
2）$：字符串结束
3）[ABC]：字符集（ABC）内任意字符
4）[^A-F]：A到F范围之外任意字符
5）|：或匹配，例如A|B意思是匹配A或者B字符

分组匹配规则

(…) 可以用来分组，例如“(\d{4})-(\d{1,2})-(\d{1,2})”
正则表达式分组可以通过Matcher对象快速提取子串

1）group(0)表示匹配的整个字符串
2）group(1)表示第一个子串
3）group(2)表示第二个子串
。。。以此类推

Pattern pattern = Pattern.compile("^(\\d{3,4})\\-(\\d{6,8})$");
Matcher matcher = pattern.matcher("010-12345678");
if(matcher.matches()){
	String whole = matcher.group(0); // 010-12345678
	String areaCode = matcher.group(1); // 010  第一个子串
	String telNumber = matcher.group(2); // 12345678  第二个子串
}

练习

编写正则，可以提取合法时间字符串的时、分、秒，或者当前字符串不合法是返回false

// 例如   18 : 43 : 56
// 正则表达式为： /^([0-1][0-9]|2[0-3]) \: ([0-5][0-9]) \: ([0-5][0-9])$/
@Test
public void testIsQQ(){
	assertTrue(isLegalTime("08 : 23 : 16"));
	assertTrue(isLegalTime("18 : 43 : 56"));
	assertTrue(isLegalTime("23 : 01 : 06"));
	
	assertFalse(isLegalTime(null));
	assertFalse(isLegalTime(""));
	assertFalse(isLegalTime(" "));
	assertFalse(isLegalTime("12 :"));
	assertFalse(isLegalTime("08 : 04"));
	assertFalse(isLegalTime("-1 : 04 : 25"));
	assertFalse(isLegalTime("38 : 23 : 16"));
	assertFalse(isLegalTime("18 : -2 : 06"));
	assertFalse(isLegalTime("16 : 223 : 16"));
	assertFalse(isLegalTime("18 : 12 : 156"));
	assertFalse(isLegalTime("21 : 43 : 6"));
}
public boolean isLegalTime(String s){
	//   /^([0-1][0-9]|2[0-3]) \: ([0-5][0-9]) \: ([0-5][0-9])$/
	if(s == null){
		return false;
	}
	return s.matches("^([0-1][0-9]|2[0-3]) \\: ([0-5][0-9]) \\: ([0-5][0-9])$");
}

非贪婪匹配

正则表达式默认使用贪婪匹配
使用?表示对某一规则进行非贪婪匹配
注意区分?含义，例如\d??

// 例如 匹配1230000时
// /^(\d+)(0*)$/    匹配结果子项1是  "1230000"   子项2是""
// /^(\d+?)(0*)$/   匹配结果子项1是  "123"    子项2是0000
// 再例如 匹配9999时
// /^(\d?)(9*)$/    匹配结果子项1是  "9"   子项2是"999"
// /^(\d??)(9*)$/    匹配结果子项1是  ""   子项2是"9999"

搜索和替换

1）分割字符串：String.split()
2）搜索子串：Matcher.find()
3）替换字符串：String.replaceAll()

练习

模板引擎是指，定义一个字符串作为模板：
Hello, ${name}! You are learning $lang!其中，以${key}表示的是变量，也就是将要被替换的内容
当传入一个Map<String, Object>给模板后，需要把对应的key替换为Map的value。
例如，传入Map为：
{
“name”: “Bob”,
“lang”: “Java”
}
然后，$name被替换为Map对应的值"Bob”，${lang}被替换为Map对应的值"Java"，最终输出的结果为：
Hello, Bob! You are learning Java!
请编写一个简单的模板引擎，利用正则表达式实现这个功能。

public class Main {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		map.put("name", "Bob");
		map.put("lang", "Java");
		String content = "Hello, ${name}! You are learning ${lang}!";
		System.out.println(templateFormat(content, map));
	}
	public static String templateFormat(String content, Map<String, String> map){
		for(Entry<String, String> entry : map.entrySet()){
			String reg = "\\$\\{" + entry.getKey() +"\\}";
			Pattern p = Pattern.compile(reg);
			Matcher m = p.matcher(content);
			content = m.replaceAll(entry.getValue());
		}
		return content;
	}
}
// 输出 Hello, Bob! You are learning Java!