外贸网站建设是什么意思自己如何制作网页
Junit
简介
JUnit是一个开源的java单元测试框架，它是XUnit测试体系架架构的一种体现
- 是Java语言事实上的标准单元测试库
- 真正的优势来自于JUnit所采作用的思想和技术，而不是框架本身。推动了单元测试、测试先行的编程和测试驱动的开发
- JUnit衍生了许多xUnit工具，将单元测试的优势应用与各种语言。影响了各种平台和语言上的程序员的测试工作
- 专门针对Java语言设计，使用广泛。
- JUnit是事实上的标准单元测试框架
优点
- 可以使用断言（Assertion）测试期望结果；
- 可以方便地组织和运行测试
- 可以方便地查看测试结果
- 常用IDE（例如IntelliJIdea、eclipse）都集成了JUnit
- 可以翻遍地集成到Maven
JUnit的设计
- TestCases：一个测试
- TestSuite：包含一组TestCases，表示一组测试
- TestFixture：测试环境
- TestResult：用于收集测试结果
- TestRunner：用于运行测试
- TestListener：用于监听测试过程，收集测试数据
- Assert：用于断言测试结果是否正确
Assert
使用Assert断言：
- 断言相等：assertEquals(100,x)
- 断言数组相等：assertArrayEquals({1,2,3},x)
- 浮点数断言相等：assertEquals(3.14,x,0.5)
- 断言为null：assertNull(x)
- 断言为true/false:assertTrue(x>0)/assertFalse(x<0)
- 其它：assertNotEquals/assertNotNull
总结
- 一个TestCase包含一组相关的测试方法
- 使用Assert断言测试结果（注意浮点数assertEquals要指定delta）
- 每个测试方法必须完全独立
- 测试代码必须非常简单
- 不能为测试代码再编写测试
- 测试需要覆盖各种输入条件，特别是边界条件
Assert
public static void assertEquals(double expected,double actual,double delta){//expecdted 预期值//actual 实际值//delta 误差值
}
//待测程序
public class Calculator{public double add(double number1,double number2){//返回两数之和return number1+number2;}
}
1.单元测试代码
import junit.framework.TestCase;//引入相应包
public class TestCalculator extends TestCase{public void testAdd(){Calculator calcuator = new Calculator();double result = calculator.add(10,15);Assert.assertEquals(60,result,0);}
}
| assertTrue | |
| assertFalse | |
| assertEquals | 支持boolean，long，int，String等等 |
| assertNotNull | |
| assertNull | |
| assertSame | 只支持Object类型（对象直接比较） |
| assertNotSame | |
| fail |
hamcrest
Hamcrest框架提供了一套匹配符Matcher，这些匹配符更接近自然语言，可读性高，更加灵活。
Hamcrest是一个书写匹配器对象时允许直接定义匹配规则的框架。
JUnit4.4引入了使用全新的断言语法：assertThat，结合Hamcest提供的匹配符，只用这一个方法，就可以实现所有的测试；
//assertThat语法如下
assertThat(T actulal,Matcher<T> matcher);
assertThat(String reson,T actual,Matcher<T> matcher);
//reson 失败提示信息
//actual 实际值
//matcher 匹配器
注意事项
-
必须导入JUnit4.4之后的版本才能使用assertThat方法
-
不需要继承TestCase类，但是需要测试方法前加
@Test -
需要导入Hamcrest类库：hamcrest-core-1.3.0.jar和hamcrest-library-1.3.0.jar
-
在eclipse或MyEclipse中使用时，建议使用自定义的Library。
否则抛出异常：java.lang.SecurityExcepiton
import static org.junit.Assert.*;
import static org.hamcrest.Matchers.*;
import org.junit.Test;
public class CalculatorTest2{Calculator calc = new Calculator();@Testpublic void testAdd(){int result = calc.add(10,20);assertThat(result,is(30));}
}
Mathcers的一般匹配器
//所有条件必须都成立测试才能通过，相当于"与"(&&)
assertThat(n,allOf(greaterThan(1),lessThan(15));
//所有条件只要有一个成立测试通过，相当于”或"(||)
assertThat(n,anyOf(greaterThan(16),lessThan(8)));
//无论什么条件，永远为true
assertThat(n,anyThing());
//待测的object等于后面给出的object，则测试通过
assertThat(obj,is(obj));
//与is匹配符正好相反
assertThat(obj,not(obj));
Mathcers的字符串匹配器
//str包含子字符串“software”则测试通过
assertThat(str,containsString("software"));
//str以子字符串“software”结尾则测试通过
assertThat(str,endsWith("software"));
//str以子字符串“software”开始则测试通过
assertThat(str,startsWith("software"));
//相等则测试通过，可测数值，字符串和对象之间是否相等，相当于Object的equals方法
assertThat(n,equalTo(nExpected));
//字符串str在忽略大小写的情况下等于"software"则测试通过
assertThat(str,equalToIgnoringCase("software"));
//忽略头尾的的任意个空格的情况下是否相等。注意：字符串中的空格不能被忽略
assertThat(str,equalToIgnoringWhiteSpace("software"));
Matchers的数值型匹配器
//浮点型数d在20.0+_0.5范围之内则测试通过
assertThat(d,closeTo(20.0,0.5));
//数值d大于16.0则测试通过
assertThat(d,greaterThan(16.0));
//数值d小于16.0则测试通过
assertThat(d,lessThan(16.0));
//数值d大于等于16.0则测试通过
assertThat(d,greaterThanOrEqualTo(16.0));
//数值d小于等于16.0则测试通过
assertThat(d,lessThanOrEqualTo(16.0));
Matchers的集合匹配器
//Map对象mapObject含有一个键值为"key"对应元素值为"value"的Entry项测试通过
assertThat(mapObject,hasEntry("key","value"));
//Map对象mapObject含有键值"key"则测试通过
assertThat(mapObject,hasKey("key"));
//Map对象mapObject含有元素值"value"则测试通过
assertThat(mapObject,hasValue("value"));
//迭代对象iterableObject含有元素"element"项则测试通过
assertThat(iterableObject,hasItem("element"));
@Test
对可能抛出的异常进行测试：
异常本身是方法签名的一部分：
public static int parseInt(String s) throws NumberFormatException
测试错误的输入是否导致特定的异常：
Integer.parseInt(null)
Integer.parseInt(“”)
Integer.parseInt(“xyz”)
在测试类中，并不是每一个方法都时用于测试的，你必须使用@Test注解来表命那些事测试方法
-
测试方法地声明要求
- 返回必须为void
- 不能有任何形参
-
@Test(timeout=1000)
-
测试逻辑复杂地循环，防止死循环，单位为毫秒
@Test(timeout=1000) public void testSquareRoot(){calc.squareRoot(4);assertTaht(calc.getResult(),is(2)); }
-
-
@Test(expected=ArithmeticException.class)
检测是否跑出来我们指定地异常，它若没抛出，则为bug
@Test(expected=ArithmeticException.class) public void testDivide(){calc.divide(0); }
@Ignore
-
被忽略地测试方法
-
某些方法尚未完成或方法已经过时，不参与此次测试
-
在某些条件下才能测试该方法（如：需要一个数据库连接，而在本地测试的时候，数据库并没有连接
-
测试结果会提示有几个测试被忽略，而不是失败
@Ignore("方法还未实现") @Test public void testMultiply(){calc.multiply(2); }
-
Fixture
某些阶段必然被调用的代码
@Test
@Ignore
@Before
@After
@BeforeClass
@AfterClass
@RunWith
@Parameters
@Suite.SuiteClasses
@Before和@After
- 注解@Before
- 在每个测试方法执行之前都要执行一次
- 在每个测试执行之前需要进行的准备工作
- 注解@After
- 在每个测试方法执行之后要执行一次
- 在任何测试执行之后进行的收尾工作
- @Before和@After标示的方法只能各有一个
JUnit使用@Before和@After
- 在@Before方法中初始化测试资源
- 在@After方法中释放测试资源、
public class CalculatorTest{Calculator calc;@Beforepublic void setUp(){calc = new Calculator();}@Afterpublic void tearDown(){calc = null;}
}
JUnit对于每个@Test方法：
- 实例化CalculatorTest
- 执行@Before方法
- 执行@Test方法
- 执行@After方法
使用@Before和@After可以保证：
- 单个@Test方法执行前会创建新的XxxTest实例，实例变量的状态不会传递给下一个@Test方法
- 单个@Test方法执行前后会执行@Before和@After方法
@BeforeClass和@AfterClass静态方法：
- 在执行所有@Test方法前执行@BeforeClass静态方法
- 执行所有测试
- 在执行所有@Test方法后执行@AfterClass静态方法
@BeforeClass和@AfterClass静态方法
public class CalculatorTest{static StringBuilder builder;@BeforeClasspublic static void beforeClass(){builder = new StringBuilder();}
}
- @BeforeClass静态方法初始化的对象只能存放在静态字段中
- 静态字段的状态会影响到所有@Test
@BeforeClass和@AfterClass
-
注解@BeforeClass
所有测试开始之前运行
-
注解@AfterClass
所有测试结束之后运行
-
@BeforeClass和@AfterClass标示的方法只能各有一个
-
该方法必须是
public static修饰
JUnit的执行逻辑
invokeBeforeClass(CalculatorTest.class);//@BeforeClass
for(Method testMethod : findTestMethods(CalculatorTest.class)){CalculatorTest test = new CalculatorTest();//newtest.setUp();//@BeforetestMethod.invoke(test);//@Testtest.tearDown();//@After
}
invokeAfterClass(CalculatorTest.class);//@AfterClass
总结
初始化资源称为Fixture
- @Before：初始化测试对象，例如：input = new FileInputStream();
- @After：销毁对象@Before创建的测试对象，例如：input。close()
- @BeforeClass：初始化非常耗时的资源，例如：创建数据库
- @AfterClass：清理@BeforeClass创建的资源，例如：删除数据库
public class SequenceTest {@BeforeClasspublic static void setUpBeforeClass() throws Exception{System.out.println("setUpBeforeClass");}@AfterClasspublic static void treaDownAfterClass() throws Exception{System.out.println("tearDownAfterClass");}public SequenceTest(){System.out.println(" new SequenceTest");}@Beforepublic void setUp() throws Exception{System.out.println(" setUp");}@Afterpublic void treaDown() throws Exception{System.out.println(" treaDown");}@Testpublic void test1001() {System.out.println(" test1001");}@Testpublic void test1002() {System.out.println(" test1002");}@Testpublic void test1003() {System.out.println(" tset1003");}
}
#执行结果
setUpBeforeClassnew SequenceTestsetUptest1001treaDownnew SequenceTestsetUptest1002treaDownnew SequenceTestsetUptset1003treaDown
tearDownAfterClass
- 理解JUnit执行测试的生命周期
- @Before用于初始化测试对象，测试对象以实例变量存放
- @After用于清理@Before创建的对象
- @BeforeClass用于初始化耗时资源，以静态变量存放
- @AfterClass用于清理@BeforeClass创建的资源
@RunWith
@Runwith放在测试类名之前，用来确定这个类怎么运行的。不标注时会使用默认运行器。
常见的JUnit运行器
当类被@RunWith注解修饰，或者类继承了一个被该注解修饰的类，JUnit将会使用这个注解所指明的运行器（runner）来运行测试，而不是JUnit默认的运行器
-
默认运行器
@RunWith(Junit4.class)
-
参数化运行器
- @RunWith(Patammeterized.class)配合@Patameters使用junit的参数化功能
- @RunWith(Suite.class)
- @SuiteClass({ATest.class,BTest.class,CTest.class})
- 配合使用测试集功能
-
兼容junit3.8的运行器
@RunWith(JUnit38ClassRunner.class)
-
其他运行器
例如@RunWith(SpringJUnit4ClassRunner.class)集成了spring的一些功能
//测试类必须标记为@RunWith(Patameterized.class)
@RunWith(Parameterized.class)
public class AbsTest(){private int input;private int expected;//参数必须由静态方法data()返回//返回类型为Collection<Object[]>//静态方法必须标记为@Patameters@Parameterspublic static Collection<?> data(){return arrays.asList(new Object[][]{{0,0},{1,1},{-1,1}})}//构造方法参数必须和测试参数对应public AbsTest(int input,int expected){this.input = input;this.expected = expected;}//测试Math@Testpublci void testAbs(){int result=Math.abs(this.input);Assert.asserEquals(this.expected,result)}
}
@RunWith(Patameterized.class)
public class SqureTest{private static Calclator calculator = new Calculator();private int param;private int result;@Parameterspublic static Collection data(){return Arrays.asList(new Object[][]{{2,4},{0,0},{-3,9}});}//构造方法，对变量进行初始化public SquareTest(int param,int result){this.param = param;this.result = result;}@Testpublic void squareTest(){calculator.square(param);assertEquals(result,calclulator.getResult());}
}
实现步骤
- 为类指定运行器：@RunWith(Parameterized.class)
- 创建提供数据的方法，加上@Parameters注解，方法必须是static的，并且返回一个集合Collection;
- 在测试类的构造方法中为各个参数赋值
- 编写测试方法，它会根据参数的组数来运行测试多次
- 注意
- 要为这种测试专门生成一个新的类
- 要为这个类指定一个Runner，而不能使用默认的Runner
JUnit为我们提供了打包测试的功能，将所有需要运行的测试类集中起来，一次性的运行完毕
@RunWith(Suite.class)
@Suite.SuiteClass({CalculatorTest.class,SquareTest.class
})
public class AllCalcculatorTests{//没有内容没关系
}
参数化测试
如果待测试的输入和输出是一组数据：
- 可以把测试数据组织起来
- 用不同的测试数据调用相同的测试方法
- 参数必须由静态方法data()返回
- 返回类型为Collection<Object[]>
- 静态方法必须标记为@Parameters
- 测试类必须标记为@RunWith()
- 构造方法参数必须和测试参数对应
//测试类必须标记为@RunWith(Patameterized.class)
@RunWith(Parameterized.class)
public class AbsTest{//参数必须由静态方法data()返回//返回类型为Collection<Object[]>//静态方法必须标记为@Patameters@Parameterspublic 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;}@Testpublic void testAbs(){int r = Math.abs(this.input);Assert.assertEquals(this.expected,r);}
}
超时测试
- @Time(timeout = 1000)可以设置超时
- timeout单位时毫秒
- 超时测试不能取代性能测试和压力测试
//计算圆周率
//PI/4 = 1 - 1/3 + 1/5 - 1/7 + 1/9 -…
public class PI {//PI/4 = 1 - 1/3 + 1/5 - 1/7 + 1/9 -…//PI = 4 - 4/3 + 4/5 - 4/7 + 4/9 -...public double calculate(int count){double sum = 0;boolean positive = true;int n = 0;for (int i = 1;;i += 2){sum = sum + (positive ? 4.0 : -4.0)/i;positive = !positive;n++;if(n == count){break;}}return sum;}
}
public class PITest {PI pi;@Beforepublic void setUp() {pi = new PI();}@Afterpublic void tearDown() {pi = null;}//超时时间为100ms@Test(timeout = 100)public void test1k(){//计算1000次double r = pi.calculate(1000);assertEquals(3.14,r,0.01);}//超时时间为500ms@Test(timeout = 500)public void test1m(){//计算1百万次double r = pi.calculate(1000000);assertEquals(3.1416,r,0.0001);}//超时时间为500ms@Test(timeout = 500)public void test100m() {//计算10亿次double r = pi.calculate(1000000000);assertEquals(3.14159,r,0.00001);}
}
示例
/*
填写快递单时通常需要确定接收人的姓名、手机号和地址。其中要求手机号是11位数字字符，地址为字母开头的10个（含10）以内字母或字母数字共同组成。填写正确则提示“OK”，否则根据实际情况提示“**不符合要求”（**为手机号或地址）,退出。编写程序实现此快递单信息的输入，并设计测试数据进行判定覆盖测试。输入数据打印出“输入手机号:”、“输入地址:”。
*/
public static main(String[]args){Scanner sc = new Scanner(System.in);System.out.println("请输入收件人手机号");String phone = sc.nextLine();System.out.println("请输入收件人地址");string address = sc.nextLine();boolean mphone = phone.matches("^\\d{11})$");boolean maddress = address.matches("^[a-zA-Z][a-zA-Z0-9]*$");if(!phmone){System.out.println("手机号不符合要求");}else if(!maddress){System.out.println("地址不符合要求");}else{System.out.println("OK");}
}
@RunWith(Parameterized.class)
public class ProgramTest(){private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();private final PrintStream originalOut = System.out;static Program program;String phone,address,expected;@Beforepublic void setUp(){program = new Program();System.setOut(new PrintStream(outContent));String inputMessage = phone + "\r\n" + address +"\r\n";System.setIn(new ByteArrayInputStream(inputMessage.getBytes()));}@Parameterspublic static Collection data(){return Array.asList(new Object[][]{{ "12345678900", "Asdfg12345", "OK" },{ "12345678900", "Asdfg12345a", "地址不符合要求" }, { "123456789001", "Asdfg12345", "手机号不符合要求" } })}public ProgramTest(String phone,String address,String expected){this.phone=phone;this.address=address;this.expected=expected;}@Testpublic void testMain(){program.main(null);String result = outContent.toString().split("\r\n")[2];assertThat(result,is(expected));}
}
@Test
public void test1001(){ByteArrayOutputStream outContent = new ByteArrayOutputStream();printStream originalout = System.out;Program progaram = new Program();System.setOut(new PrintStream(outContent));String inputMessage = "12345678900" + "\r\n" + "Asdfg12345" + "\r\n";System.setIn(new ByteArrayInputStream(inputMessage.getBytes()));program.main(null);String result = outContent.toString().split("\r\n")[2];assertThat(result,is("OK"));
}