亚洲女人18毛片水真多,亚洲激情视频网站,亚洲人成色77777在线观看

探烦JUnit4扩展�Q�深入Rule(�?

Sha Jiang — Tue, 03 Jan 2012 16:13:00 GMT

探烦JUnit4扩展�Q�深入Rule

本文�?探烦JUnit4扩展"�p�d��中的�W�三��，��进一步探�I�Rule的应用，展示如何使用Rule来替代@BeforeClass�Q�@AfterClass�Q�@Before和@After的功能�?2012.01.04最后更�?

在本�p�d��的第二篇《探索JUnit4扩展�Q�应用Rule�?/a>中提刎ͼ�可以使用Rule替代现有的大部分Runner扩展�Q�而且也不提倡对Runner中的withBefores()�Q�withAfters()�{�方法进行扩展。本文将介绍如何使用Rule��d��现@Before�Q�@After和@BeforeClass的相同功能�?/span>

1. BaseRule
首先要创��Z��个较通用的TestRule实现BaseRule�Q�它会释攑և�两个扩展点，一个在执行��试�Ҏ��之前�Q�before()�Q�另一个在执行��试�Ҏ��之后after()。下面是该类的代码，

public abstract class BaseRule implements TestRule {

    @Override
    public Statement apply(Statement base, Description description) {
        return new RuleStatement(base, description);
    }

    private class RuleStatement extends Statement {

        private Statement base = null;

        private Description description = null;

        private RuleStatement(Statement base, Description description) {
            this.base = base;
            this.description = description;
        }

        @Override
        public void evaluate() throws Throwable {
            before(base, description);
            try {
                base.evaluate();
            } finally {
                after(base, description);
            }
        }
    }

    protected void before(Statement base, Description description) throws Throwable {

    }

    protected void after(Statement base, Description description) {

    }
}

如果对JUnit4的源代码略有认知�Q�可能会发现BaseRule与JUnit4提供的TestRule实现ExternalResource代码�怼�。关键的不同之处是，BaseRule中的before()与after()�Ҏ��都提供了Statement与Description�c�d��的参敎ͼ��q��得它能够完成更复杂的工作�?/span>

2. CalculatorTest
本文使用的CalculatorTest��不使用@BeforeClass�Q�@Before和@After�Q�而会创徏两个BaseRule的实例：一个用于替代@BeforeClass和@AfterClass(本系列目前还未��用过@AfterClass)�Q�另一个则替代@Before和@After�?/span>

public class CalculatorTest {

    private static final DateFormat format = new SimpleDateFormat("yyyy-MM-dd_HH:mm:ss_SSS");

    private static Calculator calculator = null;

    @ClassRule
    public static BaseRule classRule = new BaseRule() {

        protected void before(Statement base, Description description) throws Throwable {
            calculator = new Calculator();
        };
    };

    @Rule
    public BaseRule rule = new BaseRule() {

        protected void before(Statement base, Description description) throws Throwable {
            printBeforeLog(description);
        };

        protected void after(Statement base, Description description) {
            printAfterLog(description);
        };

        private void printBeforeLog(Description description) {
            TestLogger testLogger = description.getAnnotation(TestLogger.class);
            if (testLogger != null) {
                StringBuilder log = new StringBuilder(format.format(new Date()));
                log.append(" ").append(description.getClassName()).append("#")
                        .append(description.getMethodName()).append(": ")
                        .append(testLogger.log());
                System.out.println(log.toString());
            }
        }

        private void printAfterLog(Description description) {
            StringBuilder log = new StringBuilder(format.format(new Date()));
            log.append(" ").append(description.getClassName()).append("#")
                    .append(description.getMethodName()).append(" end");
            System.out.println(log.toString());
        }
    };

    @Test
    @TestLogger(log = "a simple division")
    public void simpleDivide() {
        int value = calculator.divide(8, 2);
        Assert.assertTrue(value == 4);
    }

    @Test(expected = ArithmeticException.class)
    @TestLogger(log = "divided by zero, and an ArithmeticException thrown.")
    public void dividedByZero() {
        calculator.divide(8, 0);
    }
}

值得注意的是�Q�classRule是静态变量，它��用@ClassRule Annotation�Q�将替代@BeforeClass和@AfterClass�Q�而rule是成员变量，它��用@Rule Annotation�Q�将替代@Before和@After。与之前文章不同的是�Q�此处不仅会在执行测试方法之前打印指定内容的日志(printBeforeLog())�Q�还会在执行��试�Ҏ��之后打印一条固定格式的日志(printAfterLog())�Q�用于指�C��试�Ҏ��已经执行完毕了�?/span>

3. ��结
使用Rule可以替代�l�大部分的Runner扩展�Q�而且特定的Rule实现可以被复用，也易于添加或�U�除Rule实例�Q�这些都大大地提高了灉|��性。值得注意地是�Q�本文虽然��用Rule代替了@BeforeClass�Q�@AfterClass�Q�@Before和@After的功能，但�ƈ不意味着��应当这么做。就我个人所惻I��传�l�的Fixture功能交由@BeforeClass�Q�@AfterClass�Q�@Before和@After实现�Q�仍然是一�U�不错的选择�?/span>

Sha Jiang 2012-01-04 00:13 发表评论

探烦JUnit4扩展�Q�应用Rule(�?

Sha Jiang — Sat, 24 Dec 2011 15:26:00 GMT

探烦JUnit4扩展�Q��用Rule

在上一��文�?a href="http://www.tkk7.com/jiangshachina/archive/2011/12/14/366289.html">《探索JUnit4扩展�Q�扩展Runner�?/a>中，讨论了一�U�扩展JUnit4的方式，卻I��直接修改Test Runner的实�?BlockJUnit4ClassRunner)。但�q�种�Ҏ��昄��不便于灵�z�d��d��或删除扩展功能。本文将使用JUnit4.7才开始引入的扩展方式--Rule来实现相同的扩展功能�?2010.12.25最后更�?

1. Rule
Rule是JUnit4.7才开始提供的一�U�扩展方式，它能够替代大部分已有的Runner扩展。JUnit包含两种Rule Annotation�Q�@ClassRule与@Rule。@ClassRule应用于测试类中的静态变量，而@Rule应用于成员变量；相同地是�Q�这些变量必��L��TestRule接口的实例，且访问修饰符必须为public�?br />�?a href="http://www.tkk7.com/jiangshachina/archive/2011/12/14/366289.html">上篇博文中，对BlockJUnit4ClassRunner�q�行了扩展，被扩展的�Ҏ��是methodBlock�Q�现在我们来看看该方法体中的代码�Q?br />

protected Statement methodBlock(FrameworkMethod method) {
    Object test;
    try {
        test= new ReflectiveCallable() {
            @Override
            protected Object runReflectiveCall() throws Throwable {
                return createTest();
            }
        }.run();
    } catch (Throwable e) {
        return new Fail(e);
    }

    Statement statement= methodInvoker(method, test);
    statement= possiblyExpectingExceptions(method, test, statement);
    statement= withPotentialTimeout(method, test, statement);
    statement= withBefores(method, test, statement);
    statement= withAfters(method, test, statement);
    statement= withRules(method, test, statement);
    return statement;
}

但在BlockJUnit4ClassRunner中，possiblyExpectingExceptions()�Q�withPotentialTimeout()�Q�withBefores()和withAfters()都已�l�被标注��Ӟ��JUnit��使用Rule来替代这些方法的功能�?br />
2. TestLogRule
如第1节所�q�ͼ�Rule Annotation要作用于TestRule接口的实例，那么��p��先创��Z��个TestRule的实现类�?br />

public class TestLogRule implements TestRule {

    private static final DateFormat format = new SimpleDateFormat("yyyy-MM-dd_HH:mm:ss_SSS");

    @Override
    public Statement apply(Statement base, Description description) {
        TestLogger testLogger = description.getAnnotation(TestLogger.class);
        if (testLogger != null) {
            StringBuilder log = new StringBuilder(format.format(new Date()));
            log.append(" ").append(description.getClassName()).append("#")
                    .append(description.getMethodName()).append(": ")
                    .append(testLogger.log());
        System.out.println(log.toString());
    }

        return base;
    }
}

如上所�C�，TestLogRule�?a href="http://www.tkk7.com/jiangshachina/archive/2011/12/14/366289.html">上篇博文中的LoggedRunner的代码有许多相同之处�Q�功能则都是打印出指定的日志�Q�每行日志又以当时的执行旉��与完整方法名作�ؓ前缀�?br />
3. 使用Rule的CalculatorTest
下面是新的测试类CalculatorTest�Q�它��不使用BlockJUnit4ClassRunner的扩展LoggedRunner作�ؓ��试执行器，所以该�c�L��有��用@RunWith(LoggedRunner.class)�Q�那么在执行该测试类时仍然会使用BlockJUnit4ClassRunner�?br />

public class CalculatorTest {

    private static Calculator calculator = null;

    @Rule
    public TestLogRule testLogRule = new TestLogRule();

    @BeforeClass
    public static void createCalculator() {
        calculator = new Calculator();
    }

    @Test
    @TestLogger(log = "a simple division")
    public void simpleDivide() {
        int value = calculator.divide(8, 2);
        Assert.assertTrue(value == 4);
    }

    @Test(expected = ArithmeticException.class)
    @TestLogger(log = "divided by zero, and an ArithmeticException thrown.")
    public void dividedByZero() {
        calculator.divide(8, 0);
    }
}

�?a href="http://www.tkk7.com/jiangshachina/archive/2011/12/14/366289.html">上篇博文中的CalculatorTest相比�Q�本文中的CalculatorTest除了没有使用LoggedRunner之外�Q�还多了两行代码

@Rule
public TestLogRule testLogRule = new TestLogRule();

在执行单元测试方法之前，BlockJUnit4ClassRunner会调用TestRule/TestLogRule中的apply()�Ҏ��Q�即�Q�会先打印出日志内容�?br />
4. ��结
使用Rule对JUnit�q�行扩展�Q�能够避免对默认Runner的扩展，为测试类��d��或移除Rule十分方便�Q�而且Rule实现�c�L��w�也能很方便地被复用。在下一��博�?/a>中将�q�一步探索Rule的应用�?/div>

Sha Jiang 2011-12-24 23:26 发表评论

探烦JUnit4扩展�Q�扩展Runner(�?

Sha Jiang — Tue, 13 Dec 2011 16:01:00 GMT

探烦JUnit4扩展�Q�扩展Runner

在��用JUnit的过�E�中�Q�大家可能会对JUnit�q�行一些扩展。本文中的示例�ؓJUnit4定义了一个新的Annotation�Q��ƈ相应地对已有的Runner�q�行扩展�Q��其能够解析新引入的Annotation�?2011.12.25最后更�?

本文臆造了一个示例，会在执行单元��试�Ҏ��之前�Q�自动地为单元测试方法打印日志。该�C�Z��会�ؓJUnit定义一个新的Annotation用于指定要打印的日志内容�Q��ƈ对JUnit默认提供的Runner实现BlockJUnit4ClassRunner�q�行扩展�Q��其能够识别这个新的Annotation�?br />
1. 定义Annotation
TestLogger是一个作用于�Ҏ��的Annotation�Q�它只有一个属性，用于指定日志的内容，其代码如下所�C�，

@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface TestLogger {
public String log() default "";
}

2. 扩展Runner
JUnit提供了若�q�个Runner的实玎ͼ�如BlockJUnit4ClassRunner�Q�Suite�Q�其中BlockJUnit4ClassRunner用来执行单个��试用例�c�R��LoggedRunner��扩展BlockJUnit4ClassRunner�Q�覆写其中的methodBlock()�Ҏ��。新的methodBlock()�Ҏ��会在一开始试图获取被执行��试�Ҏ��中的TestLogger Annotation�Q�如果存在的话，��׃��打印出指定的日志�Q�每行日志以当时的执行时间与完整�Ҏ��名作为前�~�。该�cȝ��代码如下所�C�，

public class LoggedRunner extends BlockJUnit4ClassRunner {

    private static final DateFormat format = new SimpleDateFormat("yyyy-MM-dd_HH:mm:ss_SSS");

    public LoggedRunner(Class klass) throws InitializationError {
        super(klass);
    }

    @Override
    protected Statement methodBlock(FrameworkMethod method) {
        Method classMethod = method.getMethod();
        TestLogger loggerAnnotation = classMethod.getAnnotation(TestLogger.class);
        if (loggerAnnotation != null) {
            StringBuilder log = new StringBuilder(format.format(new Date()));
            log.append(" ").append(classMethod.getDeclaringClass().getName())
                    .append("#").append(classMethod.getName()).append(": ")
                    .append(loggerAnnotation.log());
            System.out.println(log.toString());
        }

        return super.methodBlock(method);
    }
}

3. 应用�E�序
Calculator是一个简单的应用�E�序�Q�其中定义了一个除法方法，代码如下所�C�，

public class Calculator {

    public int divide(int a, int b) {
        return a / b;
    }
}

4. 单元��试�E�序
CalculatorTest是一个简单的单元��试�E�序�Q�它会��用两�U�方式对Calculator中的divide()�Ҏ��q�行单元��试。其代码如下所�C�，

@RunWith(LoggedRunner.class)
public class CalculatorTest {

    private static Calculator calculator = null;

    @BeforeClass
    public static void createCalculator() {
        calculator = new Calculator();
    }

    @Test
    @TestLogger(log = "a simple division.")
    public void simpleDivide() {
        int value = calculator.divide(8, 2);
        Assert.assertTrue(value == 4);
    }

    @Test(expected = ArithmeticException.class)
    @TestLogger(log = "divided by zero, and an ArithmeticException thrown.")
    public void dividedByZero() {
        calculator.divide(8, 0);
    }
}

值得注意的是�Q�CalculatorTest特别指定LoggedRunner作�ؓ��试执行�?@RunWith(LoggedRunner.class))�Q�同�Ӟ��每个单元��试�Ҏ��Q�simpleDivide()与dividedByZero()�Q�都使用了Annotation TestLogger�Q��ؓ其指定日志内宏V��当执行上述单元��试�Ӟ��会自动地打印出如下�Ş式的日志内容�Q?br />

2011-12-13_23:48:38_218 test.CalculatorTest#simpleDivide: a simple division
2011-12-13_23:48:38_218 test.CalculatorTest#dividedByZero: divided by zero, and an ArithmeticException thrown.

5. ��结
通过对BlockJUnit4ClassRunner的扩展，可以让JUnit在运行测试用例时做一些额外的工作。但�q�种直接修改默认Test Runner的方式�ƈ不被提倡，�?a href="http://www.tkk7.com/jiangshachina/archive/2011/12/24/366801.html">下一��文�?/a>中将会介�l��用Test Rule来达到相同的扩展目的�?br />

Sha Jiang 2011-12-14 00:01 发表评论

何时�~�写单元��试�Q?�?

Sha Jiang — Mon, 09 Jun 2008 12:55:00 GMT

何时�~�写单元��试�Q?/span>

    是在�~�写一个方法之前就�~�写它的单元��试�Q�还是在写完�q�个�Ҏ��Q�甚��x��整个�c�M��后才�~�写单元��试呢？John Ferguson Smart^[1]在他�?a >blog中再�ơ提��Z��q�个问题�Q��ƈ�Ҏ��自己的经验给��Z��一些徏议�?2008.06.10最后更�?

    都别书生意气了。在你编写一个方法之前或是之后编写单元测�?-�Ҏ��我的�l�验�Q�只要你在编写代码的几乎同时��p��虑�q�编写单元测试程序，那么�q�就无关紧要了。过后再�q�回�?或者根本就不回�?写测试程序将��D��问题。就我个��言�Q�我喜欢在编写少量代码之前或紧接着的之后就�~�写单元��试--�q�不会打破工作流�E�，因�ؓ它就是流�E�的一部分�?br />     �q�需要一点儿实践�l�验--�~�Z��l�验的开发者经��ؓ要写什么样的测试程序而烦恹{��但�q�可能也反映��Z��个事实：他们同样也不知道要写什么样的代码。一些�h评说TDD能够鼓励�q�行微设�?-一�U�非常底层的设计�Q�它不需要考虑较大的场景。这会发生在�~�Z��l�验的开发者��n上；如果你教条般地应用这�U�方法，同样也会遇上。像行�ؓ驱动开发这��L��Ҏ��在此处就会很酗��当你在写getter�Ҏ��之前�Q�你会写一个针对这个getter�Ҏ��的单元测试吗�Q�如果是的话�Q�那么你的单元测试专注的层次��p��高了�Q�也会更接近于用�?或系�l?的需求�?br />     回到问题的本质，��Z��么我喜欢把单元测试放在最开始的位置�Q�很��单！我的实践�l�验告诉我，那样可以帮助提高代码的质量，�q�且节约调试旉��。在开始时写十个小的单元测试所��q��旉��比在以后修复Bug所��q��旉��要少�Q�如果代码经�q�了正确的单元测试，那就不会有Bug了�?br />     事实上，我屡屡见刎ͼ�如果某些代码�l�过了适当的单元测试，那么��׃��会有�~�码问题。最�q�就有一个例子：�׃��一个小时的旉��L��寻Web应用中的一个问题，该问题出现在一个编写正��的Spring-MVC�E�序中。结果是�׃��一个检验器�c�d��略了一个异常。很�Ҏ��发��C��q�个问题�Q�实际上�Q�在看了代码(代码��?Code Review)也很有效)之后立刻��发��C��。但关键是，我们�׃��一个小时甚��x��多的旉��L��q�个需要进行检查的�c�R��如果这些代码经�q�了适当的测试，那么��p��很快地发现�ƈ解决�q�个问题�?br />     �Ҏ��我的�l�验�Q�当��Z��在编写完�E�序之后才开始编写单元测试，��如同事后才有这��L��x��Q�他们很隑ֆ��些测试了 ("我已�l�完成了所有的代码�Q�此时我�q�得��d��单元��试")。或者根本就不去做。在�q�种情况下，代码是否完成了呢�Q�如果代码运行地很好�Q�那��q��是完成了。这��L��话，再写单元��试��大大地丧失了它的�h倹{��还不仅如此�Q�事后编写的单元��试��是肤浅的，不会对代码进行良好地��试。或者，开发者已�l�耗完了时��_��他们�Ҏ��׃��惛_��为单元测试伤��了�?br />     TDD与�Q何其它的�~�码实践一栗��当你正在学习某个新的技术时�Q�你会們֐�于对学习指导亦步亦趋。类似地�Q�当你学习一��Ҏ��术时�Q�你也会试着一步步地模仿大师的动作�Q�而不必去理解其中的逻辑。一旦你熟悉了某个技术，能够熟练��C��用它�Q��ƈ对它有了更深入地理解�Q?em>然后�Q�你��p��改进它，�q�与你之前掌握的其它技术进行溶合了�?br />
译注
[1]John�?a >Java Power Tools一书的��M��者，也是java.net中一位活跃的Blogger�?br />
译后
    上周在java.net上看到这��Blog�Q�再联想到自己在�q�x��工作中的单元��试实践�Q�有些感触，故将其翻译了出来�Q�与大家�׃�n�?br />     事先��q��写单元测试，�q�是事后才编写单元测试？�q�是一个老问题。按照TDD的思想�Q�自然是要先�~�写单元��试�Q�然后再�~�写能够通过该单元测试的�Ҏ��?br />     但，单元��试�q�不是TDD的专属领圎ͼ�很多不实践TDD的项目也在应用着单元��试�?br />     我认为，在不实践TDD的项目中(我自己所处的环境��是如此)�Q�事后编写单元测试仍有着其合理性：
    1. 以消极的态度来看�Q�既焉��目本�w�不严格要求事先�~�写单元��试�Q�那么就可以在事后去做了。这臛_��比不��d��要好�Q�聊胜于无嘛�?嘿嘿�Q�是够消极的�Q�但也拿你没办法)
    2. 事后�~�写单元��试臛_��也是一�U�检验手�D�，当然�Q�肯定比不上事先�~�写的单元测试。因为，事后�~�写的单元测试很可能�?��就"已经写好的应用程序，正如John所�?事后�~�写的单元测试将是肤��的�Q�不会对代码�q�行良好地测�?。但...仍然是聊胜于无嘛 :-D (哈哈�Q�有完没完了)
    3. 可以把单元测试，其中��包含事后单元测试，作�ؓ"后来�?了解、学习应用程序的手段。因为单元测试程序就是应用程序的"客户"�Q�所以无论它是事先写的，�q�是事后写的�Q�都能够表现出应用程序的行�ؓ�?br />     4. 事后单元��试�Q�也可能转化��Z��先单元测试。在应用�E�序的整个生命周期中�Q�维护阶�D�|��最长的。在"漫长"的维护过�E�中�Q?之前"所写的"事后"单元��试��会成�ؓ"后来�?(包括原始作者本�?�?事先"单元��试。在改进�E�序的过�E�中�Q�这些单元测试仍然能起到监督的作用�?orz�Q�有点儿诡辩)
    虽然�Q�事后单元测试明显不如事先单元测试，但它的作用仍然不可低估。只要编写了优秀的单元测试程序，无论是在哪个阶段�Q�它都会�Ҏ��q�应用程序有莫大的帮助�?�q�可不是"聊胜于无"能够表达�?

Sha Jiang 2008-06-09 20:55 发表评论

亚洲女人18毛片水真多,亚洲激情视频网站,亚洲人成色77777在线观看

探烦JUnit4扩展�Q�深入Rule(�?

探烦JUnit4扩展�Q�应用Rule(�?

探烦JUnit4扩展�Q�扩展Runner(�?

何时�~�写单元���试�Q?�?

何时�~�写单元��试�Q?�?