《编写可读代码的艺术》第14章 测试与可读性

1. 使测试易于阅读和维护

    测试代码的可读性和被测试代码同样重要。很多程序员会把测试代码看做非正式文档，它记录了代码如何工作及如何使用。

    当测试代码多得让人望而却步，程序员不敢修改真实代码，不会再增加新的测试。从而对测试代码丧失信心。

2. 有问题的测试代码示例，后面要一一对它们进行修改。

void Test1() {
    vector<ScoredDocument> docs;
    docs.resize(5);
    docs[0].url = "http://example.com";
    docs[0].score = -5.0;
    docs[1].url = "http://example.com";
    docs[1].score = 1;
    docs[2].url = "http://example.com";
    docs[2].score = 4;
    docs[3].url = "http://example.com";
    docs[3].score = -99998.7;
    docs[4].url = "http://example.com";
    docs[4].score = 3.0;

    SortAndFilterDocs(&docs);
    
    assert(docs.size() == 3);
    assert(docs[0].score == 4);
    assert(docs[1].score == 3.0);
    assert(docs[2].score == 1);
}

  3. 使这个测试更可读

    对使用者隐去不重要的细节，以便更重要的细节能突出。这样测试代码变得紧凑一点了。

void MakeScoredDoc(ScoredDocument* sd, double score, string url) {
    sd->score = score;
    sd->url = url;
}

void Test1() {
    vector<ScoredDocument> docs;
    docs.resize(5);
    MakeScoredDoc(&docs[0], -5.0, "http://example.com");
    MakeScoredDoc(&docs[1], 1, "http://example.com");
    MakeScoredDoc(&docs[2], 4, "http://example.com");
    MakeScoredDoc(&docs[3], -99998.7, "http://example.com");
    ...
}

    进一步隐藏细节

void AddScoredDoc(vector<ScoredDocument>& docs, double score) {
    ScoredDocument sd;
    sd.score = score;
    sd.url = "http://example.com";
    docs.push_back(sd);
}

void Test1() {
    vector<ScoredDocument> docs;
    AddScoredDoc(docs, -5.0);
    AddScoredDoc(docs, 1);
    AddScoredDoc(docs, 4);
    AddScoredDoc(docs, -99998.7);
    ...
}

4. 创建最小的测试声明

    CheckScoresBeforeAfter("-5, 1, 4, -99998.7, 3", "4, 3, 1");

    我们可以把测试的基本内容精简为一行代码来描述，即对于给定的输入，期望的输出是什么。

5. 实现定制的“微语言”

    在较新版本的C++中，可以这样传入数组：

    CheckScoresBeforeAfter({-5, 1, 4, -99998.7, 3}, {4, 3, 1});

    然而在之前，需要对字符串进行解析：

vector<ScoredDocument> ScoredDocsFromString(string scores) {
    vector<ScoredDocument> docs;
    replace(scores.begin(), scores.end(), ',', ' ');
    // Populate 'docs' from a string of space-separated scores.
    istringstream stream(scores);
    double score;
    while (stream >> score) {
        AddScoredDoc(docs, score);
    }
    return docs;
}

string ScoredDocsToString(vector<ScoredDocument> docs) {
    ostringstream stream;
    for (int i = 0; i < docs.size(); i++) {
        if (i > 0) {
            stream << ", ";
            stream << docs[i].score;
        }
    }
    return stream.str();
}

void CheckScoresBeforeAfter(string input, string expected_output) {
    vector<ScoredDocument> docs = ScoredDocsFromString(input);
    SortAndFilterDocs(&docs);
    string output = ScoredDocsToString(docs);
    assert(output == expected_output);
}

    乍一看有很多的代码，但是实际代码的能力更强了，你可以只调用。

    CheckScoresBeforeAfter一次就写出了整个测试，你将倾向于增加更多的测试代码。

6. 让错误消息具有可读性

 　assert(output == expected_output);

    Assertion failed: (output == expected_output),

　　　function CheckScoresBeforeAfter, file test.cc, line 37.

    大部分语言都有高级版本的assert()可用。

    BOOST_REQUIRE_EQUAL(output, expected_output)

　　test.cc(37): fatal error in "CheckScoresBeforeAfter": critical check
　　　　output == expected_output failed ["1, 3, 4" != "4, 3, 1"]

   手工打造错误消息。理想的错误消息可以像这样：

　　CheckScoresBeforeAfter() failed,
　　　　Input:
　　　　"-5, 1, 4, -99998.7, 3"
　　　　Expected Output: "4, 3, 1"
　　　　Actual Output: "1, 3, 4"

void CheckScoresBeforeAfter(...) {
    //...
    if (output != expected_output) {
        cerr << "CheckScoresBeforeAfter() failed," << endl;
        cerr << "Input:
        "" << input << """ << endl;
        cerr << "Expected Output: "" << expected_output << """ << endl;
        cerr << "Actual Output: "" << output << """ << endl;
        abort();
    }
}

7. 选择好的测试输入

    应当选择一组最简单的输入，它能完整地使用被测代码。

CheckScoresBeforeAfter("1, 2, 3", "3, 2, 1"); //未测试负分的情况
CheckScoresBeforeAfter("123014, -1082342, 823423, 234205, -235235",
    "823423, 234205, 123014"); // 无必要的复杂

     简化输入值

CheckScoresBeforeAfter("-5, 1, 4, -99998.7, 3", "4, 3, 1");

// -99998.7, 3只是想表示很大的负数，用-1e100这样的值更好
// 实际上只需要一个负数来测试负数会被移除就可以了：
CheckScoresBeforeAfter("1, 2, -1, 3", "3, 2, 1");

//你可能会想包含这样一个测试，
//大型输入在发现bug方面很有用，但是这样的代码大多看上去很吓人，效果却不好
CheckScoresBeforeAfter("100, 38, 19, -25, 4, 84, [lots of values] ...",
    "100, 99, 98, 97, 96, 95, 94, 93, ...");
// 用编程的方法来生成大型输入（如100000个值）会有更好的效果。

    一个功能的多个小测试，更容易、更高效且更有可读性

    SortAndFilterDocs()的四个测试： 

CheckScoresBeforeAfter("2, 1, 3", "3, 2, 1");   //Basic sorting
CheckScoresBeforeAfter("0, -0.1, -10", "0");    // All values < 0 removed
CheckScoresBeforeAfter("1, -2, 1, -2", "1, 1"); //Duplicates not a problem
CheckScoresBeforeAfter("","");                  //Empty input O

 8. 为测试函数命名

    不要用Test1()这样的名字，可以用Test_<FunctionName>()这样的格式：

    void Test_SortAndFilterDocs()

    或者Test_<FunctionName>_<Situation>()这样的格式：

    void Test_SortAndFilterDocs_BasicSorting()
    void Test_SortAndFilterDocs_NegativeValues()

    在你的整个代码库中不会调用这些函数，因此避免使用长函数名的情形在这里不适用

9. 对测试较好的开发方式

    对测试友好的东西往往自然地产生有良好组织的代码。

    尽量避免：1. 使用全局变量；2. 对外部组件有大量依赖的代码；3. 代码有不确定的行为。

    应当做到：1. 类中只有很少或者没有内部状态；2. 一个类/函数只做一件事；3. 每个类对别的类的依赖很少（低耦合）；4. 函数的接口简单，定义明确。

    不要走得太远：1. 为了测试，牺牲代码可读性；2. 着迷于100%的测试覆盖率；3. 让测试成为产品开发的阻碍