abstract_regression_test_generator.h

Go to the documentation of this file.

#pragma once
#include "interop/io/metric_file_stream.h"
#include "src/tests/interop/inc/regression_test_data.h"
#include "src/tests/interop/inc/generic_fixture.h"
#include "src/tests/interop/inc/proxy_parameter_generator.h"
#include "interop/model/run_metrics.h"

namespace illumina{ namespace interop { namespace unittest
{
    template<class Model>
    class abstract_regression_test_generator : public abstract_generator< Model >
    {
    public:
        typedef typename abstract_generator< Model >::parent_type base_t;
    public:
        abstract_regression_test_generator(const std::string& test_dir, const int test_modifier=0) :
                abstract_generator< Model >(test_modifier), m_test_dir(test_dir)
        {
            regression_test_data::instance().add_subdir(test_dir);
        }
        abstract_regression_test_generator(const std::string& run_folder,
                                           const std::string& test_dir,
                                           const int test_modifier=0) :
                abstract_generator< Model >(test_modifier), m_run_folder(run_folder), m_test_dir(test_dir)
        {
        }
        base_t operator()(const std::string& name)const
        {
            m_run_folder=name;
            return clone(name);
        }
        virtual base_t clone(const std::string& name)const=0;
        ::testing::AssertionResult generate(Model& expected, Model& actual, bool* skip_test)const
        {
            const regression_test_data& data = regression_test_data::instance();
            const std::string baseline_file = baseline();
            if(!data.rebaseline())
            {
                const bool expected_found = read_expected(baseline_file, expected);
                const bool actual_generated = generate_actual(m_run_folder, actual);
                if(expected_found == actual_generated)
                {
                    *skip_test = !expected_found;
                    return ::testing::AssertionSuccess();
                }
                if(!expected_found)
                    return ::testing::AssertionFailure()  << "Failed to find baseline: " << baseline_file;
                return ::testing::AssertionFailure()  << "Failed to generate data for baseline: " << baseline_file;
            }
            else
            {
                try
                {
                    if(generate_actual(m_run_folder, actual))
                    {
                        if(!write_actual(baseline_file, actual))
                            return ::testing::AssertionFailure() << "Failed to write baseline: " << baseline_file;
                    }
                    *skip_test = true;
                }
                catch(const std::exception& ex)
                {
                    std::cerr << "Failed to generate baseline: " << baseline_file << " " << ex.what() << std::endl;
                    std::exit(1);
                    //return ::testing::AssertionFailure()  << "Failed to generate baseline: " << baseline_file << " " << ex.what();
                }
            }
            return ::testing::AssertionSuccess();
        }
        virtual std::string baseline()const
        {
            return io::combine(io::combine(io::combine(regression_test_data::instance().baseline(), io::basename(m_run_folder)), m_test_dir), "baseline");
        }

    protected:
        virtual bool read_expected(const std::string& baseline_file, Model& expected)const=0;
        virtual bool generate_actual(const std::string& run_folder, Model& actual)const=0;
        virtual bool write_actual(const std::string& baseline_file, const Model& actual)const=0;
        virtual base_t clone()const=0;

    protected:
        mutable std::string m_run_folder;
        std::string m_test_dir;
    };

    inline void read_metrics_safe(model::metrics::run_metrics& metrics, const std::string& run_folder)
    {
        try{
            metrics.read(run_folder);
        }
        catch(const model::invalid_run_info_cycle_exception&){}
    }

}}}