初识TDD（原理+实例）

工作两年多了，一直采用TDD（测试驱动开发），刚开始觉得是反人类的方法论，后来在使用的过程中逐渐发现它的妙处。本文介绍了一些TDD的基本概念，并结合几个小需求进行实践。由于本人能力、精力有限，如有错误或者不当之处，还请各位提出宝贵的建议。

1. TDD原理

TDD流程.png

步骤：

先写测试代码，并执行，得到失败结果
写刚好让测试通过的代码，并通过测试用例
识别坏味道，重构代码，并保证测试通过
反复实行这个步骤，测试失败 -> 测试成功 -> 重构

三原则：

除非是为了使一个失败的用例通过，否则不允许编写任何代码
在一个单元测试中，只允许编写刚好能够导致失败的内容
只允许编写刚好能够使一个失败的用例通过的代码

详细的介绍详见参考文献1和2。

2. TDD实例

话不多说，下面通过一个实际的例子说明。由于最近在看STL，就实现一个简单的Array容器类，此例子可能不太贴切，但大体上是那么个过程。
该例子采用C++语言（为了方便，暂时将代码全部放在.h文件中）和谷歌的gtest测试框架（详见参考文献3）。完整的代码详见参考文献4，已经在Ubuntu 18.04调试通过，如有编译及运行问题，欢迎提出。

2.1 需求一

模仿STL，实现一个数据类型为int的Array类，且能够指定长度，此需求只要求实现其构造和析构函数。
按照TDD的步骤，我们首先写出测试用例（Test.cpp文件）：

#include "IntArray.h"
#include "gtest/gtest.h"struct IntArrayTest : testing::Test
{};TEST_F(IntArrayTest, test_constructor)
{IntArray array{1};ASSERT_EQ(0, array[0]);
}

此时执行代码，编译是失败的。
然后写刚好让测试通过的代码（IntArray.h文件），并通过测试用例：

#ifndef INTARRAY_H_
#define INTARRAY_H_#include <cassert>struct IntArray
{IntArray() = default;IntArray(int len) : len(len){assert(this->len >= 0);if(this->len > 0){this->data = new int[this->len]{0};}}~IntArray(){delete[] this->data;}int& operator [](int idx) const{assert(idx >= 0 and idx < this->len);return this->data[idx];}private:int len;int* data;
};#endif

至此实现了需求一，且代码和用例编译、运行通过。此时代码没有出现明显的坏味道，暂时不需要重构。但是此时有一个比较大的问题，不知各位有没有发现，由于我们的关注点不在此处，暂时不做解释，下文会有说明及修改。

2.2 需求二

实现一个size()方法，该方法返回IntArray的长度；实现一个erase()方法，该方法可以清除IntArray的所有内容。
其实需求二是两个小需求，首先写出测试用例一：

TEST_F(IntArrayTest, test_func_size)
{IntArray array{3};ASSERT_EQ(3, array.size());
}

此时编译失败，再写刚好让测试通过的代码：

int size() const
{return this->len;
}

此时编译运行通过，再写第二个小需求的测试用例：

TEST_F(IntArrayTest, test_func_erase)
{IntArray array{3};ASSERT_EQ(3, array.size());array.erase();ASSERT_EQ(0, array.size());
}

再写刚好让测试通过的第二个小需求的代码：

void erase()
{delete[] this->data;this->data = nullptr;this->len = 0;
}

此时代码也没有出现明显的坏味道，暂时不需要重构。

2.3 需求三

实现一个类似于STL的insert()方法，要求能够实现Array任意位置的插入，包括起始、中间和结束位置。
此处我们先写出在中间位置插入的用例：

TEST_F(IntArrayTest, test_func_insert)
{IntArray array{2};for(int idx = 0; idx < 2; ++idx){array[idx] = idx;}ASSERT_EQ(0, array[0]);ASSERT_EQ(1, array[1]);int value = 3;int index = 1;array.insertBefore(value, index);ASSERT_EQ(3, array.size());ASSERT_EQ(0, array[0]);ASSERT_EQ(3, array[1]);ASSERT_EQ(1, array[2]);
}

再写出刚好能够使此测试用例通过的代码：

void insertBefore(int value, int index)
{assert(index >= 0 and index <= this->len);int* tmpData = new int[this->len + 1]{};for(int before = 0; before < index; ++before){tmpData[before] = this->data[before];} tmpData[index] = value;for(int after = index; after < this->len; ++after){tmpData[after + 1] = this->data[after];}delete[] this->data;this->data = tmpData;++this->len;
}

至此代码没有明显的坏味道，但是用例中出现了较多的ASSERT_EQ形式的重复。我们暂且忍一下，先实现我们其余的需求。
写出在起始位置插入的用例：

TEST_F(IntArrayTest, test_func_insert_at_begining)
{IntArray array{1};for(int idx = 0; idx < 1; ++idx){array[idx] = idx;}ASSERT_EQ(0, array[0]);int value = 3;array.insertAtBegining(value);ASSERT_EQ(2, array.size());ASSERT_EQ(3, array[0]);ASSERT_EQ(0, array[1]);
}

再写出刚好使此用例通过的代码：

void insertAtBegining(int value)
{insertBefore(value, 0);
}

我们可以发现ASSERT_EQ形式的重复在增多，我们选择继续忍（毕竟Copy and Paste多舒服），先实现我们其余的需求。
写出在结束位置插入的用例：

TEST_F(IntArrayTest, test_func_insert_at_end)
{IntArray array{1};for(int idx = 0; idx < 1; ++idx){array[idx] = idx;}ASSERT_EQ(0, array[0]);int value = 3;array.insertAtEnd(value);ASSERT_EQ(2, array.size());ASSERT_EQ(0, array[0]);ASSERT_EQ(3, array[1]);
}

再写出刚好使此用例通过的代码：

void insertAtEnd(int value)
{insertBefore(value, this->len);
}

2.4 代码重构

此时我们再也不能忍了，用例中重复的代码越来越多，代码重复是最严重的坏味道，必须消除。通过分析发现，重复代码无非两种类型，一种是IntArray的初始化，另一种是IntArray的校验。只需要将这些重复的代码提取到Fixture中即可，简单的重构如下：

struct IntArrayTest : testing::Test
{void initIntArr(IntArray& array) const{for(int idx = 0; idx < array.size(); ++idx){array[idx] = idx;}}void assertIntArr(const IntArray& array, const int num) const{ASSERT_EQ(num, array.size());for(int idx = 0; idx < array.size(); ++idx){ASSERT_EQ(array[idx], idx);}}
};

然后选择insert的用例重构如下：

TEST_F(IntArrayTest, test_func_insert)
{IntArray array{2};initIntArr(array);assertIntArr(array, 2);int value = 3;int index = 1;array.insertBefore(value, index);ASSERT_EQ(3, array.size());ASSERT_EQ(0, array[0]);ASSERT_EQ(3, array[1]);ASSERT_EQ(1, array[2]);
}TEST_F(IntArrayTest, test_func_insert_at_begining)
{IntArray array{1};initIntArr(array);assertIntArr(array, 1);int value = 3;array.insertAtBegining(value);ASSERT_EQ(2, array.size());ASSERT_EQ(3, array[0]);ASSERT_EQ(0, array[1]);
}TEST_F(IntArrayTest, test_func_insert_at_end)
{IntArray array{1};initIntArr(array);assertIntArr(array, 1);int value = 3;array.insertAtEnd(value);ASSERT_EQ(2, array.size());ASSERT_EQ(0, array[0]);ASSERT_EQ(3, array[1]);
}

此处的重构可能并不完美，但是重点是告诉大家要识别代码中的坏味道，并且主动去重构消除。

2.5 需求四

实现一个remove()方法，可以删除指定索引的元素。
相同的套路，首先写出用例：

TEST_F(IntArrayTest, test_func_remove)
{IntArray array{2};initIntArr(array);assertIntArr(array, 2);int index = 1;array.remove(index);ASSERT_EQ(1, array.size());ASSERT_EQ(0, array[0]);
}

相同的套路，再写出刚好能够使此测试用例通过的代码：

void remove(int index)
{assert(index >= 0 and index < this->len);if(this->len == 1){erase();       return ;}int* tmpData = new int[this->len]{};for(int before = 0; before < index; ++before){tmpData[before] = this->data[before];} for(int after = index + 1; after < this->len; ++after){tmpData[after - 1] = this->data[after];}delete[] this->data;this->data = tmpData;--this->len;
}

2.6 代码重构

此时我们可以发现在代码中出现了明显的重复，即insertBefore()函数和最新的remove()函数，最简单直接的方法是提取公共部分，如下：

...
struct IntArray
{void insertBefore(int value, int index){assert(index >= 0 and index <= this->len);int* tmpData = new int[this->len + 1]{};copyBeforeData(tmpData, index);tmpData[index] = value;for(int after = index; after < this->len; ++after){tmpData[after + 1] = this->data[after];}delete[] this->data;this->data = tmpData;++this->len;}void remove(int index){assert(index >= 0 and index < this->len);if(this->len == 1){erase();       return ;}int* tmpData = new int[this->len]{};copyBeforeData(tmpData, index);for(int after = index + 1; after < this->len; ++after){tmpData[after - 1] = this->data[after];}delete[] this->data;this->data = tmpData;--this->len;}private:void copyBeforeData(int* tmpData, const int index) const{for(int before = 0; before < index; ++before){tmpData[before] = this->data[before];}}
};
...

2.7 需求五

实现一个reallocate()函数，可以改变IntArray的size()，并且清空原有的元素。再实现一个resize()函数，可以改变IntArray的size()，但是保留原有的元素。
套路相同，对于此需求不再赘述，详见参考文献4。

2.8 需求六

将数据类型由int修改为double，实现上述的所有功能。
此时我们需要再重写一遍吗？当然不用。借助C++的泛型编码（模板机制，其实所有的STL都是采用模板实现，这样可以将数据和算法解耦；泛型编码和面向对象是C++重要的两个分支，只是它们考虑问题的方向不同）可以快速实现，详见参考文献4。

2.9 代码review

此时我们反观整体代码，有没有发现一些问题？提醒一下，内存方面的，其实内存管理一直是C++比较让人头痛的问题。是的，代码中有指针，若不实现显示的拷贝和赋值构造函数，会有浅拷贝的问题。具体详见参考文献5。

浅拷贝
浅拷贝只是对指针的拷贝，拷贝后两个指针指向同一块内存空间。当多个对象共用同一块内存资源时，若同一块资源释放多次，会发生崩溃或者内存泄漏。
深拷贝
深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针。

最终实现的拷贝和赋值构造函数如下：

template<typename T>
struct Array
{Array(const Array& array){this->len = array.size();setData(array);}Array& operator=(const Array& array){if(this == &array){return *this;}delete[] this->data;this->len = array.size();setData(array);return *this;}private:void setData(const Array& array){if(array.size() > 0){this->data = new T[array.size()]{};for(int idx = 0; idx < array.size(); ++idx){this->data[idx] = array[idx];}}}
};

3. 总结

TDD只是一种实现方法，在某些场景下比较好用，在现实中我们要合理利用，没必要完完全全按照TDD的要求来做。
个人理解TDD算是敏捷开发的一种很好的实现方式，它的整体步骤如下：

先分解任务，分离关注点，实例化需求
写测试，只关注需求、程序的输入输出，不关心中间过程
写实现，不考虑别的需求，用最简单的方式实现当前这个小需求
手动测试一下，基本没什么问题，有问题再修复
重构，用手法消除代码里的坏味道
重复以上的步骤2, 3, 4和5
代码整洁且用例齐全，信心满满地提交

它有以下的优点：

提前澄清需求，明晰需求中的各种细节
小步快走，有问题能够及时修复
一个测试用例只关注一个点，降低开发者的负担
从整体来看，可以明显提升开发的效率

4. 参考文献

tdd（测试驱动开发）的概述, https://blog.csdn.net/abchywabc/article/details/91351044
深度解读 - TDD（测试驱动开发）, https://www.jianshu.com/p/62f16cd4fef3
gtest的介绍和使用, https://blog.csdn.net/linhai1028/article/details/81675724
https://github.com/mzh19940817/ArrayClass
C++中深复制和浅复制(深拷贝和浅拷贝), https://zhangkaifang.blog.csdn.net/article/details/107865997

本文结合实例分享了TDD，文中可能有些许不当及错误之处，代码也没有用做到尽善尽美，欢迎大家批评指正，同时也欢迎大家评论、转载（请注明源出处），谢谢！