coverage-helper.cpp File Reference

#include <algorithm>
#include <array>
#include <cassert>
#include <fstream>
#include <iostream>
#include <memory>
#include <numeric>
#include <regex>
#include <string>
#include <vector>

Include dependency graph for coverage-helper.cpp:

Go to the source code of this file.

Functions
std::string	escape_arg (const std::string &arg)
void	create_empty_file (std::string const &path)
bool	starts_with (std::string const &str, std::string const &pref)
int	parse_log_file_arg (std::string const &arg)
std::string	catch_path (std::string path)
std::string	windowsify_path (std::string path)
void	exec_cmd (std::string const &cmd, int log_num, std::string const &path)
int	main (int argc, char **argv)

Variables
const std::string	separator = "--sep--"
const std::string	logfile_prefix = "--log-file="

Function Documentation

catch_path()

std::string catch_path

(

std::string

path

)

Definition at line 70 of file coverage-helper.cpp.

                                     {
    auto start = path.find("catch");
    // try capitalized instead
    if (start == std::string::npos) {
        start = path.find("Catch");
    }
    if (start == std::string::npos) {
        throw std::domain_error("Couldn't find Catch's base path");
    }
    auto end = path.find_first_of("\\/", start);
    return path.substr(0, end);
}

Here is the caller graph for this function:

create_empty_file()

void create_empty_file

(

std::string const &

path

)

Definition at line 45 of file coverage-helper.cpp.

                                              {
    std::ofstream ofs(path);
    ofs << '\n';
}

Here is the caller graph for this function:

escape_arg()

std::string escape_arg

(

const std::string &

arg

)

Definition at line 12 of file coverage-helper.cpp.

                                           {
    if (arg.empty() == false &&
        arg.find_first_of(" \t\n\v\"") == arg.npos) {
        return arg;
    }
 
    std::string escaped;
    escaped.push_back('"');
    for (auto it = arg.begin(); ; ++it) {
        int num_backslashes = 0;
 
        while (it != arg.end() && *it == '\\') {
            ++it;
            ++num_backslashes;
        }
 
        if (it == arg.end()) {
            escaped.append(num_backslashes * 2, '\\');
            break;
        } else if (*it == '"') {
            escaped.append(num_backslashes * 2 + 1, '\\');
            escaped.push_back(*it);
        } else {
            escaped.append(num_backslashes, '\\');
            escaped.push_back(*it);
        }
    }
    escaped.push_back('"');
 
    return escaped;
}

Here is the caller graph for this function:

exec_cmd()

void exec_cmd	(	std::string const &	cmd,
		int	log_num,
		std::string const &	path )

Definition at line 92 of file coverage-helper.cpp.

                                                                        {
    std::array<char, 128> buffer;
#if defined(_WIN32)
    // cmd has already been escaped outside this function.
    auto real_cmd = "OpenCppCoverage --export_type binary:cov-report" + std::to_string(log_num)
        + ".bin --quiet " + "--sources " + escape_arg(path) + " --cover_children -- " + cmd;
    std::cout << "=== Marker ===: Cmd: " << real_cmd << '\n';
    std::shared_ptr<FILE> pipe(_popen(real_cmd.c_str(), "r"), _pclose);
#else // Just for testing, in the real world we will always work under WIN32
    (void)log_num; (void)path;
    std::shared_ptr<FILE> pipe(popen(cmd.c_str(), "r"), pclose);
#endif
 
    if (!pipe) {
        throw std::runtime_error("popen() failed!");
    }
    while (!feof(pipe.get())) {
        if (fgets(buffer.data(), 128, pipe.get()) != nullptr) {
            std::cout << buffer.data();
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv )

Definition at line 121 of file coverage-helper.cpp.

                                {
    std::vector<std::string> args(argv, argv + argc);
    auto sep = std::find(begin(args), end(args), separator);
    assert(sep - begin(args) == 2 && "Structure differs from expected!");
 
    auto num = parse_log_file_arg(args[1]);
    
    auto cmdline = std::accumulate(++sep, end(args), std::string{}, [] (const std::string& lhs, const std::string& rhs) {
        return lhs + ' ' + escape_arg(rhs);
    });
 
    try {
        return exec_cmd(cmdline, num, windowsify_path(catch_path(args[0])));
    } catch (std::exception const& ex) {
        std::cerr << "Helper failed with: '" << ex.what() << "'\n";
        return 12;
    }
}

Here is the call graph for this function:

parse_log_file_arg()

int parse_log_file_arg

(

std::string const &

arg

)

Definition at line 57 of file coverage-helper.cpp.

                                             {
    assert(starts_with(arg, logfile_prefix) && "Attempting to parse incorrect arg!");
    auto fname = arg.substr(logfile_prefix.size());
    create_empty_file(fname);
    std::regex regex("MemoryChecker\\.(\\d+)\\.log", std::regex::icase);
    std::smatch match;
    if (std::regex_search(fname, match, regex)) {
        return std::stoi(match[1]);
    } else {
        throw std::domain_error("Couldn't find desired expression in string: " + fname);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

starts_with()

bool starts_with	(	std::string const &	str,
		std::string const &	pref )

Definition at line 53 of file coverage-helper.cpp.

                                                              {
    return str.find(pref) == 0;
}

Here is the caller graph for this function:

windowsify_path()

std::string windowsify_path

(

std::string

path

)

Definition at line 83 of file coverage-helper.cpp.

                                          {
    for (auto& c : path) {
        if (c == '/') {
            c = '\\';
        }
    }
    return path;
}

Here is the caller graph for this function:

Variable Documentation

logfile_prefix

const std::string logfile_prefix = "--log-file="

Definition at line 51 of file coverage-helper.cpp.

separator

const std::string separator = "--sep--"

Definition at line 50 of file coverage-helper.cpp.