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
l
a
n
g
!
其
中
,
以
{lang}! 其中,以
lang!其中,以{key}表示的是变量,也就是将要被替换的内容
当传入一个Map<String, Object>给模板后,需要把对应的key替换为Map的value。
例如,传入Map为:
{
“name”: “Bob”,
“lang”: “Java”
}
然后,
n
a
m
e
被
替
换
为
M
a
p
对
应
的
值
"
B
o
b
”
,
{name}被替换为Map对应的值"Bob”,
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!