[嵌入式TDD实战]TDD开发AT26DF驱动模块(三)：第一个测试用例

待我称王封你为后i 2022-11-30 01:34 235阅读 0赞

### 文章目录 ###

*  前言
 *  第一个接口
 *   *  函数签名
     *  开写测试用例
     *  本章快照
     *   *  AT26DFTest.c
         *  AT26DFTestRunner.c
         *  AT26DF.h
         *  AT26DF.c
 *  结语

# 前言 #

[上一章][Link 1]中，我们把模块的通信监控框架搭起来了。万事俱备，直接开始开发吧。

# 第一个接口 #

## 函数签名 ##

我们来看看AT26DF的第一条命令：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbl9zdHJvbmc_size_16_color_FFFFFF_t_70_pic_center][]  
嗯，Read Array，那第一个接口的名字就叫AT26DF\_readArray了。

*  这个方法在CS断言后，先要求一个操作符，0B比03的好处是没有频率限制，那感情好。先写0B那个。
 *  然后需要一个24bit的地址，那接口的参数中加一个地址参数。
 *  因为选择了0B，还需要多传一个随便什么字符
 *  然后就可以从这个地址起想读几个字符读几个了，那说明还要一个指定读多少字节的参数，以及一个告知把返回结果写到哪的参数
 *  最后通过CS取消断言来结束

那这个接口的签名就基本确定了：

……
    typedef uint32_t AT26DF_ADDR;
    ……
    void AT26DF_readArray(AT26DF_ADDR addr, uint8_t *buf, uint16_t len);

虽然用了32位的int表示了实际只需要24位的地址，但没事，只取低24位就好，主要比byte\[3\]用起来方便的多。  
重新定义下类型后这个参数做什么用的也一目了然。完美！

## 开写测试用例 ##

那我们接下来为他写测试用例，先把监听搭好，随便给几个参数(这里已经不需要那个NULL测试了，删掉吧)：  
AT26DFTest.c

#include "unity_fixture.h"
    #include "AT26DF.h"
    #include "MockSPI.h"
    
    TEST_GROUP(AT26DF);
    TEST_SETUP(AT26DF){
        
    }
    
    TEST_TEAR_DOWN(AT26DF){
        
    }
    
    TEST(AT26DF, ReadArray){
        
      MockSPI_Init();
      AT26DF_regFuncSPI(SPI_readByte,SPI_writeByte);
      AT26DF_regFuncCS(SPI_SelectCS,SPI_DeselectCS);
    
      AT26DF_readArray(0x345254, actualData, 5);
    
      MockSPI_Verify();
      MockSPI_Destroy();
    }

生成试试。  
![2020082217322149.png_pic_center][]  
咦，报错了，哦，光写了声明，没写实现。我们打开AT26DF.c文件，直接写个空函数先，TDD的基本原则就是没有写测试前不要写代码。

AT26DF.c

……
    void AT26DF_readArray(AT26DF_ADDR addr, uint8_t *buf, uint16_t len){
        
    }

再次生成。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbl9zdHJvbmc_size_16_color_FFFFFF_t_70_pic_center 1][]  
编译成功了，但这数量咋不对呢。哦，新测试忘记安装进Runner了。

AT26DFTestRunner.c

#include "unity_fixture.h"
    
    TEST_GROUP_RUNNER(AT26DF)
    {
        
      RUN_TEST_CASE(AT26DF, ReadArray)
    }

再生成。  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbl9zdHJvbmc_size_16_color_FFFFFF_t_70_pic_center 2][]  
数量对了。

然后往测试用例里头填内容。

首先应该要先断言：

……
      AT26DF_regFuncCS(SPI_SelectCS,SPI_DeselectCS);
      SPI_SelectCS_Expect();
    
      AT26DF_readArray(0x345254, actualData, 5);
      ……

生成：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbl9zdHJvbmc_size_16_color_FFFFFF_t_70_pic_center 3][]  
果然出问题了，赶快回去在实现中加上这一句。

void AT26DF_readArray(AT26DF_ADDR addr, uint8_t *buf, uint16_t len){
        
      _csSel();
    }

生成，通过！

好嘞，然后，首先应该传一个操作符0x0B

……
      AT26DF_regFuncCS(SPI_SelectCS,SPI_DeselectCS);
      SPI_SelectCS_Expect();
      SPI_writeByte_Expect(0x0B);
    
      AT26DF_readArray(0x345254, actualData, 5);
    ……

再测试，又失败了  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbl9zdHJvbmc_size_16_color_FFFFFF_t_70_pic_center 4][]  
嗯，要回去加上写操作符了，但是为了让你明白mock真能测出你没按希望的参数调用，我们故意失误，打错了输出的错误码：

void AT26DF_readArray(AT26DF_ADDR addr, uint8_t *buf, uint16_t len){
        
      _csSel();
      _spiWrite(0x03);
    }

这时来看看测试输出：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbl9zdHJvbmc_size_16_color_FFFFFF_t_70_pic_center 5][]  
输出中准确地说明了测试用例失败的原因。

好啦，去改成正确的吧。

这时，我又觉得0x0B很不直观，这是个magic number，可读性差。所以我又改了改，给了它个名字，让它别那么magic了。

AT26DF.h

#ifndef _AT26DF_H
    #define _AT26DF_H
    #include <stdint.h>
    
    #define AT26DF_OPC_READARRAY   0x0B
    
    typedef uint32_t AT26DF_ADDR;
    ……

AT26DF.c

void AT26DF_readArray(AT26DF_ADDR addr, uint8_t *buf, uint16_t len){
        
      _csSel();
      _spiWrite(AT26DF_OPC_READARRAY);
    }

AT26DFTest.c

……
      AT26DF_regFuncCS(SPI_SelectCS,SPI_DeselectCS);
      SPI_SelectCS_Expect();
      SPI_writeByte_Expect(AT26DF_OPC_READARRAY);
    
      AT26DF_readArray(0x345254, actualData, 5);
    ……

这样，以后的操作码我也都会用宏定义的方式给它个**AT26DF\_OPC\_XXXX**形式的名字。在测试用例和接口实现中都用名字的坏处是如果定义错了，你难以发现。但是没事，在硬件测试中会发现的。为了可读性还是值得的。

接下来，地址，传过去的是0x345254，那也应该收到对应的：

……
      SPI_writeByte_Expect(AT26DF_OPC_READARRAY);
      // address byte
      SPI_writeByte_Expect(0x34);
      SPI_writeByte_Expect(0x52);
      SPI_writeByte_Expect(0x54);
    
      AT26DF_readArray(0x345254, actualData, 5);
    ……

测试，失败，然后修改实现：

void AT26DF_readArray(AT26DF_ADDR addr, uint8_t *buf, uint16_t len){
        
      _csSel();
      _spiWrite(AT26DF_OPC_READARRAY);
      _spiWrite((addr >> 16) & 0xFF);
      _spiWrite((addr >> 8) & 0xFF);
      _spiWrite(addr & 0xFF);
    }

测试通过。

然后应该写一个无所谓什么字节，CMock中是这么写的

SPI_writeByte_Expect(0x54);
      // one don't care byte
      SPI_writeByte_Expect(0xab);
      SPI_writeByte_IgnoreArg_b();
    
      AT26DF_readArray(0x345254, actualData, 5);

SPI\_writeByte\_IgnoreArg\_b使得上一个SPI\_writeByte\_Expect忽视参数b。  
这里又有magic number的问题了，为了让后人看到这个0xab不感到困惑，咱们略作修改。

……
    TEST_GROUP(AT26DF);
    static const uint8_t anyByte = 0xEE;
    TEST_SETUP(AT26DF){
        
    }
    ……
      SPI_writeByte_Expect(0x54);
      // one don't care byte
      SPI_writeByte_Expect(anyByte);
      SPI_writeByte_IgnoreArg_b();
    
      AT26DF_readArray(0x345254, actualData, 5);

然后又是，测试，失败，然后改造实现：

……
    #define DONTCAREBYTE   0x37
    ……
    void AT26DF_readArray(AT26DF_ADDR addr, uint8_t *buf, uint16_t len){
        
      _csSel();
      _spiWrite(AT26DF_OPC_READARRAY);
      _spiWrite((addr >> 16) & 0xFF);
      _spiWrite((addr >> 8) & 0xFF);
      _spiWrite(addr & 0xFF);
    
      _spiWrite(DONTCAREBYTE);
    }

好了，这个没用的字符发出去后就该开始读取数据了。  
读取多少个是由len参数决定的，而返回的应该就是SPI\_Read给他的，换句话说就是咱们的接口应该调用len次SPI\_read然后把结果写到buf指向的数组中。  
所以测试用例变成了这样：

TEST(AT26DF, ReadArray){
        
      int i;
      const uint8_t expectData[] = {
        0x12, 0x34, 0x56, 0x78, 0x9a};
      uint8_t actualData[sizeof(expectData)];
      const uint8_t len = sizeof(expectData);
      MockSPI_Init();
      AT26DF_regFuncSPI(SPI_readByte,SPI_writeByte);
      AT26DF_regFuncCS(SPI_SelectCS,SPI_DeselectCS);
      SPI_SelectCS_Expect();
      SPI_writeByte_Expect(AT26DF_OPC_READARRAY);
      // address byte
      SPI_writeByte_Expect(0x34);
      SPI_writeByte_Expect(0x52);
      SPI_writeByte_Expect(0x54);
      // one don't care byte
      SPI_writeByte_Expect(anyByte);
      SPI_writeByte_IgnoreArg_b();
      for(i = 0; i < len; i++){
        
        SPI_readByte_ExpectAndReturn(expectData[i]);
      }
    
      AT26DF_readArray(0x345254,actualData,len);
    
      TEST_ASSERT_EQUAL_HEX8_ARRAY(expectData,actualData,len);
      MockSPI_Verify();
      MockSPI_Destroy();
    }

我们要验证了接口调用了N次的read，同时真的把结果返回来了。

测试，失败，然后改造实现：

测试通过，OK。最后别漏了个取消断言：

……
      for(i = 0; i < sizeof(expectData); i++){
        
        SPI_readByte_ExpectAndReturn(expectData[i]);
      }
      SPI_DeselectCS_Expect();
    
      AT26DF_readArray(0x345254,actualData,sizeof(expectData));
    ……

然后接口实现就成了这样：

这样，我们的第一个测试用例其实就写完了。

我们回头再看看写好的测试用例，

MockSPI_Init();
      AT26DF_regFuncSPI(SPI_readByte,SPI_writeByte);
      AT26DF_regFuncCS(SPI_SelectCS,SPI_DeselectCS);

和

MockSPI_Verify();
      MockSPI_Destroy();

其实是这个模块的所有测试通用的Setup和teardown部分，所以，我们再进行修改，把这两部分分别移到：TEST\_SETUP和TEST\_TEAR\_DOWN里，这样，在所有这个测试组的测试用例开始前都会初始化MockSPI并注册，结束时都会验证MockSPI并回收资源。于是，到目前为止，我们的几个文件长这样：

## 本章快照 ##

### AT26DFTest.c ###

#include "unity_fixture.h"
    #include "AT26DF.h"
    #include "MockSPI.h"
    
    TEST_GROUP(AT26DF);
    static const uint8_t anyByte = 0xEE;
    TEST_SETUP(AT26DF){
        
      MockSPI_Init();
      AT26DF_regFuncSPI(SPI_readByte,SPI_writeByte);
      AT26DF_regFuncCS(SPI_SelectCS,SPI_DeselectCS);
    }
    
    TEST_TEAR_DOWN(AT26DF){
        
      MockSPI_Verify();
      MockSPI_Destroy();
    }
    
    TEST(AT26DF, ReadArray){
        
      int i;
      const uint8_t expectData[] = {
        0x12, 0x34, 0x56, 0x78, 0x9a};
      uint8_t actualData[sizeof(expectData)];
      const uint8_t len = sizeof(expectData);
      SPI_SelectCS_Expect();
      SPI_writeByte_Expect(AT26DF_OPC_READARRAY);
      // address byte
      SPI_writeByte_Expect(0x34);
      SPI_writeByte_Expect(0x52);
      SPI_writeByte_Expect(0x54);
      // one don't care byte
      SPI_writeByte_Expect(anyByte);
      SPI_writeByte_IgnoreArg_b();
      for(i = 0; i < len; i++){
        
        SPI_readByte_ExpectAndReturn(expectData[i]);
      }
      SPI_DeselectCS_Expect();
    
      AT26DF_readArray(0x345254,actualData,len);
    
      TEST_ASSERT_EQUAL_HEX8_ARRAY(expectData,actualData,len);
    }

### AT26DFTestRunner.c ###

#include "unity_fixture.h"
    
    TEST_GROUP_RUNNER(AT26DF)
    {
        
      RUN_TEST_CASE(AT26DF, ReadArray);
    }

### AT26DF.h ###

#ifndef _AT26DF_H
    #define _AT26DF_H
    #include <stdint.h>
    
    #define AT26DF_OPC_READARRAY   0x0B
    
    typedef uint32_t AT26DF_ADDR;
    
    // description: Register SPI call back functions
    // parameter  : spi_rb   callback function to read byte using SPI
    //              spi_wb   callback function to write byte using SPI
    // return     : 
    // note       : you should register SPI functions through this interface before use the driver.
    void AT26DF_regFuncSPI(uint8_t (*spi_rb)(void), void (*spi_wb)(uint8_t wb));
    // description: Register SPI call back functions
    // parameter  : spi_rb   callback function to burst read byte using SPI
    //                       NULL   if want to use the default function
    //              spi_wb   callback function to burst write byte using SPI
    //                       NULL   if want to use the default function
    // return     : 
    // note       : if you don't register any functions, the default functions will call the functions
    //              registered by the AT26DF_regFuncSPI.
    void AT26DF_regFuncSPIBurst(void (*spi_rb)(uint8_t* pBuf, uint16_t len), 
                                 void (*spi_wb)(const uint8_t* pBuf, uint16_t len));
    // description: Registers call back function for AT26DF select & deselect.
    // parameter  : cs_sel     callback function for WIZCHIP select
    //              cs_desel   callback fucntion for WIZCHIP deselect
    // return     : 
    // note       : you should register CS functions through this interface before use the driver.
    void AT26DF_regFuncCS(void(*cs_sel)(void), void(*cs_desel)(void));
    // description: Sequentially read a continuous stream of data begun from the address specified.
    // parameter  : addr   the starting address
    //              buf    buffer to store the result.
    //              len    the length of data you want to read.
    // return     : 
    // note       : this function can be used at any SCK frequency up to the maximum specified by fSCK.
    void AT26DF_readArray(AT26DF_ADDR addr, uint8_t *buf, uint16_t len);
    
    #endif

### AT26DF.c ###

#include "common.h"
    #include "AT26DF.h"
    #define DONTCAREBYTE   0x37
    
    static uint8_t _spi_rb_default(void);
    static void _spi_wb_default(uint8_t wb);
    static void _spi_burst_rb_default(uint8_t* pBuf, uint16_t len);
    static void _spi_burst_wb_default(const uint8_t* pBuf, uint16_t len);
    static void _nullFunc(void);
    
    static uint8_t (*_spiRead)(void) = _spi_rb_default;
    static void (*_spiWrite)(uint8_t wb) = _spi_wb_default;
    static void (*_spiBurstRead)(uint8_t* pBuf, uint16_t len) = _spi_burst_rb_default;
    static void (*_spiBurstWrite)(const uint8_t* pBuf, uint16_t len) = _spi_burst_wb_default;
    static void(*_csSel)(void) = _nullFunc;
    static void(*_csDesel)(void) = _nullFunc;
    
    static uint8_t _spi_rb_default(void){
        return 0;}
    static void _spi_wb_default(uint8_t wb){
        (void)wb;}
    static void _spi_burst_rb_default(uint8_t* pBuf, uint16_t len){
        
      while(len > 0){
        
        --len;
        *pBuf++ = _spiRead();
      }
    }
    static void _spi_burst_wb_default(const uint8_t* pBuf, uint16_t len){
        
      while(len > 0){
        
        --len;
        _spiWrite(*pBuf++);
      }
    }
    
    static void _nullFunc(void){
        }
    
    
    void AT26DF_regFuncSPI(uint8_t (*spi_rb)(void), void (*spi_wb)(uint8_t wb)){
        
      _spiRead = spi_rb;
      _spiWrite = spi_wb;
    }
    
    void AT26DF_regFuncSPIBurst(void (*spi_rb)(uint8_t* pBuf, uint16_t len), void (*spi_wb)(const uint8_t* pBuf, uint16_t len)){
        
      if(spi_rb)
        _spiBurstRead = spi_rb;
      else
        _spiBurstRead = _spi_burst_rb_default;
      if(spi_wb)
        _spiBurstWrite = spi_wb;
      else
        _spiBurstWrite = _spi_burst_wb_default;
    }
    
    void AT26DF_regFuncCS(void(*cs_sel)(void), void(*cs_desel)(void)){
        
      _csSel = cs_sel;
      _csDesel = cs_desel;
    }
    
    
    void AT26DF_readArray(AT26DF_ADDR addr, uint8_t *buf, uint16_t len){
        
      _csSel();
      _spiWrite(AT26DF_OPC_READARRAY);
      _spiWrite((addr >> 16) & 0xFF);
      _spiWrite((addr >> 8) & 0xFF);
      _spiWrite(addr & 0xFF);
      _spiWrite(DONTCAREBYTE);
      _spiBurstRead(buf,len);
      _csDesel();
    }

# 结语 #

这一章中，我较为详尽的展示了用TDD的方式开发单个接口的各个步骤。不断的重复TDD微循环：

*  添加一个小测试
 *  运行所有测试并故意看到新的那个失败，甚至编译不了。
 *  做很小的修改使得测试通过。
 *  运行所有测试并看到新的一个通过。
 *  重构，移除冗余并提升代码可读性。

测试用例也遵从 四步测试模式：

*  Setup：建立测试的预环境(precondition)
 *  Exercise：做一些事情
 *  Verify：检查输出是否如期望的
 *  Cleanup：在测试后把系统还原为最初状态

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbl9zdHJvbmc_size_16_color_FFFFFF_t_70_pic_center 6][]  
感兴趣的朋友可以读《测试驱动的嵌入式c语言开发》更深入的学习，这是我的[笔记][Link 2]。

后面的章节中，我不再事无巨细的按照一个个测试的小步骤来讲，而可能会更偏向于重构的思想来讲。但是读者要清楚，实际上还是遵从着这章中的模式一点点递增地开发出程序的。

[Link 1]: https://blog.csdn.net/lin_strong/article/details/108167585
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbl9zdHJvbmc_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/27a574ea66de412eb3f93a6060d21864.png
[2020082217322149.png_pic_center]: /images/20221124/bcf1fe5e8dbc458a99f35b410dbee175.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbl9zdHJvbmc_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221124/3030c70c56ac48c8ac88af8fb80e1b56.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbl9zdHJvbmc_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221124/550e051e74c54e67a8dd3888c33eda43.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbl9zdHJvbmc_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221124/b1010b6c9d92492c83277c105e313c08.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbl9zdHJvbmc_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221124/1d5c98a6326440d6a9f762a49c408571.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbl9zdHJvbmc_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221124/49ac990e9294436c8eda8e894d1c9e46.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbl9zdHJvbmc_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221124/980dcb827e8c4390af8662ad78fe3fb7.png
[Link 2]: https://blog.csdn.net/lin_strong/article/details/84853138