class DBConnection
{
public:
    class TParams
    {
    public:
        TParams(int size);
        virtual ~TParams();
    private:
        TParams(const TParams& params) {}
        TParams& operator = (const TParams& params) { return *this; }
    public:
        void Add(const char* val, int size);
        void Add(int val);
        void Add(unsigned int val);
        void Add(uint64_t val);
        void Add(short val);
        
        void Free();
        
        int Size() const { return _size; }
        const char * const * Value() const { return value; }
        const int* Length() const { return length; }
        const int* Format() const { return format; }
    public:
        char** value;
        int* length;
        int* format;
    private:
        int _size;
        int _pos;
    };
public:
    DBConnection()
    : conn(NULL)
    {
    }
    virtual ~DBConnection();
public:
    int Connect(const char* info);
    void Disconnect();
    
    int ExecCmd(const char* cmd);
    PGresult* ExecQuery(const char* sql);
    int ExecCmdWithParams(const char* cmd, const TParams& params);
    PGresult* ExecQueryWithParams(const char* sql, const TParams& params);
    int BeginTranscation();
    int EndTranscation();
private:
    PGconn* conn;
};

DBConnection::TParams::TParams(int size)
: _size(size), _pos(0)
{
    value = new char*[_size];
    length = new int[_size];
    format = new int[_size];
}

DBConnection::TParams::~TParams()
{
    Free();
}

void DBConnection::TParams::Free()
{
    if (_size == 0)
    {
        return;
    }
    
    for (int i = 0; i < _size; ++ i)
    {
        if (format[i] == 0)
        {
            delete[] value[i];
        }
        else if (length[i] == sizeof(int) || length[i] == sizeof(unsigned int))
        {
            delete (int*)value[i];
        }
        else if (length[i] == sizeof(uint64_t))
        {
            delete (uint64_t*)value[i];
        }
        else
        {
            delete (short*)value[i];
        }
    }
    
    delete[] value, value = NULL;
    delete[] length, length = NULL;
    delete[] format, format = NULL;
    
    _size = 0;
    
    DEBUG(DEBUG_ANY, "<DBConnection::TParams::Free()>"<< std::endl);
}

void DBConnection::TParams::Add(const char* val, int size)
{
    char* char_val = new char[size + 1];
    char_val[size] = '\0';
//    char* char_val = new char[size];
    memcpy(char_val, val, size);
    
    value[_pos] = char_val;
    length[_pos] = size + 1;
    format[_pos] = 0;
    
    ++ _pos;
}

void DBConnection::TParams::Add(int val)
{
#ifdef __OS_MAC__
    int* int_val = new (int)(val);
#else
    int* int_val = new (int)(htonl(val));
#endif
    value[_pos] = (char*)(int_val);
    length[_pos] = sizeof(int);
    format[_pos] = 1;
    
    ++ _pos;
}

void DBConnection::TParams::Add(unsigned int val)
{
#ifdef __OS_MAC__
    unsigned int* int_val = new (unsigned int)(val);
#else
    unsigned int* int_val = new (unsigned int)(htonl(val));
#endif

    value[_pos] = (char*)(int_val);
    length[_pos] = sizeof(int);
    format[_pos] = 1;
    
    ++ _pos;
}

void DBConnection::TParams::Add(uint64_t val)
{
#ifdef __OS_MAC__
    uint64_t* uint64_val = new uint64_t(val);
#else
    uint64_t* uint64_val = new uint64_t(htobe64(val));
#endif
    value[_pos] = (char*)(uint64_val);
    length[_pos] = sizeof(uint64_t);
    format[_pos] = 1;
    
    ++ _pos;
}

void DBConnection::TParams::Add(short val)
{
#ifdef __OS_MAC__
    short* int_val = new (short)(val);
#else
    short* int_val = new (short)(htons(val));
#endif
    value[_pos] = (char*)(int_val);
    length[_pos] = sizeof(short);
    format[_pos] = 1;
    
    ++ _pos;
}

////

DBConnection::~DBConnection()
{
    Disconnect();
}

int DBConnection::Connect(const char* info)
{
    conn = PQconnectdb(info);
    if (PQstatus(conn) != CONNECTION_OK)
    {
        DEBUG(DEBUG_ANY, "PQ connection failed.");
        PQfinish(conn);
        return -1;
    }
    
    return 0;
}

void DBConnection::Disconnect()
{
    if (conn != NULL)
    {
        PQfinish(conn);
        conn = NULL;
    }
}

int DBConnection::ExecCmd(const char* cmd)
{
    PGresult* res = PQexec(conn, cmd);
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
    {
        DEBUG(DEBUG_ANY, "<DBConnection::ExecCmd> failed - " << cmd << std::endl);
        DEBUG(DEBUG_ANY, "DBConnection::ExecCmd> error - " << PQerrorMessage(conn) << std::endl);
        PQclear(res);
        return -1;
    }
    //    int ret = ntohl(*PQcmdTuples(res));
    int ret = *PQcmdTuples(res);
    PQclear(res);
    return ret;
}

PGresult* DBConnection::ExecQuery(const char* sql)
{
    PGresult* res = PQexec(conn, sql);
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        DEBUG(DEBUG_ANY, "<DBConnection::ExecQuery> failed - " << sql << std::endl);
        DEBUG(DEBUG_ANY, "DBConnection::ExecQuery> error - " << PQerrorMessage(conn) << std::endl);
        PQclear(res);
        return NULL;
    }
    return res;
}

int DBConnection::ExecCmdWithParams(const char* cmd, const DBConnection::TParams& params)
{
    PGresult* res = PQexecParams(conn, cmd, params.Size(), NULL, params.Value(), params.Length(), params.Format(), 0);
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
    {
        DEBUG(DEBUG_ANY, "<DBConnection::ExecCmdWithParams> failed - " << cmd << std::endl);
        DEBUG(DEBUG_ANY, "DBConnection::ExecCmdWithParams> error - " << PQerrorMessage(conn) << std::endl);
        PQclear(res);
        return -1;
    }
//    int ret = ntohl(*PQcmdTuples(res));
    int ret = *PQcmdTuples(res);
    PQclear(res);
    
    DEBUG(DEBUG_ANY, "<DBConnection::ExecCmdWithParams> succ - " << cmd << std::endl);
    
    return ret;
//    return 0;
}

PGresult* DBConnection::ExecQueryWithParams(const char* sql, const TParams& params)
{
    PGresult* res = PQexecParams(conn, sql, params.Size(), NULL, params.Value(), params.Length(), params.Format(), 0);
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        DEBUG(DEBUG_ANY, "<DBConnection::ExecQueryWithParams> failed - " << sql << std::endl);
        DEBUG(DEBUG_ANY, "DBConnection::ExecQueryWithParams> error - " << PQerrorMessage(conn) << std::endl);
        PQclear(res);
        return NULL;
    }
    return res;
}

int DBConnection::BeginTranscation()
{
    return ExecCmd("BEGIN");
}

int DBConnection::EndTranscation()
{
    return ExecCmd("END");
}

codejie 2015-01-10 00:49 发表评论

Please have a look the following codes, they include two source files (source.h, source.c), one test file (test_source.c) and one makefile file.

//source.h

//source.c

//test_source.c


//makefile

My purpose is that get the UT line coverage report of source files by running the test file. I guess I should get the below report of line coverage, because I have called every functions of source file in test file, include the inline function and the normal function.

But after run test file, I got the report is just 50%, the inline function has not been covered. Why? Why it is not be covered? I am sure it is called in test file.

OK, Calming down. If it is not covered, there are two reason, one is that the inline function is not be called, of course it is impossible, because we did it. So the root cause must be the second one that gcov/lcov tools do not process those lines of inline function. Have any idea? gcov/lcov tools process all files with compilation parameters '-fprofile-arcs -ftest-coverage', so let's check makefile file again.

Look here, source files have the compilation paraments, but why normal function has been coverage, but inline function not?

Thinking again, as we knew, the difference between inline function and normal function is just that inline function will be inserted source code while compiling period. Yes, the answer is here! While compiling, the inline function is put into test file, but the test file has not '-fprofile-arcs -ftest-coverage' paramenter. So, so it was not covered.

To fix it, just add the parameter to test file while compiling. OK, let's update the makefile file like the below line.

Done, enjoy it!

codejie 2012-09-21 17:45 发表评论

codejie 2012-03-30 16:16 发表评论

codejie 2012-01-06 16:53 发表评论

codejie 2012-01-05 11:36 发表评论

codejie 2011-12-29 18:13 发表评论

codejie 2011-07-08 11:23 发表评论

codejie 2011-05-31 23:36 发表评论

codejie 2011-03-19 22:15 发表评论

codejie 2011-02-18 17:48 发表评论

codejie 2011-02-15 23:33 发表评论

codejie 2011-02-01 12:46 发表评论

codejie 2011-01-31 16:37 发表评论

codejie 2011-01-18 17:10 发表评论

codejie 2011-01-07 18:39 发表评论

codejie 2010-12-29 01:10 发表评论

codejie 2010-08-13 15:47 发表评论

codejie 2010-08-04 22:25 发表评论

codejie 2010-08-03 17:13 发表评论

codejie 2010-07-19 20:24 发表评论

#include "nameA.h"
#include "classA.h"

int main()
{
    return 0;
}

codejie 2010-06-11 17:03 发表评论

codejie 2010-06-09 18:31 发表评论

codejie 2010-06-08 22:07 发表评论

codejie 2010-05-21 17:39 发表评论

codejie 2010-05-12 18:06 发表评论

codejie 2010-04-29 20:32 发表评论

codejie 2010-04-08 00:03 发表评论

codejie 2010-04-01 00:28 发表评论

codejie 2010-03-30 22:59 发表评论

codejie 2010-03-26 23:58 发表评论