err.h

Go to the documentation of this file.

 
 
#ifndef CHEBYSHEV_ERR_H
#define CHEBYSHEV_ERR_H
 
#include <vector>
#include <cstdlib>
#include <iostream>
 
#include "./core/common.h"
#include "./core/random.h"
#include "./err/err_structures.h"
 
 
namespace chebyshev {
 
 
    // To err is human; to forgive, divine.
 
 
    namespace err {
 
 
        struct err_settings {
                
            std::string moduleName = "unknown";
 
            bool outputToFile = true;
 
            std::vector<std::string> outputFiles {};
 
            std::vector<std::string> assertOutputFiles {};
 
            std::vector<std::string> assertColumns = {
                "name", "evaluated", "failed", "description"
            };
 
            std::vector<std::string> errnoOutputFiles {};
 
            std::vector<std::string> errnoColumns = {
                "name", "evaluated", "expectedFlags", "failed"
            };
 
            std::vector<std::string> exceptionOutputFiles {};
 
            std::vector<std::string> exceptionColumns = {
                "name", "thrown", "correctType", "failed"
            };
 
            std::map<std::string, bool> pickedChecks {};
 
            bool quiet = false;
 
        } settings;
 
 
        struct err_results {
            
            // Total number of checks
            unsigned int totalChecks = 0;
 
            unsigned int failedChecks = 0;
 
            std::map<std::string, std::vector<assert_result>> assertResults {};
 
            std::map<std::string, std::vector<errno_result>> errnoResults {};
 
            std::map<std::string, std::vector<exception_result>> exceptionResults {};
 
        } results;
 
 
        inline void setup(
            const std::string& moduleName, int argc = 0, const char** argv = nullptr) {
 
            if(argc && argv)
                for (int i = 1; i < argc; ++i)
                    settings.pickedChecks[argv[i]] = true;
 
            std::cout << "Starting error checking on "
                << moduleName << " ..." << std::endl;
 
            settings.moduleName = moduleName;
            results.failedChecks = 0;
            results.totalChecks = 0;
 
            random::setup();
            output::setup();
        }
 
 
        inline void terminate(bool exit = true) {
 
            output::settings.quiet = settings.quiet;
 
            // Output to file is true but no specific files are specified, add default output file.
            if(  settings.outputToFile &&
                !output::settings.outputFiles.size() &&
                !settings.assertOutputFiles.size() &&
                !settings.errnoOutputFiles.size() &&
                !settings.exceptionOutputFiles.size() &&
                !settings.outputFiles.size()) {
                
                settings.outputFiles = { settings.moduleName + "_results" };
            }
 
            std::vector<std::string> outputFiles;
 
            // Print assert results
            outputFiles  = settings.outputFiles;
            outputFiles.insert(outputFiles.end(), settings.assertOutputFiles.begin(), settings.assertOutputFiles.end());
 
 
            output::print_results(results.assertResults, settings.assertColumns, outputFiles);
 
            // Print errno checking results
            outputFiles  = settings.outputFiles;
            outputFiles.insert(outputFiles.end(), settings.errnoOutputFiles.begin(), settings.errnoOutputFiles.end());
 
 
            output::print_results(results.errnoResults, settings.errnoColumns, outputFiles);
 
            // Print exception checking results
            outputFiles  = settings.outputFiles;
            outputFiles.insert(outputFiles.end(), settings.exceptionOutputFiles.begin(), settings.exceptionOutputFiles.end());
 
 
            output::print_results(results.exceptionResults, settings.exceptionColumns, outputFiles);
 
            std::cout << "Finished error checking " << settings.moduleName << " ...\n";
            std::cout << results.totalChecks
                << " total checks, "
                << results.failedChecks << " failed ("  << std::setprecision(3)
                << (results.failedChecks / (double) results.totalChecks * 100.0)
                << "%)" << std::endl;
 
            // Discard previous results
            results = err_results();
 
            if(exit) {
                output::terminate();
                std::exit(results.failedChecks);
            }
        }
 
 
        inline void assert(
            const std::string& name,
            bool exp,
            std::string description = "",
            bool quiet = false) {
 
            assert_result res {};
 
            res.name = name;
            res.evaluated = exp;
            res.failed = !exp;
            res.description = description;
            res.quiet = quiet;
 
            results.totalChecks++;
 
            if(!exp)
                results.failedChecks++;
 
            results.assertResults[name].push_back(res);
        }
 
 
        template<typename Function, typename InputType>
        inline void check_errno(
            const std::string& name,
            Function f,
            InputType x,
            int expected_errno,
            bool quiet = false) {
 
            errno_result res {};
            errno = 0;
 
            try {
                volatile auto r = f(x);
                r = *(&r);
            } catch(...) {}
 
            res.name = name;
            res.evaluated = errno;
            res.expectedFlags = { expected_errno };
            res.failed = (errno != expected_errno);
            res.quiet = quiet;
 
            results.totalChecks++;
 
            if(res.failed)
                results.failedChecks++;
 
            results.errnoResults[name].push_back(res);
        }
 
 
        template<typename Function, typename InputType>
        inline void check_errno(
            const std::string& name, Function f,
            std::function<InputType()> generator,
            int expected_errno,
            bool quiet = false) {
 
            check_errno(name, f, generator(), expected_errno, quiet);
        }
 
 
        template<typename Function, typename InputType>
        inline void check_errno(
            const std::string& name,
            Function f,
            InputType x,
            std::vector<int>& expected_flags,
            bool quiet = false) {
 
 
            errno_result res {};
            errno = 0;
 
            try {
                volatile auto r = f(x);
                r = *(&r);
            } catch(...) {}
 
            res.name = name;
            res.evaluated = errno;
            res.expectedFlags = expected_flags;
            res.quiet = quiet;
 
            res.failed = false;
            for (int flag : expected_flags)
                if(!(errno & flag))
                    res.failed = true;
 
            results.totalChecks++;
 
            if(res.failed)
                results.failedChecks++;
 
            results.errnoResults[name].push_back(res);
        }
 
 
        template<typename Function, typename InputType>
        void check_errno(
            const std::string& name, Function f,
            std::function<InputType()> generator,
            std::vector<int>& expected_flags,
            bool quiet = false) {
 
            check_errno(name, f, generator(), expected_flags, quiet);
        }
 
 
        template<typename Function, typename InputType>
        inline void check_exception(
            const std::string& name,
            Function f,
            InputType x,
            bool quiet = false) {
 
            exception_result res {};
            bool thrown = false;
 
            try {
                volatile auto r = f(x);
                r = *(&r);
            } catch(...) {
                thrown = true;
            }
 
            res.name = name;
            res.thrown = thrown;
            res.failed = !thrown;
            res.correctType = true;
            res.quiet = quiet;
 
            results.totalChecks++;
            if(!thrown)
                results.failedChecks++;
 
            results.exceptionResults[name].push_back(res);
        }
 
 
        template<typename Function, typename InputType>
        inline void check_exception(
            const std::string& name, Function f,
            std::function<InputType()> generator,
            bool quiet = false) {
 
            check_exception(name, f, generator(), quiet);
        }
 
 
        template<typename ExceptionType, typename Function, typename InputType>
        inline void check_exception(
            const std::string& name,
            Function f,
            InputType x,
            bool quiet = false) {
 
            exception_result res {};
            bool thrown = false;
            bool correctType = false;
 
            try {
                volatile auto r = f(x);
                r = *(&r);
            } catch(ExceptionType& exc) {
 
                correctType = true;
                thrown = true;
 
            } catch(...) {
                thrown = true;
            }
 
            res.name = name;
            res.thrown = thrown;
            res.failed = !(thrown && correctType);
            res.correctType = correctType;
            res.quiet = quiet;
 
            results.totalChecks++;
            if(!thrown)
                results.failedChecks++;
 
            results.exceptionResults[name].push_back(res);
        }
 
 
        template<typename ExceptionType, typename Function, typename InputType>
        inline void check_exception(
            const std::string& name, Function f,
            std::function<InputType()> generator,
            bool quiet = false) {
 
            check_exception(name, f, generator(), quiet);
        }
    }
}
 
#endif