metric_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/abstract_regression_test_generator.h"
#include "src/tests/interop/metrics/inc/format_registry.h"

namespace illumina{ namespace interop { namespace unittest
{
    template<class Gen>
    class hardcoded_metric_generator;
    typedef registry_factory<hardcoded_metric_generator> hardcoded_metric_registry_t;
    template<class Gen>
    class write_read_metric_generator;
    typedef registry_factory<write_read_metric_generator> write_read_metric_registry_t;
    template<class Gen>
    class by_cycle_metric_generator;
    typedef registry_factory<by_cycle_metric_generator> by_cycle_metric_registry_t;
    template<class Gen>
    class clear_metric_generator;
    typedef registry_factory<clear_metric_generator> clear_metric_registry_t;
    template<class Gen>
    class hardcoded_metric_generator : public abstract_generator< typename Gen::metric_set_t >
    {
        typedef typename Gen::metric_set_t metric_set_t;
        typedef typename Gen::metric_t metric_t;
        typedef typename abstract_generator<metric_set_t>::parent_type parent_t;
    public:
        hardcoded_metric_generator()
        {
            hardcoded_metric_registry_t::instance()(metric_t(), Gen::VERSION);
        }
        ::testing::AssertionResult generate(metric_set_t& expected, metric_set_t& actual, bool*)const
        {
            actual.clear();
            Gen::create_expected(expected);
            std::string binary_data;//std::vector< ::uint8_t > binary_data;
            Gen::create_binary_data(binary_data);
            io::read_interop_from_string(binary_data, actual);
            return ::testing::AssertionSuccess();
        }
        parent_t clone()const{return new hardcoded_metric_generator<Gen>;}
        void write(std::ostream& out)const
        {
            out << "hardcoded_metric_generator<" << Gen::name() << ">";
        }

    };
    template<class Gen>
    class write_read_metric_generator : public abstract_generator< typename Gen::metric_set_t >
    {
        typedef typename Gen::metric_set_t metric_set_t;
        typedef typename Gen::metric_t metric_t;
        typedef typename abstract_generator<metric_set_t>::parent_type parent_t;
    public:
        write_read_metric_generator() : abstract_generator< typename Gen::metric_set_t >(1)
        {
            write_read_metric_registry_t::instance()(metric_t(), Gen::VERSION);
        }
        ::testing::AssertionResult generate(metric_set_t& expected, metric_set_t& actual, bool*)const
        {
            actual.clear();
            Gen::create_expected(expected);
            std::ostringstream fout;
            illumina::interop::io::write_metrics(fout, expected);

            //-------------------------------------------------
            //For unit test creation!
            //print_actual(std::cout, fout.str());
            //-------------------------------------------------

            io::read_interop_from_string(fout.str(), actual);
            return ::testing::AssertionSuccess();
        }
        parent_t clone()const{return new write_read_metric_generator<Gen>;}
        void write(std::ostream& out)const
        {
            out << "write_read_metric_generator<" << Gen::name() << ">";
        }

    private:
        static void print_actual(std::ostream& out, const std::string& data)
        {
            for(size_t i=0;i<data.size();++i)
            {
                out << "," << int(data[i]);
                if( i%20 == 0) out << std::endl;
            }
            out << std::endl;
            out << std::endl;
            out << std::endl;
        }
    };
    template<class Gen>
    class by_cycle_metric_generator : public abstract_generator< typename Gen::metric_set_t >
    {
        typedef typename Gen::metric_set_t metric_set_t;
        typedef typename Gen::metric_t metric_t;
        typedef typename abstract_generator<metric_set_t>::parent_type parent_t;
    public:
        by_cycle_metric_generator()
        {
            by_cycle_metric_registry_t::instance()(metric_t(), Gen::VERSION);
        }
        ::testing::AssertionResult generate(metric_set_t& expected, metric_set_t& actual, bool*)const
        {
            typedef typename metric_set_t::metric_type metric_t;
            typedef typename metric_t::uint_t uint_t;
            typedef typename metric_set_t::metric_comparison_t metric_comparison_t;

            std::string expected_data;
            {
                // Write out expected metrics
                std::ostringstream fout;
                Gen::create_expected(expected);
                io::write_metrics(fout, expected);
                expected_data = fout.str();
            }
            std::string expected_binary_data2;
            {
                // Insert additional metrics and write them to another buffer
                std::ostringstream fout;
                metric_set_t expected_metric_set2(expected, Gen::VERSION);
                uint_t max_tile_id=0;

                metric_t tmp = expected[0];
                const size_t n = expected.size();
                for(size_t i=0;i<n;++i)
                    max_tile_id = std::max(metric_comparison_t::to_tile(expected[i]), max_tile_id);
                for(uint_t i=0;i<n;++i)
                {
                    tmp.set_base(metric_comparison_t::to_lane(tmp), max_tile_id+1+i);
                    expected.insert(tmp);
                    expected_metric_set2.insert(tmp);
                }
                io::write_metrics(fout, expected_metric_set2, Gen::VERSION);
                expected_binary_data2 = fout.str();
            }
            io::read_interop_from_buffer(
                    reinterpret_cast< ::uint8_t*>(const_cast<char*>(expected_data.c_str()))
                    , static_cast<size_t>(expected_data.size())
                    , actual);
            io::read_interop_from_buffer(
                    reinterpret_cast< ::uint8_t*>(const_cast<char*>(expected_binary_data2.c_str()))
                    , static_cast<size_t>(expected_binary_data2.size())
                    , actual);
            actual.rebuild_index();

            return ::testing::AssertionSuccess();
        }
        parent_t clone()const{return new by_cycle_metric_generator<Gen>;}
        void write(std::ostream& out)const
        {
            out << "by_cycle_metric_generator<" << Gen::name() << ">";
        }
    };
    template<class MetricSet>
    class regression_test_metric_generator : public abstract_regression_test_generator< MetricSet >
    {
        typedef abstract_regression_test_generator< MetricSet > parent_t;
        typedef typename parent_t::base_t base_type;
        typedef MetricSet metric_set_t;
        enum{INCOMPLETE=250, NOT_FOUND=251};
    public:
        typedef typename abstract_regression_test_generator< MetricSet >::parent_type  parent_type;
    public:
        regression_test_metric_generator() : parent_t("InterOp", 2)
        {
        }
        regression_test_metric_generator(const std::string& run_folder) :
                parent_t(run_folder, "InterOp", 2)
        {
        }

    protected:
        bool read_expected(const std::string& baseline_file, metric_set_t& expected)const
        {
            expected.clear();
            try
            {
                illumina::interop::io::read_interop(baseline_file, expected);
            }
            // Should never have an incomplete file in baseline, set sentinel to detect
            catch(const io::incomplete_file_exception&){expected.set_version(INCOMPLETE);return true;}
            // Ensure missing file is expected
            catch(const io::file_not_found_exception&){expected.set_version(NOT_FOUND); return false;}
            return true;
        }
        bool generate_actual(const std::string& run_folder,  metric_set_t& actual)const
        {
            actual.clear();
            try
            {
                illumina::interop::io::read_interop(run_folder, actual);
            }
            // Ensure missing file is expected
            catch(const io::incomplete_file_exception&){if(actual.empty()) actual.set_version(NOT_FOUND);}
            // Ensure file is missing
            catch(const io::file_not_found_exception&){actual.set_version(NOT_FOUND);}
            return !actual.empty();
        }
        bool write_actual(const std::string& baseline_file, const metric_set_t& actual)const
        {
            return illumina::interop::io::write_interop(baseline_file, actual);
        }
        base_type clone(const std::string& run_folder)const
        {
            return new regression_test_metric_generator<MetricSet>(run_folder);
        }
        base_type clone()const
        {
            return new regression_test_metric_generator<MetricSet>(*this);
        }
        void write(std::ostream& out)const
        {
            out << "regression_test_metric_generator< "<< metric_set_t::prefix() << metric_set_t::suffix() << "> - "
                    << io::basename(parent_t::m_run_folder);
        }
        std::string baseline()const
        {
            return io::dirname(parent_t::baseline());
        }
    };

    template<class Gen>
    class clear_metric_generator : public abstract_generator< typename Gen::metric_set_t >
    {
        typedef typename Gen::metric_set_t metric_set_t;
        typedef typename Gen::metric_t metric_t;
        typedef typename abstract_generator<metric_set_t>::parent_type parent_t;
    public:
        clear_metric_generator()
        {
            clear_metric_registry_t::instance()(metric_t(), Gen::VERSION);
        }
        ::testing::AssertionResult generate(metric_set_t&, metric_set_t& actual, bool*)const
        {
            actual.clear();
            std::string binary_data;
            Gen::create_binary_data(binary_data);
            io::read_interop_from_string(binary_data, actual);
            actual.clear();
            return ::testing::AssertionSuccess();
        }
        parent_t clone()const{return new clear_metric_generator<Gen>;}
        void write(std::ostream& out)const
        {
            out << "clear_metric_generator<" << Gen::name() << ">";
        }

    };

}}}