Android单元测试 - 验证函数参数、返回值的正确姿势

摘要：验证参数传递函数返回值，是单元测试中十分重要的环节。一般形式单元测试下文称为例子这个单元测试是通过的。不过，仅仅比较两个对象，这个单元测试还是有问题的。单元测试的细节，已经讲得七七八八了。

原文链接：http://www.jianshu.com/p/77ee7c0270bc

读者有没发觉我写文章时，喜欢有个前言、序？真相是，一半用来装逼凑字数，一半是因为不知道接下来要写什么，先闲聊几句压压惊^_^ 哈哈哈......该说的还是要说。

上一篇《Android单元测试 - Sqlite、SharedPreference、Assets、文件操作 怎么测？》 讲了一些DAO（Data Access Object）单元测试的细节。本篇讲解参数验证。

验证参数传递、函数返回值，是单元测试中十分重要的环节。笔者相信不少读者都有验证过参数，但是你的单元测试代码真的是正确的吗？笔者在早期实践的时候，遇到一些问题，积累了一点心得，本期与大家分享一下。

Bean

public class Bean {
    int    id;
    String name;

    public Bean(int id, String name) {
        this.id = id;
        this.name = name;
    }
    // getter and setter
    ......
}

DAO

public class DAO {
    public Bean get(int id) {
        return new Bean(id, "bean_" + id);
    }
}

Presenter

public class Presenter {

    DAO dao;

    public Presenter(DAO dao) {
        this.dao = dao;
    }

    public Bean getBean(int id) {
        Bean bean = dao.get(id);

        return bean;
    }
}

单元测试PresenterTest（下文称为“例子1”）

public class PresenterTest {

    DAO       dao;
    Presenter presenter;

    @Before
    public void setUp() throws Exception {
        dao = mock(DAO.class);
        presenter = new Presenter(dao);
    }

    @Test
    public void testGetBean() throws Exception {
        Bean bean = new Bean(1, "bean_1");

        when(dao.get(1)).thenReturn(bean);

        Bean result = presenter.getBean(1);

        Assert.assertEquals(result.getId(), 1);
        Assert.assertEquals(result.getName(), "bean_1");
    }
}

这个单元测试是通过的。

上面的Bean只有2个参数，但实际项目，对象往往有很多很多参数，例如，用户信息User ：

public class User {
    int    id;
    String name;

    String country;
    String province;
    String city;
    String address;
    int    zipCode;

    long birthday;

    double height;
    double weigth;

    ...
}

单元测试：

    @Test
    public void testUser() throws Exception {
        User user = new User(1, "bean_1");
        user.setCountry("中国");
        user.setProvince("广东");
        user.setCity("广州");
        user.setAddress("天河区临江大道海心沙公园");
        user.setZipCode(510000);
        user.setBirthday(631123200);
        user.setHeight(173);
        user.setWeigth(55);
        user.setXX(...);

        .....

        User result = presenter.getUser(1);

        Assert.assertEquals(result.getId(), 1);
        Assert.assertEquals(result.getName(), "bean_1");
        Assert.assertEquals(result.getCountry(), "中国");
        Assert.assertEquals(result.getProvince(), "广东");
        Assert.assertEquals(result.getCity(), "广州");
        Assert.assertEquals(result.getAddress(), "天河区临江大道海心沙公园");
        Assert.assertEquals(result.getZipCode(), 510000);
        Assert.assertEquals(result.getBirthday(), 631123200);
        Assert.assertEquals(result.getHeight(), 173);
        Assert.assertEquals(result.getWeigth(), 55);
        Assert.assertEquals(result.getXX(), ...);
        ......
    }

一般形式的单元测试，有10个参数，就要set()10次，get()10次，如果参数更多，一个工程有几十上百个这种测试......感受到那种蛋蛋的痛了吗？

这里有两个痛点：

1.生成对象必须 调用所有setter() 赋值成员变量
2.验证返回值，或者回调参数时，必须 调用所有getter() 获取成员值

这时同学A举手了：“不就是比较对象吗，用equal()还不行？”

为了演示方便，还是用回Bean做例子：

    @Test
    public void testGetBean() throws Exception {
        Bean bean = new Bean(1, "bean_1");

        when(dao.get(1)).thenReturn(bean);

        Bean result = presenter.getBean(1);

        Assert.assertTrue(result.equals(bean));
    }

运行一下：

诶，还真通过了！第一个问题解决了，鼓掌..... 稍等，我们把Presenter代码改改，看还能不能凑效：

public class Presenter {

    public Bean getBean(int id) {
        Bean bean = dao.get(id);

        return new Bean(bean.getId(), bean.getName());
    }
}

再运行单元测试：

果然出错了！

我们分析一下问题，修改前的Presenter.getBean()方法， dao.get()得到的Bean对象，直接作为返回值，所以PresenterTest中Assert.assertTrue(result.equals(bean));通过测试，因为bean和result是同一个对象；修改后，Presenter.getBean()里，返回值是dao.get()得到的Bean的深拷贝，bean和result是不同对象，因此result.equals(bean)==false，测试失败。如果我们使用一般形式Assert.assertEquals(result.getXX(), ...);，单元测试是通过的。

无论是直接返回对象，深拷贝，只要参数一致，都符合我们期望的结果。所以，仅仅调用equals()解决不了问题。

同学B：“既然只是比较成员值，重写equals()！”

 public class Bean {
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Bean) {
            Bean bean = (Bean) obj;

            boolean isEquals = false;

            if (isEquals) {
                isEquals = id == bean.getId();
            }

            if (isEquals) {
                isEquals = (name == null && bean.getName() == null) || (name != null && name.equals(bean.getName()));
            }

            return isEquals;
        }

        return false;
    }
}

再次运行单元测试Assert.assertTrue(result.equals(bean));：

稍等，这样我们不是回到老路，每个java bean都要重写equals()吗？尽管整个工程下来，总体代码会减少，但这真不是好办法。

同学C：“我们可以用反射获取两个对象所有成员值，并逐一对比。”

哈哈哈，同学C比同学A、B都要聪明点，还会反射！

public class PresenterTest{
    @Test
    public void testGetBean() throws Exception {
        ...
        ObjectHelper.assertEquals(bean, result);
    }
}

public class ObjectHelper {

    public static boolean assertEquals(Object expect, Object actual) throws IllegalAccessException {
        if (expect == actual) {
            return true;
        }

        if (expect == null && actual != null || expect != null && actual == null) {
            return false;
        }

        if (expect != null) {
            Class clazz = expect.getClass();

            while (!(clazz.equals(Object.class))) {
                Field[] fields = clazz.getDeclaredFields();

                for (Field field : fields) {
                    field.setAccessible(true);

                    Object value0 = field.get(expect);
                    Object value1 = field.get(actual);

                    Assert.assertEquals(value0, value1);
                }

                clazz = clazz.getSuperclass();
            }
        }

        return true;
    }
}

运行单元测试，通过！

用反射直接对比成员值，思路是正确的。这里解决了“对比两个对象的成员值是否相同，不需要get()n次”问题。不过，仅仅比较两个对象，这个单元测试还是有问题的。我们先讲第4节，这个问题留在第5节给大家说明。

在testUser()中，第一个痛点：“生成对象必须 调用所有setter() 赋值成员变量”。 上一节同学C用反射方案，把对象成员值拿出来，逐一比较。这个方案提醒了我们，赋值也可以同样方案。

ObjectHelper:

public class ObjectHelper {

    protected static final List numberTypes = Arrays.asList(int.class, long.class, double.class, float.class, boolean.class);

    public static  T random(Class clazz) throws IllegalAccessException, InstantiationException {
        try {
            T obj = newInstance(clazz);

            Class tClass = clazz;

            while (!tClass.equals(Object.class)) {

                Field[] fields = tClass.getDeclaredFields();

                for (Field field : fields) {
                    field.setAccessible(true);

                    Class type      = field.getType();
                    int   modifiers = field.getModifiers();

                    // final 不赋值
                    if (Modifier.isFinal(modifiers)) {
                        continue;
                    }

                    // 随机生成值
                    if (type.equals(Integer.class) || type.equals(int.class)) {
                        field.set(obj, new Random().nextInt(9999));
                    } else if (type.equals(Long.class) || type.equals(long.class)) {
                        field.set(obj, new Random().nextLong());
                    } else if (type.equals(Double.class) || type.equals(double.class)) {
                        field.set(obj, new Random().nextDouble());
                    } else if (type.equals(Float.class) || type.equals(float.class)) {
                        field.set(obj, new Random().nextFloat());
                    } else if (type.equals(Boolean.class) || type.equals(boolean.class)) {
                        field.set(obj, new Random().nextBoolean());
                    } else if (CharSequence.class.isAssignableFrom(type)) {
                        String name = field.getName();
                        field.set(obj, name + "_" + (int) (Math.random() * 1000));
                    }
                }
                tClass = tClass.getSuperclass();
            }
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    protected static  T newInstance(Class clazz) throws IllegalAccessException, InvocationTargetException, InstantiationException {

        Constructor constructor = clazz.getConstructors()[0];// 构造函数可能是多参数

        Class[] types = constructor.getParameterTypes();

        List