美文网首页首页投稿(暂停使用,暂停投稿)@IT·互联网iOS OC 学习手册
优雅编程之这样写测试用例,你就“正常”了(九)

优雅编程之这样写测试用例,你就“正常”了(九)

作者: 阿_毅 | 来源:发表于2016-07-16 10:27 被阅读867次

    开心一笑

    【朋友病了,要挂盐水。给他扎针的是一个实习小护士,扎了半天都没扎进血管。
    他痛得龇牙咧嘴,无奈叫来了护士长。
    护士长好手法,只见她一针见血地扎进了血管,然后马上拔出来,
    把针递给那个实习护士说:“看清楚没有?你再试一次!”】

    提出问题

    如何优雅编写测试代码???

    解决问题

    开发工作当中,我们经常需要编写很多接口,但是往往忽略了单元测试。即使使用了单元测试,对于大部分人来说,也是用过既仍。编写一些简洁,可复用的单元测试时非常有必要的,以下是来自《代码整洁之道》的几点总结:

    1)TDD(测试驱动开发),意思是先写单元测试,然后写对应的代码,通过修改调试让写的代码通过单元测试。使用TDD,会使测试覆盖所有的代码,测试代码和生产代码的比例有可能会达到1:1 ,所以也会带来成本的问题,所有我们要保持测试的整洁。

    2)单元测试的好处:让代码可扩展,可维护,可复用。

    3)整洁测试的三要素 :可读性、可读性、可读性。

    4)每个测试都可以拆分为三个环节:构造测试数据、操作测试数据、检验操作是否达到预期结果。

    5)双重标准:测试环境中和生产环境中有些条件不必完全一致。生产环境中有时要考虑内存、CPU等性能问题,而在测试环境中不必做这些限制。

    6)一个测试一个断言,不必完全纠结,但单个测试断言数应该最小化,只测试一个概念,还是单一职责的问题;

    7)F.I.R.S.T原则

    • F Fast:测试需要频繁运行,因此要能快速运行;

    • I Independent:测试应该相互独立;

    • R Repeatable:测试应当能在任何环境中重复;

    • S Self-validating:自足验证,测试应该能看到成功与否的结果;

    • T Timely:测试应该及时编写,应该恰好在生产代码之前编写;

    下面用一个例子说明上面的理论(理论很枯燥,实例很美好):

    package com.hwy.test;
    
    import org.junit.Assert;
    import org.junit.Test;
    import java.util.ArrayList;
    import java.util.List;
    
    public class CodeCleanTest {
    
        @Test
        public void testBuySnacks(){
            List<String> snacks =  buySnacks();
            Assert.assertEquals("购买零食有问题,请检查!!!",true,snacks.size()>0);
        }
    
        @Test
        public void testEatSnacks(){
            /** 这个是我们自己构建的零食数据,肯定不会出现null等问题 **/
            /** 我们不要调用buySnacks方法,因为还是单一职责的问题,只测试一个概念**/
            List<String> snacks =  getSnacks();
            Assert.assertEquals("没有一起吃3个零食", 3, eatSnacks(snacks));
        }
    
        @Test
        public void testDropLitter(){
    
            List<String> snacks =  getSnacks();
            Assert.assertEquals("垃圾没有扔掉!!!",true,dropLitter(snacks));
        }
    
        @Test
        public void testDateWithGirl() throws Exception{
            Assert.assertEquals("约会失败了", true, dateWithGirl());
        }
    
        /**
         * 构建零食数据(事实这些注释都是不需要,只是为了大家理解)
         * @return
         */
        public List<String> getSnacks(){
            List<String> snacksList = new ArrayList<>();
            snacksList.add("牛奶");
            snacksList.add("巧克力");
            snacksList.add("土豆片");
            return snacksList;
        }
    
        /**
         * 买零食(事实这些注释都是不需要,只是为了大家理解)
         * @return
         */
        public List<String> buySnacks(){
            List<String> snacksList = new ArrayList<>();
            snacksList.add("牛奶");
            snacksList.add("巧克力");
            snacksList.add("土豆片");
            /** 这里故意显示为空 **/
            //return null;
            return snacksList;
        }
    
        /**
         * 约会
         */
        public boolean dateWithGirl() throws Exception {
            boolean isSuccess = false;
            List<String> snacksList =  buySnacks();
            /** 利用逆向思维,抛出一个业务异常,这里我只是用简单的exception代替 **/
            if(null == snacksList || snacksList.size() ==0){
                throw new Exception("你没买到零食或买到的零食有问题,请检查!");
            }
            /** 代码执行到这一步就说明snacksList不为null,之后的所有
             * 操作都不用判断snacksList是否为空 **/
            List<String> litter =  eatSnacks(snacksList);
            dropLitter(litter);
            isSuccess = true;
            return isSuccess;
        }
    
    
    
        /**
         * 吃零食(事实这些注释都是不需要,只是为了大家理解)
         * @param snacks
         */
        public List<String> eatSnacks(List<String> snacks){
            for (String snack : snacks) {
                System.out.println("一起吃" + snack);
            }
            return snacks;
        }
    
        /**
         * 仍垃圾(事实这些注释都是不需要,只是为了大家理解)
         * @param litter
         */
        public boolean dropLitter(List<String> litter){
            boolean isDrop = false;
            for(String snack:litter){
                System.out.println("扔掉垃圾:" + snack);
    
            }
            /** 这里故意写的有点冗余,只是方便大家学习 **/
            isDrop = true;
            return isDrop;
        }
    
    
    }
    

    上面的每个测试方法都是:test + 原方法名称,一般测试方法都是这么命名的。同时上面的测试方法,每个方法都是独立的,只测试一个概念。

    下面举一个错误的实例:

    package com.hwy.test;
    
    import org.junit.Assert;
    import org.junit.Test;
    import java.util.ArrayList;
    import java.util.List;
    
    public class CodeCleanTest {
    
        @Test
        public void testBuySnacks() throws Exception{
            /** 像这样子,在一个测试方法中,测试太多的方法,造成测试用例难以复用 **/
            /** 这样不符合每个测试一个断言的规则,同时也不符合F.I.R.S.T原则**/
            List<String> snacks =  buySnacks();
            Assert.assertEquals("购买零食有问题,请检查!!!",true,snacks.size()>0);
    
            Assert.assertEquals("没有一起吃3个零食", 3, eatSnacks(snacks));
    
            Assert.assertEquals("垃圾没有扔掉!!!",true,dropLitter(snacks));
    
            Assert.assertEquals("约会失败了", true, dateWithGirl());
        }
    
    
        /**
         * 构建零食数据(事实这些注释都是不需要,只是为了大家理解)
         * @return
         */
        public List<String> getSnacks(){
            List<String> snacksList = new ArrayList<>();
            snacksList.add("牛奶");
            snacksList.add("巧克力");
            snacksList.add("土豆片");
            return snacksList;
        }
    
        /**
         * 买零食(事实这些注释都是不需要,只是为了大家理解)
         * @return
         */
        public List<String> buySnacks(){
            List<String> snacksList = new ArrayList<>();
            snacksList.add("牛奶");
            snacksList.add("巧克力");
            snacksList.add("土豆片");
            /** 这里故意显示为空 **/
            //return null;
            return snacksList;
        }
    
        /**
         * 约会
         */
        public boolean dateWithGirl() throws Exception {
            boolean isSuccess = false;
            List<String> snacksList =  buySnacks();
            /** 利用逆向思维,抛出一个业务异常,这里我只是用简单的exception代替 **/
            if(null == snacksList || snacksList.size() ==0){
                throw new Exception("你没买到零食或买到的零食有问题,请检查!");
            }
            /** 代码执行到这一步就说明snacksList不为null,之后的所有
             * 操作都不用判断snacksList是否为空 **/
            List<String> litter =  eatSnacks(snacksList);
            dropLitter(litter);
            isSuccess = true;
            return isSuccess;
        }
    
    
    
        /**
         * 吃零食(事实这些注释都是不需要,只是为了大家理解)
         * @param snacks
         */
        public List<String> eatSnacks(List<String> snacks){
            for (String snack : snacks) {
                System.out.println("一起吃" + snack);
            }
            return snacks;
        }
    
        /**
         * 仍垃圾(事实这些注释都是不需要,只是为了大家理解)
         * @param litter
         */
        public boolean dropLitter(List<String> litter){
            boolean isDrop = false;
            for(String snack:litter){
                System.out.println("扔掉垃圾:" + snack);
    
            }
            /** 这里故意写的有点冗余,只是方便大家学习 **/
            isDrop = true;
            return isDrop;
        }
    
    
    }
    
    感悟

    读书感悟

    来自《穷查理智慧书》

    • 忙碌的人们很少有闲客来访;沸腾的锅里绝不会落入苍蝇。
    • 失意时,没有人了解;得意时,不了解自己。
    • 愤怒总是有一定的理,但很少有好的道理。
    • 你可能有时犯大错,是因为你认为自己永远正确。
    • 一百个小偷,也偷不走一个人的脸皮,特别是当这个人没有脸皮的话。
    • 人们经常把自己看错了,却很少把自己忘记了。
    • 无人认错的争吵必然延续无尽。
    • 如果你的秘密不想被敌人知道,请先对你的朋友保密。
    • 教训换来的一两智慧,胜过书本一斤的知识。

    其他

    如果有带给你一丝丝小快乐,就让快乐继续传递下去,欢迎转载,点赞,顶,欢迎留下宝贵的意见,多谢支持!

    相关文章

      网友评论

        本文标题:优雅编程之这样写测试用例,你就“正常”了(九)

        本文链接:https://www.haomeiwen.com/subject/qccujttx.html