Common C++ classes and routines used by my applications such as argument parser, IO and conversion utilities
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 

395 lines
15 KiB

#include "./testutils.h"
#include "../application/failure.h"
#include "../conversion/stringbuilder.h"
#include "../conversion/stringconversion.h"
#include "../io/catchiofailure.h"
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <initializer_list>
#include <iostream>
#include <limits>
#ifdef PLATFORM_UNIX
#include <poll.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>
#endif
using namespace std;
using namespace ApplicationUtilities;
using namespace ConversionUtilities;
using namespace IoUtilities;
/*!
* \brief Contains classes and functions utilizing creating of test applications.
*/
namespace TestUtilities {
TestApplication *TestApplication::m_instance = nullptr;
/*!
* \class TestApplication
* \brief The TestApplication class simplifies writing test applications that require opening test files.
* \remarks Only one instance is allowed at a time (singletone class).
*/
/*!
* \brief Constructs a TestApplication instance.
* \throws Throws std::runtime_error if an instance has already been created.
*/
TestApplication::TestApplication(int argc, char **argv)
: m_helpArg(m_parser)
, m_testFilesPathArg("test-files-path", 'p', "specifies the path of the directory with test files")
, m_applicationPathArg("app-path", 'a', "specifies the path of the application to be tested")
, m_workingDirArg("working-dir", 'w', "specifies the directory to store working copies of test files")
, m_unitsArg("units", 'u', "specifies the units to test; omit to test all units")
{
// check whether there is already an instance
if (m_instance) {
throw runtime_error("only one TestApplication instance allowed at a time");
}
m_instance = this;
// read TEST_FILE_PATH environment variable
if (const char *testFilesPathEnv = getenv("TEST_FILE_PATH")) {
if (const auto len = strlen(testFilesPathEnv)) {
m_testFilesPathEnvValue.reserve(len + 1);
m_testFilesPathEnvValue += testFilesPathEnv;
m_testFilesPathEnvValue += '/';
}
}
// setup argument parser
for (Argument *arg : initializer_list<Argument *>{ &m_testFilesPathArg, &m_applicationPathArg, &m_workingDirArg }) {
arg->setRequiredValueCount(1);
arg->setValueNames({ "path" });
arg->setCombinable(true);
}
m_unitsArg.setRequiredValueCount(Argument::varValueCount);
m_unitsArg.setValueNames({ "unit1", "unit2", "unit3" });
m_unitsArg.setCombinable(true);
m_parser.setMainArguments({ &m_testFilesPathArg, &m_applicationPathArg, &m_workingDirArg, &m_unitsArg, &m_helpArg });
// parse arguments
try {
m_parser.parseArgs(argc, argv);
// print help
if (m_helpArg.isPresent()) {
m_valid = false;
exit(0);
}
// handle path for testfiles and working-copy
cerr << "Directories used to search for testfiles:" << endl;
if (m_testFilesPathArg.isPresent()) {
if (*m_testFilesPathArg.values().front()) {
cerr << ((m_testFilesPathArgValue = m_testFilesPathArg.values().front()) += '/') << endl;
} else {
cerr << (m_testFilesPathArgValue = "./") << endl;
}
}
if (!m_testFilesPathEnvValue.empty()) {
cerr << m_testFilesPathEnvValue << endl;
}
cerr << "./testfiles/" << endl << endl;
cerr << "Directory used to store working copies:" << endl;
if (m_workingDirArg.isPresent()) {
if (*m_workingDirArg.values().front()) {
(m_workingDir = m_workingDirArg.values().front()) += '/';
} else {
m_workingDir = "./";
}
} else if (const char *workingDirEnv = getenv("WORKING_DIR")) {
if (const auto len = strlen(workingDirEnv)) {
m_workingDir.reserve(len + 1);
m_workingDir += workingDirEnv;
m_workingDir += '/';
}
} else {
if (m_testFilesPathArg.isPresent()) {
m_workingDir = m_testFilesPathArgValue + "workingdir/";
} else if (!m_testFilesPathEnvValue.empty()) {
m_workingDir = m_testFilesPathEnvValue + "workingdir/";
} else {
m_workingDir = "./testfiles/workingdir/";
}
}
cerr << m_workingDir << endl << endl;
// clear list of all additional profiling files created when forking the test application
if (const char *profrawListFile = getenv("LLVM_PROFILE_LIST_FILE")) {
ofstream(profrawListFile, ios_base::trunc);
}
m_valid = true;
cerr << "Executing test cases ..." << endl;
} catch (const Failure &failure) {
cerr << "Invalid arguments specified: " << failure.what() << endl;
m_valid = false;
}
}
/*!
* \brief Destroys the TestApplication.
*/
TestApplication::~TestApplication()
{
m_instance = nullptr;
}
/*!
* \brief Returns the full path of the test file with the specified \a name.
*/
string TestApplication::testFilePath(const string &name) const
{
string path;
fstream file; // used to check whether the file is present
// check the path specified by command line argument
if (m_testFilesPathArg.isPresent()) {
file.open(path = m_testFilesPathArgValue + name, ios_base::in);
if (file.good()) {
return path;
}
}
// check the path specified by environment variable
if (!m_testFilesPathEnvValue.empty()) {
file.clear();
file.open(path = m_testFilesPathEnvValue + name, ios_base::in);
if (file.good()) {
return path;
}
}
// file still not found -> return default path
file.clear();
file.open(path = "./testfiles/" + name, ios_base::in);
if (!file.good()) {
cerr << "Warning: The testfile \"" << path << "\" can not be located." << endl;
}
return path;
}
#ifdef PLATFORM_UNIX
/*!
* \brief Returns the full path to a working copy of the test file with the specified \a name.
* \remarks Currently only available under UNIX.
*/
string TestApplication::workingCopyPathMode(const string &name, WorkingCopyMode mode) const
{
// create file streams
fstream origFile, workingCopy;
origFile.exceptions(ios_base::badbit | ios_base::failbit);
workingCopy.exceptions(ios_base::badbit | ios_base::failbit);
// ensure working directory is present
struct stat currentStat;
if (stat(m_workingDir.c_str(), &currentStat) || !S_ISDIR(currentStat.st_mode)) {
if (mkdir(m_workingDir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) {
cerr << "Unable to create working copy for \"" << name << "\": can't create working directory." << endl;
return string();
}
}
// ensure subdirectory exists
const auto parts = splitString<vector<string>>(name, string("/"), EmptyPartsTreat::Omit);
if (!parts.empty()) {
string currentLevel = m_workingDir;
for (auto i = parts.cbegin(), end = parts.end() - 1; i != end; ++i) {
if (currentLevel.back() != '/') {
currentLevel += '/';
}
currentLevel += *i;
if (stat(currentLevel.c_str(), &currentStat) || !S_ISDIR(currentStat.st_mode)) {
if (mkdir(currentLevel.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) {
cerr << "Unable to create working copy for \"" << name << "\": can't create working directory." << endl;
return string();
}
}
}
}
// copy file
if (mode != WorkingCopyMode::NoCopy) {
try {
origFile.open(testFilePath(name), ios_base::in | ios_base::binary);
const string path = m_workingDir + name;
workingCopy.open(path, ios_base::out | ios_base::binary | ios_base::trunc);
workingCopy << origFile.rdbuf();
return path;
} catch (...) {
catchIoFailure();
cerr << "Unable to create working copy for \"" << name << "\": an IO error occured." << endl;
}
} else {
return m_workingDir + name;
}
return string();
}
string TestApplication::workingCopyPath(const string &name) const
{
return workingCopyPathMode(name, WorkingCopyMode::CreateCopy);
}
/*!
* \brief Executes an application with the specified \a args.
* \remarks Provides internal implementation of execApp() and execHelperApp().
*/
int execAppInternal(const char *appPath, const char *const *args, std::string &output, std::string &errors, bool suppressLogging, int timeout,
const std::string &newProfilingPath)
{
// print log message
if (!suppressLogging) {
cout << '-';
for (const char *const *i = args; *i; ++i) {
cout << ' ' << *i;
}
cout << endl;
}
// create pipes
int coutPipes[2], cerrPipes[2];
pipe(coutPipes), pipe(cerrPipes);
int readCoutPipe = coutPipes[0], writeCoutPipe = coutPipes[1];
int readCerrPipe = cerrPipes[0], writeCerrPipe = cerrPipes[1];
// create child process
if (int child = fork()) {
// parent process: read stdout and stderr from child
close(writeCoutPipe), close(writeCerrPipe);
try {
if (child == -1) {
throw runtime_error("Unable to create fork");
}
// init file descriptor set for poll
struct pollfd fileDescriptorSet[2];
fileDescriptorSet[0].fd = readCoutPipe;
fileDescriptorSet[1].fd = readCerrPipe;
fileDescriptorSet[0].events = fileDescriptorSet[1].events = POLLIN;
// init variables for reading
char buffer[512];
ssize_t count;
output.clear(), errors.clear();
// poll as long as at least one pipe is open
do {
int retpoll = poll(fileDescriptorSet, 2, timeout);
if (retpoll > 0) {
// poll succeeds
if (fileDescriptorSet[0].revents & POLLIN) {
if ((count = read(readCoutPipe, buffer, sizeof(buffer))) > 0) {
output.append(buffer, count);
}
} else if (fileDescriptorSet[0].revents & POLLHUP) {
close(readCoutPipe);
fileDescriptorSet[0].fd = -1;
}
if (fileDescriptorSet[1].revents & POLLIN) {
if ((count = read(readCerrPipe, buffer, sizeof(buffer))) > 0) {
errors.append(buffer, count);
}
} else if (fileDescriptorSet[1].revents & POLLHUP) {
close(readCerrPipe);
fileDescriptorSet[1].fd = -1;
}
} else if (retpoll == 0) {
// timeout
throw runtime_error("Poll time-out");
} else {
// fail
throw runtime_error("Poll failed");
}
} while (fileDescriptorSet[0].fd >= 0 || fileDescriptorSet[1].fd >= 0);
} catch (...) {
// ensure all pipes are close in the error case
close(readCoutPipe), close(readCerrPipe);
throw;
}
// get return code
int childReturnCode;
waitpid(child, &childReturnCode, 0);
return childReturnCode;
} else {
// child process
// -> set pipes to be used for stdout/stderr
dup2(writeCoutPipe, STDOUT_FILENO), dup2(writeCerrPipe, STDERR_FILENO);
close(readCoutPipe), close(writeCoutPipe), close(readCerrPipe), close(writeCerrPipe);
// -> modify environment variable LLVM_PROFILE_FILE to apply new path for profiling output
if (!newProfilingPath.empty()) {
setenv("LLVM_PROFILE_FILE", newProfilingPath.data(), true);
}
// -> execute application
execv(appPath, const_cast<char *const *>(args));
cerr << "Unable to execute \"" << appPath << "\": execv() failed" << endl;
exit(-101);
}
}
/*!
* \brief Executes the application to be tested with the specified \a args and stores the standard output and
* errors in \a stdout and \a stderr.
* \throws Throws std::runtime_error when the application can not be executed.
* \remarks
* - The specified \a args must be 0 terminated. The first argument is the application name.
* - Currently only supported under UNIX.
* - \a stdout and \a stderr are cleared before.
*/
int TestApplication::execApp(const char *const *args, string &output, string &errors, bool suppressLogging, int timeout) const
{
// increase counter used for giving profiling files unique names
static unsigned int invocationCount = 0;
++invocationCount;
// determine application path
const char *const appPath = m_applicationPathArg.firstValue();
if (!appPath || !*appPath) {
throw runtime_error("Unable to execute application to be tested: no application path specified");
}
// determine new path for profiling output (to not override profiling output of parent and previous invocations)
string newProfilingPath;
if (const char *llvmProfileFile = getenv("LLVM_PROFILE_FILE")) {
// replace eg. "/some/path/tageditor_tests.profraw" with "/some/path/tageditor0.profraw"
if (const char *llvmProfileFileEnd = strstr(llvmProfileFile, ".profraw")) {
const string llvmProfileFileWithoutExtension(llvmProfileFile, llvmProfileFileEnd);
// extract application name from path
const char *appName = strrchr(appPath, '/');
appName = appName ? appName + 1 : appPath;
// concat new path
newProfilingPath = argsToString(llvmProfileFileWithoutExtension, '_', appName, invocationCount, ".profraw");
// append path to profiling list file
if (const char *profrawListFile = getenv("LLVM_PROFILE_LIST_FILE")) {
ofstream(profrawListFile, ios_base::app) << newProfilingPath << endl;
}
}
}
return execAppInternal(appPath, args, output, errors, suppressLogging, timeout, newProfilingPath);
}
/*!
* \brief Executes an application with the specified \a args.
* \remarks
* - Intended to invoke helper applications (eg. to setup test files). Use execApp() and TestApplication::execApp() to
* invoke the application to be tested itself.
* - Currently only supported under UNIX.
*/
int execHelperApp(const char *appPath, const char *const *args, std::string &output, std::string &errors, bool suppressLogging, int timeout)
{
return execAppInternal(appPath, args, output, errors, suppressLogging, timeout, string());
}
#endif
}