JAVA自动化之Junit单元测试框架详解

?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>junit</groupId>
    <artifactId>junitTest</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <!-- https://mvnrepository.com/artifact/junit/junit -->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>

org.junit.runner.JUnitCore.runClasses(TestClass1.class, ...);

@RunWith(Suite.class)@Suite.SuiteClasses({AssertTests.class, CalculatorTest.class})publicclassSuiteTest{// the class remains empty, used only as a holder for the above annotations}

@FixMethodOrder(MethodSorters.NAME_ASCENDING)publicclassExecutionOrderTest{@TestpublicvoidtestB(){
        System.out.println("second");
    }@TestpublicvoidtestA(){
        System.out.println("first");
    }@TestpublicvoidtestC(){
        System.out.println("third");
    }
}

first
second
third

publicclassExpectedExceptionsTest{//方法一:@Test(expected=xxx)@Test(expected = IndexOutOfBoundsException.class)publicvoidempty(){newArrayList<Object>().get(0);
    }//方法二:try...fail...catch...  当没有异常被抛出的时候fail方法会被调用，输出测试失败的信息。@TestpublicvoidtestExceptionMessage(){try{newArrayList<Object>().get(0);
            fail("Expected an IndexOutOfBoundsException to be thrown");
        }catch(IndexOutOfBoundsException anIndexOutOfBoundsException) {
            assertThat(anIndexOutOfBoundsException.getMessage(), is("Index: 0, Size: 0"));
        }
    }//方法三：在测试之前使用Rule标记来指定一个ExpectedException，并在测试相应操作之前指定期望的Exception类型（如IndexOutOfBoundException.class）@RulepublicExpectedException thrown = ExpectedException.none();@TestpublicvoidshouldTestExceptionMessage()throwsIndexOutOfBoundsException{
        List<Object> list =newArrayList<Object>();
        thrown.expect(IndexOutOfBoundsException.class);
        thrown.expectMessage("Index: 0, Size: 0");
        list.get(0);
    }
}

publicclassIgnoreTest{@Ignore("Test is ignored as a demonstration")@TestpublicvoidtestSame(){
        assertThat(1, is(1));
    }
}

@Test(timeout =2000)publicvoidtestSleepForTooLong()throwsException{
        log +="ran1";
        TimeUnit.SECONDS.sleep(100);// sleep for 100 seconds}

publicclassTimeoutTests{publicstaticString log;privatefinalCountDownLatch latch =newCountDownLatch(1);@RulepublicTimeout globalTimeout = Timeout.seconds(3);// 3 seconds max per method tested@TestpublicvoidtestSleepForTooLong()throwsException{
        log +="ran1";
        TimeUnit.SECONDS.sleep(100);// sleep for 100 seconds}@TestpublicvoidtestBlockForever()throwsException{
        log +="ran2";
        latch.await();// will block}
}

@RunWith(Parameterized.class)publicclassFibonacciTest{@Parameters(name ="{index}: fib({0})={1}")publicstaticCollection<Object[]> data() {returnArrays.asList(newObject[][] {
                {0,0}, {1,1}, {2,1}, {3,2}, {4,3}, {5,5}, {6,8}
        });
    }privateintfInput;privateintfExpected;publicFibonacciTest(intinput,intexpected){this.fInput = input;this.fExpected = expected;
    }@Testpublicvoidtest(){
        assertEquals(fExpected, Fibonacci.compute(fInput));
    }
}

@RunWith(Parameterized.class)publicclassFibonacciTest{@Parameters(name ="{index}: fib({0})={1}")publicstaticCollection<Object[]> data() {returnArrays.asList(newObject[][] {
                {0,0}, {1,1}, {2,1}, {3,2}, {4,3}, {5,5}, {6,8}
        });
    }@Parameter// first data value (0) is defaultpublic/* NOT private */intfInput;@Parameter(1)public/* NOT private */intfExpected;@Testpublicvoidtest(){
        assertEquals(fExpected, Fibonacci.compute(fInput));
    }
}

publicclassAssumptionsTest{@TestpublicvoidtestAssumTrue(){
        System.out.println("test");
        assumeTrue(3>5);//该方法中下面所有的代码在上面假设的条件成立后执行//如果上述假设不成立，则会忽略执行该行下面的代码，并报错System.out.println("assume is true!");
    }@TestpublicvoidtestAssumFalse(){
        assumeFalse(3>5);
        System.out.println("assume is true!");
    }
  }

@TestpublicvoidtestAssumTrueMessage(){
        assumeTrue(3<5,//第二个参数为当第一个参数不成立时，输出的自定义错误信息() ->"Aborting test: not on developer workstation");
        System.out.println("assume is true!");
    }@TestpublicvoidtestAssumeTrueLambda(){//这个方法的第一个参数为函数式接口，无参数返回值为booleanassumeTrue(()->{
            System.out.println("in assumeTrue");booleanflag =false;returnflag;
        });
        System.out.println("out assumeTrue");
    }@TestpublicvoidtestAssumThat(){
        assumingThat(3>5,
                () -> {//与上述方法不同的是，仅当前面假设成立时，才会执行这里面的语句//且只会影响到该lambda表达式中的代码assertEquals(2,2);
                });//此处的断言不受上述assumingThat限制，在所有情况下都会执行System.out.println("no effect");
        assertEquals("a string","a string");
    }

publicclassMethodNameExampleimplementsTestRule{@OverridepublicStatementapply(finalStatement base,finalDescription description){returnnewStatement() {@Overridepublicvoidevaluate()throwsThrowable{//base.evaluate()之前为测试方法运行之前所做操作String className = description.getClassName();
                String methodName = description.getMethodName();//运行测试方法base.evaluate();//base.evaluate()之后为测试方法运行之后所做操作System.out.println("Class name: "+className +", method name: "+methodName);
            }
        };
    }
}

publicclassRuleTest2{@RulepublicMethodNameExample methodNameExample =newMethodNameExample();@Testpublicvoidaddition_isCorrect()throwsException{
        assertEquals(4,2+2);
    }@Testpublicvoidmulitiplication_isCorrect()throwsException{
        assertEquals(4,2*2);
    }
}

@RunWith(Theories.class)publicclassTheoryTest{//允许的最大误差privatestaticfinaldoubleDELTA =0.01;/*@DataPoints注解静态变量*/@DataPointpublicstaticintZERO =0;@DataPointpublicstaticintTWO =2;@DataPointpublicstaticintEIGHT =8;//标志这个测试为Theory测试@TheorypublicvoidtestDivide(intdividend,intdivisor){//跳过除数为0的caseassumeThat(divisor, not(0));//Calculator.divide(dividend, divisor)方法返回他们相除的结果assertEquals(dividend / divisor, Calculator.divide(dividend, divisor), DELTA);
        System.out.println("Passed with: dividend="+ dividend +", divisor="+ divisor);
    }
}

@RunWith(Theories.class)publicclassTheoryTest{//允许的最大误差privatestaticfinaldoubleDELTA =0.01;/*@DataPoints注解一个静态方法*/@DataPointspublicstaticint[] getTestData() {returnnewint[]{0,2,8};
    }//标志这个测试为Theory测试@TheorypublicvoidtestDivide(intdividend,intdivisor){//跳过除数为0的caseassumeThat(divisor, not(0));//Calculator.divide(dividend, divisor)方法返回他们相除的结果assertEquals(dividend / divisor, Calculator.divide(dividend, divisor), DELTA);
        System.out.println("Passed with: dividend="+ dividend +", divisor="+ divisor);
    }
}

Passed with: dividend=0, divisor=2
Passed with: dividend=0, divisor=8
Passed with: dividend=2, divisor=2
Passed with: dividend=2, divisor=8
Passed with: dividend=8, divisor=2
Passed with: dividend=8, divisor=8

importorg.junit.experimental.theories.Theories;importorg.junit.experimental.theories.Theory;importorg.junit.experimental.theories.suppliers.TestedOn;importorg.junit.runner.RunWith;importstaticorg.junit.Assert.assertEquals;@RunWith(Theories.class)publicclassTheoryTest{//允许的最大误差privatestaticfinaldoubleDELTA =0.01;//如果需要限定某个参数，可以使用@TestOn注解@Theorypublicvoid