UnitTestFramework.h

Go to the documentation of this file.

#if !defined(_UNITTESTFRAMEWORK_H_)
#define _UNITTESTFRAMEWORK_H_
 
#include "Standard.h"
#include "Types.h"
#include "Utils.h"
 
#include <string>
#include <vector>
#include <map>
 
namespace cmlabs {

typedef bool (*UnitTestFunc)();

namespace unittest {

    void progress(int percent, const char* action);
    void progressf(int percent, const char* fmt, ...);

    void metric(const char* name, double value, const char* unit = "", bool higherIsBetter = true);

    void detail(const char* fmt, ...);

    void fail(const char* fmt, ...);

    bool verbose();
 
} // namespace unittest

struct UnitTestMetric {
    std::string name;           
    double      value;          
    std::string unit;           
    bool        higherIsBetter; 
};

struct UnitTestRecord {
    std::string  name;          
    std::string  description;   
    std::string  category;      
    UnitTestFunc func;          
    bool         inDefaultRun;  
 
    // Filled in at run time
    bool         ran;           
    bool         passed;        
    uint64       durationUs;    
    std::string  failReason;    
    std::string  endNote;       
    std::vector<UnitTestMetric> metrics; 

    UnitTestRecord() : func(NULL), inDefaultRun(true), ran(false), passed(false), durationUs(0) {}
};

class UnitTestRunner {
public:
    static UnitTestRunner& instance();

    void registerTest(const char* name, UnitTestFunc func,
                       const char* description = "", const char* category = "",
                       bool inDefaultRun = true);

    void setVerbose(bool v);
    void setCompareFile(const char* path);
    void setOutputFile(const char* path);
    void setOutputDir(const char* dir);
    void setWriteJSON(bool v);
    void setForkPerTest(bool v);

    bool hasTest(const char* name) const;
    std::vector<std::string> testNames() const;
    void listTests() const;

    bool runAll();
    bool runOne(const char* name);

    void hookProgress(int percent, const char* action);
    void hookMetric(const char* name, double value, const char* unit, bool higherIsBetter);
    void hookDetail(const char* text);
    void hookFail(const char* text);
    bool hookVerbose() const;
 
private:
    UnitTestRunner();

    bool runRecords(std::vector<UnitTestRecord*>& records);
    bool executeRecord(UnitTestRecord* rec);
    void beginTest(UnitTestRecord* rec);
    void finishTest(UnitTestRecord* rec);
    void clearProgressLine();
    void printStatusLine(const UnitTestRecord* rec);
    void printMetricLines(const UnitTestRecord* rec);
    void writeResults(const std::vector<UnitTestRecord*>& records,
                      uint64 totalUs, int passed, int failed);
    void loadComparison();
    bool comparisonValue(const std::string& key, double& out) const;
    static std::string timestampForFilename(uint64 t);
 
    std::vector<UnitTestRecord> tests;  
    UnitTestRecord* current;            
 
    bool   verboseFlag;         
    bool   writeJSONFlag;       
    bool   forkPerTest;         
    bool   isTTY;               
    int    lastProgressLen;     
    std::string progressPath;   
 
    std::string compareFile;    
    std::string outputFile;     
    std::string outputDir;      
 
    bool compareLoaded;         
    std::map<std::string, double> compareMetrics; 
 
    utils::Mutex lock;          
};
 
} // namespace cmlabs
 
#endif // _UNITTESTFRAMEWORK_H_