baseTest Class Reference

Inheritance diagram for baseTest:

Collaboration diagram for baseTest:

Public Member Functions
	baseTest (const std::string &aName, const std::string &aDescription, const decltype(parameters)&aParameters, const decltype(options)&aOptions={})
virtual void	execute (const std::vector< std::string > &remainingOptions)=0
void	ensuredWrite (int fd, const std::string &data)
void	ensuredRead (int fd, std::string &data)
void	Execute (const std::vector< std::string > &remainingOptions)

Static Public Member Functions
static std::map< std::string, baseTest * > &	getList ()
static void	setUpOptions ()
static const std::string &	getDescriptions ()

Protected Attributes
std::string	name
std::string	description
std::list< std::pair< std::string, std::string > >	parameters
std::list< std::pair< options::base &, std::string > >	options
std::set< std::string >	createdFiles

Static Protected Attributes
static options::single< unsigned int >	repeat
static options::single< bool >	cleanup
static options::single< bool >	urandom
static options::single< bool >	einsZweiDrei
static options::single< std::string >	contentFile
static options::single< size_t >	size
static options::single< unsigned int >	blocks
static options::single< std::string >	content
static options::single< bool >	truncate
static options::single< std::chrono::duration< double > >	time
static options::single< unsigned long >	syncus
static options::single< unsigned long >	skewus
static std::string	descriptions = "\npossible actions and their parameters:\n"

Detailed Description

Definition at line 35 of file fileOpsTests.cpp.

Constructor & Destructor Documentation

baseTest()

baseTest::baseTest ( const std::string &  aName, const std::string &  aDescription, const decltype(parameters)&  aParameters, const decltype(options)&  aOptions = {}  )

inline

Definition at line 68 of file fileOpsTests.cpp.

                                                 {}):
        name(aName),
        description(aDescription),
        parameters(aParameters),
        options(aOptions) {
        getList().emplace(name, this);
 
        descriptions += name;
        descriptions += ": ";
        descriptions += description;
        descriptions += "\n";
        if (!options.empty()) {
            descriptions += "\toptions:\n";
            for (const auto& opt : options) {
                descriptions += "\t\t";
                descriptions += opt.first.fGetLongName();
                descriptions += ": ";
                descriptions += opt.second;
                descriptions += "\n";
            }
        }
        descriptions += "\tparameters:\n";
        for (const auto& par : parameters) {
            descriptions += "\t\t";
            descriptions += par.first;
            descriptions += ": ";
            descriptions += par.second;
            descriptions += "\n";
        }
    };

Member Function Documentation

ensuredRead()

void baseTest::ensuredRead ( int  fd, std::string &  data  )

inline

Definition at line 122 of file fileOpsTests.cpp.

                                              {
        auto bytesToRead = data.size();
        auto ptr = const_cast<char*>(data.data()); // c++17 legalizes this...
        while (bytesToRead > 0) {
            auto result = read(fd, ptr, bytesToRead);
            if (result == -1 && errno == EINTR) {
                continue;
            }
            throwcall::badval(result, -1, "read ", bytesToRead, " from fd ", fd);
            bytesToRead -= result;
        }
    }

References throwcall::badval().

Referenced by Execute(), and simpleRead::execute().

Here is the call graph for this function:

Here is the caller graph for this function:

ensuredWrite()

void baseTest::ensuredWrite ( int  fd, const std::string &  data  )

inline

Definition at line 106 of file fileOpsTests.cpp.

                                                     {
        auto bytesToWrite = data.size();
        auto ptr = data.data();
        while (bytesToWrite > 0) {
            auto result = write(fd, ptr, bytesToWrite);
            if (result == -1) {
                if (errno == EINTR) {
                    continue;
                } else {
                    throwcall::badval(result, -1, "write ", bytesToWrite, " to fd ", fd);
                }
            } else {
                bytesToWrite -= result;
            }
        }
    }

References throwcall::badval().

Referenced by tmpFile::execute(), vimWrite::execute(), appendBlocks::execute(), simpleWrite::execute(), cpWrite::execute(), sparseWrite::execute(), sparseWrite2::execute(), findMinHoleSize::execute(), createUnlinkCreate::execute(), closeMvUpdate::execute(), createUnlinkClose::execute(), uglyNames::execute(), and uglyPaths::execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Execute()

void baseTest::Execute ( const std::vector< std::string > &  remainingOptions )

inline

Definition at line 134 of file fileOpsTests.cpp.

                                                               {
 
        if (size > 0) {
            content.resize(size);
        }
 
        if (urandom) {
            auto fd = throwcall::badval(open("/dev/urandom", O_RDONLY), -1, "open /dev/urandom");
            ensuredRead(fd, content);
            throwcall::good0(close(fd), "close /dev/urandom");
        }
        if (einsZweiDrei) {
            auto s = content.size();
            content.clear();
            content.reserve(s);
            for (unsigned i = 0; true; i++) {
                auto number = std::to_string(i);
                if (content.size() + number.size() < content.capacity()) {
                    content += number;
                    if (content.size() < content.capacity()) {
                        content.push_back('\n');
                    }
                } else {
                    break;
                }
            }
            while (content.size() < content.capacity()) {
                content.push_back('+');
            }
        }
        if (!contentFile.empty()) {
            auto fd = throwcall::badval(open(contentFile.c_str(), O_RDONLY), -1, "open ", contentFile);
            struct stat statData;
            throwcall::good0(fstat(fd, &statData), "stat ", contentFile);
            content.resize(statData.st_size);
            ensuredRead(fd, content);
        }
 
        std::vector<clockType::duration> times;
        times.reserve(repeat);
 
        for (unsigned i = 0; i < repeat; i++) {
            if (syncus > 0) {
                auto now = std::chrono::system_clock::now();
                auto seconds = std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count();
                auto divresult = std::div(seconds, syncus);
                auto then = std::chrono::system_clock::time_point(std::chrono::microseconds(divresult.quot * syncus + syncus + (i % syncus) * skewus));
                std::this_thread::sleep_until(then);
            }
            auto tStart = clockType::now();
            execute(remainingOptions);
            auto tStop = clockType::now();
            auto dt = tStop - tStart;
            times.push_back(dt);
        }
        if (cleanup) {
            for (const auto& file : createdFiles) {
                std::cout << "removing " << file << "\n";
                throwcall::good0(unlink(file.c_str()), "unlink ", file);
            }
        }
 
        if (repeat == 1) {
            std::cout << "took " << times.at(0) << "s\n";
        } else {
            auto minMax = std::minmax_element(times.begin(), times.end());
            std::cout << "minimum time: " << *(minMax.first) << "s\n";
            std::cout << "maximum time: " << *(minMax.second) << "s\n";
            auto sum = std::accumulate(times.begin(), times.end(), clockType::duration::zero());
            auto mean = std::chrono::duration_cast<std::chrono::duration<double>>(sum).count() / repeat;
            std::cout << "average time: " << mean << "s\n";
            std::map<double, unsigned long> histogram;
            unsigned bins = 10;
            auto range = std::chrono::duration_cast<std::chrono::duration<double>>(*(minMax.second) - * (minMax.first)).count();
            auto lowBorder = std::chrono::duration_cast<std::chrono::duration<double>>(*(minMax.first)).count();
            if (mean < lowBorder + range / 10) { // use log bins
                auto border = lowBorder;
                histogram[border] = 0;
                auto factor = std::pow(std::chrono::duration_cast<std::chrono::duration<double>>(*(minMax.second)).count() / lowBorder,
                                       1.0 / bins);
                for (unsigned i = 0; i < bins; i++) {
                    border *= factor;
                    histogram[border] = 0;
                }
            } else { // use lin bins
                lowBorder -= range / (2 * bins);
                if (lowBorder < 0) {
                    lowBorder = 0;
                }
                for (unsigned i = 0; i < bins + 1; i++) {
                    histogram[lowBorder + i * range / bins] = 0;
                }
            }
            for (auto t : times) {
                auto bin = histogram.begin();
                for (auto testBin = bin; testBin != histogram.end(); ++testBin) {
                    if (std::chrono::duration_cast<std::chrono::duration<double>>(t).count() < testBin->first) {
                        break;
                    }
                    bin = testBin;
                }
                bin->second++;
            }
            for (auto& bin : histogram) {
                std::cout << bin.first << ": " << bin.second << "\n";
            }
        }
    }

References throwcall::badval(), cleanup, content, contentFile, createdFiles, einsZweiDrei, ensuredRead(), execute(), throwcall::good0(), repeat, size, skewus, syncus, and urandom.

Here is the call graph for this function:

execute()

virtual void baseTest::execute ( const std::vector< std::string > &  remainingOptions )

pure virtual

Implemented in uglyPaths, uglyNames, truncateToSize, mmapRead, simpleRead, createUnlinkClose, closeMvUpdate, createUnlinkCreate, appendHole, findMinHoleSize, sparseWrite2, sparseWrite, mmapWrite, directWrite, cpWrite, simpleWrite, appendBlocks, keepOpen, vimWrite, and tmpFile.

Referenced by Execute().

Here is the caller graph for this function:

getDescriptions()

static const std::string& baseTest::getDescriptions ( )

inlinestatic

Definition at line 101 of file fileOpsTests.cpp.

                                              {
        return descriptions;
    }

References descriptions.

Referenced by main().

Here is the caller graph for this function:

getList()

static std::map<std::string, baseTest*>& baseTest::getList ( )

inlinestatic

Definition at line 58 of file fileOpsTests.cpp.

                                                   {
        static std::remove_reference<decltype(getList())>::type list;
        return list;
    }

Referenced by main().

Here is the caller graph for this function:

setUpOptions()

static void baseTest::setUpOptions ( )

inlinestatic

Definition at line 62 of file fileOpsTests.cpp.

                               {
        urandom.fForbid({&einsZweiDrei, &content, &contentFile});
        einsZweiDrei.fForbid({&urandom, &content, &contentFile});
        content.fForbid({&size, &urandom, &einsZweiDrei, &contentFile});
        contentFile.fForbid({&urandom, &einsZweiDrei, &content, &size});
    }

References content, contentFile, einsZweiDrei, options::base::fForbid(), size, and urandom.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

createdFiles

std::set<std::string> baseTest::createdFiles

protected

Definition at line 42 of file fileOpsTests.cpp.

Referenced by Execute(), tmpFile::execute(), vimWrite::execute(), appendBlocks::execute(), simpleWrite::execute(), cpWrite::execute(), directWrite::execute(), mmapWrite::execute(), sparseWrite::execute(), sparseWrite2::execute(), findMinHoleSize::execute(), appendHole::execute(), createUnlinkCreate::execute(), closeMvUpdate::execute(), uglyNames::execute(), and uglyPaths::execute().

description

std::string baseTest::description

protected

Definition at line 38 of file fileOpsTests.cpp.

name

std::string baseTest::name

protected

Definition at line 37 of file fileOpsTests.cpp.

options

std::list<std::pair<options::base&, std::string> > baseTest::options

protected

Definition at line 40 of file fileOpsTests.cpp.

parameters

std::list<std::pair<std::string, std::string> > baseTest::parameters

protected

Definition at line 39 of file fileOpsTests.cpp.

---

The documentation for this class was generated from the following file:

• src/fileOpsTests.cpp (v0.19-24-g0617ca1 with changes)