UnitTest.h

Go to the documentation of this file.

#ifndef included_AMP_AMPUnitTest
#define included_AMP_AMPUnitTest
 
#include "AMP/utils/UtilityMacros.h"
 
#include <stdarg.h>
#include <string>
#include <vector>
 
 
namespace AMP {
 
 
class UnitTest final
{
public:
    UnitTest() = default;
 
    ~UnitTest();
 
    // Copy constructor
    UnitTest( const UnitTest & ) = delete;
 
    // Assignment operator
    UnitTest &operator=( const UnitTest & ) = delete;
 
    void passes( std::string in );
 
    void failure( std::string in );
 
    void expected_failure( std::string in );
 
    void pass_fail( bool pass, std::string in );
 
    inline size_t NumPassLocal() const { return d_pass.size(); }
 
    inline size_t NumFailLocal() const { return d_fail.size(); }
 
    inline size_t NumExpectedFailLocal() const { return d_expected.size(); }
 
    size_t NumPassGlobal() const;
 
    size_t NumFailGlobal() const;
 
    size_t NumExpectedFailGlobal() const;
 
    inline const auto &getPass() const { return d_pass; }
 
    inline const auto &getFail() const { return d_fail; }
 
    inline const auto &getExpected() const { return d_expected; }
 
    void report( const int level = 1, bool removeDuplicates = true ) const;
 
    void reset();
 
 
public: // printf like interfaces
    inline void passes( const char *format, ... )
    {
        va_list ap;
        va_start( ap, format );
        char tmp[4096];
        int n = vsnprintf( tmp, sizeof tmp, format, ap );
        va_end( ap );
        AMP_INSIST( n >= 0, "Error using stringf: encoding error" );
        AMP_INSIST( n < (int) sizeof tmp, "Error using stringf: internal buffer size" );
        passes( std::string( tmp ) );
    }
 
    inline void failure( const char *format, ... )
    {
        va_list ap;
        va_start( ap, format );
        char tmp[4096];
        int n = vsnprintf( tmp, sizeof tmp, format, ap );
        va_end( ap );
        AMP_INSIST( n >= 0, "Error using stringf: encoding error" );
        AMP_INSIST( n < (int) sizeof tmp, "Error using stringf: internal buffer size" );
        failure( std::string( tmp ) );
    }
 
    inline void expected_failure( const char *format, ... )
    {
        va_list ap;
        va_start( ap, format );
        char tmp[4096];
        int n = vsnprintf( tmp, sizeof tmp, format, ap );
        va_end( ap );
        AMP_INSIST( n >= 0, "Error using stringf: encoding error" );
        AMP_INSIST( n < (int) sizeof tmp, "Error using stringf: internal buffer size" );
        expected_failure( std::string( tmp ) );
    }
 
    inline void pass_fail( bool pass, const char *format, ... )
    {
        va_list ap;
        va_start( ap, format );
        char tmp[4096];
        int n = vsnprintf( tmp, sizeof tmp, format, ap );
        va_end( ap );
        AMP_INSIST( n >= 0, "Error using stringf: encoding error" );
        AMP_INSIST( n < (int) sizeof tmp, "Error using stringf: internal buffer size" );
        pass_fail( pass, std::string( tmp ) );
    }
 
 
private:
    std::vector<std::string> d_pass;
    std::vector<std::string> d_fail;
    std::vector<std::string> d_expected;
};
 
 
} // namespace AMP
 
#endif