err.h

Go to the documentation of this file.

 
 
#ifndef CHEBYSHEV_ERR_H
#define CHEBYSHEV_ERR_H
 
#include <vector>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <iomanip>
 
#include "./core/common.h"
#include "./core/random.h"
#include "./core/output.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;
 
    };
 
 
    class err_context {
    private:
 
        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 {};
 
        bool wasTerminated {false};
 
    public:
 
        err_settings settings;
 
        std::shared_ptr<output::output_context> output;
 
        std::shared_ptr<random::random_context> random;
 
 
        inline void setup(
            const std::string& moduleName,
            int argc = 0, const char** argv = nullptr) {
 
            // Initialize other modules
            settings = err_settings();
            output = std::make_shared<output::output_context>();
            random = std::make_shared<random::random_context>();
 
            if(argc && argv)
                for (int i = 1; i < argc; ++i)
                    settings.pickedChecks[argv[i]] = true;
 
            std::cout << "Starting error checking on ";
            std::cout << moduleName << " module ..." << std::endl;
 
            settings.moduleName = moduleName;
            wasTerminated = false;
        }
 
 
        inline void terminate(bool exit = false) {
 
            unsigned int failedChecks = 0;
            unsigned int totalChecks = 0;
 
            for (const auto& pair : assertResults) {
                for (const auto& testCase : pair.second) {
                    totalChecks++;
                    failedChecks += testCase.failed ? 1 : 0;
                }
            }
 
            for (const auto& pair : errnoResults) {
                for (const auto& testCase : pair.second) {
                    totalChecks++;
                    failedChecks += testCase.failed ? 1 : 0;
                }
            }
 
            for (const auto& pair : exceptionResults) {
                for (const auto& testCase : pair.second) {
                    totalChecks++;
                    failedChecks += testCase.failed ? 1 : 0;
                }
            }
 
            // Ensure that an output file is specified
            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(
                assertResults,
                settings.assertColumns,
                outputFiles
            );
 
            // Print errno checking results
            outputFiles = settings.outputFiles;
            outputFiles.insert(
                outputFiles.end(),
                settings.errnoOutputFiles.begin(),
                settings.errnoOutputFiles.end()
            );
 
 
            output->print_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(
                exceptionResults,
                settings.exceptionColumns,
                outputFiles
            );
 
            // Print overall checks results
            std::cout << "Finished testing " << settings.moduleName << '\n';
            std::cout << totalChecks << " total checks, ";
            std::cout << failedChecks << " failed";
 
            // Print proportion of failed checks, avoiding division by zero
            if (totalChecks > 0) {
 
                const double percent = (failedChecks / (double) totalChecks) * 100;
                std::cout << " (" << std::setprecision(3) << percent << "%)" << std::endl;
                
            } else {
                std::cout << "\nNo checks were run!" << std::endl;
            }
 
            if(exit) {
                output->terminate();
                std::exit(failedChecks);
            }
 
            wasTerminated = true;
        }
 
 
        err_context(
            std::string moduleName,
            int argc = 0,
            const char** argv = nullptr) {
 
            setup(moduleName, argc, argv);
        }
        
 
        ~err_context() {
            if (!wasTerminated)
                terminate();
        }
 
 
        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;
 
            assertResults[name].push_back(res);
        }
 
 
        template<typename Function, typename InputType>
        inline void errno_value(
            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;
 
            errnoResults[name].push_back(res);
        }
 
 
        template<typename Function, typename InputType>
        inline void errno_value(
            const std::string& name, Function f,
            std::function<InputType()> generator,
            int expected_errno,
            bool quiet = false) {
 
            errno_value(name, f, generator(), expected_errno, quiet);
        }
 
 
        template<typename Function, typename InputType>
        inline void errno_flags(
            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;
 
            errnoResults[name].push_back(res);
        }
 
 
        template<typename Function, typename InputType>
        void errno_flags(
            const std::string& name, Function f,
            std::function<InputType()> generator,
            std::vector<int>& expected_flags,
            bool quiet = false) {
 
            errno_flags(name, f, generator(), expected_flags, quiet);
        }
 
 
        template<typename Function, typename InputType>
        inline void throws(
            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;
 
            exceptionResults[name].push_back(res);
        }
 
 
        template<typename Function, typename InputType>
        inline void throws(
            const std::string& name, Function f,
            std::function<InputType()> generator,
            bool quiet = false) {
 
            throws(name, f, generator(), quiet);
        }
 
 
        template <
            typename ExceptionType,
            typename Function,
            typename InputType
        >
        inline void throws(
            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;
 
            exceptionResults[name].push_back(res);
        }
 
 
        template <
            typename ExceptionType,
            typename Function,
            typename InputType
        >
        inline void throws(
            const std::string& name, Function f,
            std::function<InputType()> generator,
            bool quiet = false) {
 
            throws(name, f, generator(), quiet);
        }
 
 
        inline std::vector<assert_result> get_assertion(const std::string& name) {
            return assertResults[name];
        }
 
 
        inline assert_result get_assertion(const std::string& name, unsigned int i) {
            return assertResults[name].at(i);
        }
 
 
        inline std::vector<errno_result> get_errno(const std::string& name) {
            return errnoResults[name];
        }
 
 
        inline errno_result get_errno(const std::string& name, unsigned int i) {
            return errnoResults[name].at(i);
        }
 
 
        inline std::vector<exception_result> get_exception(const std::string& name) {
            return exceptionResults[name];
        }
 
 
        inline exception_result get_exception(const std::string& name, unsigned int i) {
            return exceptionResults[name].at(i);
        }
 
    };
 
 
    err_context make_context(const std::string& moduleName,
            int argc = 0, const char** argv = nullptr) {
        
        return err_context(moduleName, argc, argv);
    }
 
}}
 
#endif