generic_fixture.h

Go to the documentation of this file.

#pragma once

#include "interop/util/assert.h"
#include "interop/util/unique_ptr.h"
#include "interop/util/math.h"

namespace illumina{ namespace interop { namespace unittest {

    template<class T>
    class generator_ptr;
    template<class T>
    class abstract_generator
    {
        typedef  abstract_generator<T>*  base_type;
    public:
        typedef generator_ptr<T> parent_type;
        abstract_generator(const int test_modifier=0) : m_test_modifier(test_modifier){}
        virtual ~abstract_generator(){}
        virtual ::testing::AssertionResult generate(T& expected, T& actual, bool* skip_test)const=0;
        virtual bool advance()
        {
            return true;
        }

        virtual parent_type clone()const=0;
        int test_modifier()const{return m_test_modifier;}
        virtual void write(std::ostream& out)const=0;
        std::string info()const
        {
            std::ostringstream oss;
            write(oss);
            return oss.str();
        }
        friend std::ostream& operator<<(std::ostream& out, const abstract_generator<T>& gen)
        {
            gen.write(out);
            return out;
        }

    private:
        int m_test_modifier;
    };

    template<class T, class Fixture>
    class standard_parameter_generator : public abstract_generator<T>
    {
        typedef typename Fixture::parameter_type parameter_type;
        typedef typename abstract_generator<T>::parent_type base_type;
    public:
        standard_parameter_generator(const parameter_type parameter) : m_fixture(parameter)
        {
        }
        base_type operator()(const parameter_type& parameter)const
        {
            return new standard_parameter_generator(parameter);
        }

        ::testing::AssertionResult generate(T& expected, T &actual, bool*) const
        {
            return m_fixture.generate(expected, actual);
        }

        base_type clone() const
        {
            return new standard_parameter_generator(*this);
        }

        void write(std::ostream &out) const
        {
            m_fixture.write(out);
        }

    protected:
        Fixture m_fixture;
    };
    template<class T, class Fixture>
    class iterator_parameter_generator : public standard_parameter_generator<T, Fixture>
    {
        typedef typename Fixture::parameter_type parameter_type;
    public:
        iterator_parameter_generator(const parameter_type parameter) :
                standard_parameter_generator<T, Fixture>(parameter)
        {
        }
        bool advance()
        {
            return standard_parameter_generator<T, Fixture>::m_fixture.advance();
        }
    };

    template<class T>
    class generator_ptr
    {
    public:
        generator_ptr(abstract_generator<T>* ptr=0) : m_ptr(ptr){}
        generator_ptr(const generator_ptr<T>& other) : m_ptr(0)
        {
            if(other.m_ptr != 0)
            {
                generator_ptr<T> tmp = other.m_ptr->clone();
                m_ptr = tmp.m_ptr;
                tmp.m_ptr=0;
            }
        }
        generator_ptr& operator=(const generator_ptr<T>& other)
        {
            delete m_ptr;
            INTEROP_ASSERT(other.m_ptr != 0);

            if(other.m_ptr != 0)
            {
                generator_ptr<T> tmp = other.m_ptr->clone();
                m_ptr = tmp.m_ptr;
                tmp.m_ptr=0;
            }
            return *this;
        }
        generator_ptr& operator=(abstract_generator<T>* ptr)
        {
            delete m_ptr;
            if(ptr != 0) m_ptr = ptr;
            return *this;
        }
        virtual ~generator_ptr(){delete m_ptr;}

        const abstract_generator<T>& operator*()const
        {
            INTEROP_ASSERT(m_ptr != 0);
            return *m_ptr;
        }
        abstract_generator<T>& operator*()
        {
            INTEROP_ASSERT(m_ptr != 0);
            return *m_ptr;
        }
        const abstract_generator<T>* operator->()const
        {
            INTEROP_ASSERT(m_ptr != 0);
            return m_ptr;
        }
        abstract_generator<T>* operator->()
        {
            INTEROP_ASSERT(m_ptr != 0);
            return m_ptr;
        }
        bool operator==(const abstract_generator<T>* other)
        {
            return m_ptr == other;
        }
        bool operator!=(const abstract_generator<T>* other)
        {
            return m_ptr != other;
        }
        friend std::ostream& operator<<(std::ostream& out, const generator_ptr<T>& ptr)
        {
            INTEROP_ASSERT(ptr.m_ptr != 0);
            if(ptr.m_ptr == 0) return out;
            ptr.m_ptr->write(out);
            return out;
        }
    private:
        abstract_generator<T>* m_ptr;
    };
    template<class T>
    generator_ptr<T> wrap(abstract_generator<T>* ptr)
    {
        return generator_ptr<T>(ptr);
    }


    template<class T>
    struct generic_test_fixture : public ::testing::TestWithParam< generator_ptr<T> >
    {
    public:
        typedef ::testing::TestWithParam< generator_ptr<T> > parent_type;
    public:
        //typedef  abstract_generator<T>* generator_type;
        typedef  generator_ptr<T> generator_type;
        typedef T value_type;

        generic_test_fixture() : skip_test(false),
                                 fixture_test_result(parent_type::GetParam()->generate(expected, actual, &skip_test))
        {
            if(skip_test && !fixture_test_result)
                std::cout << fixture_test_result.message() << std::endl;
            test_modifier = parent_type::GetParam()->test_modifier();
        }
        T expected;
        T actual;
        bool skip_test;
        ::testing::Message msg;
        int test_modifier;
        const ::testing::AssertionResult fixture_test_result;
    };

    inline bool is_float_near(const float expected, const float actual, const float tol)
    {
        if(std::isnan(expected) && std::isnan(actual)) return true;
        if(std::isnan(expected) || std::isnan(actual)) return false;
        if(std::isinf(expected) && std::isinf(actual)) return true;
        if(std::isinf(expected) || std::isinf(actual)) return false;
        return std::abs(expected-actual) < tol;
    }

    inline ::testing::AssertionResult AreFloatsNear(const float expected, const float actual, const float tol)
    {
        if(is_float_near(expected, actual, tol)) return ::testing::AssertionSuccess();
        return ::testing::AssertionFailure() << "Abs(" << expected << " - " << actual << ") >= " << tol;
    }

    inline ::testing::AssertionResult AreValuesNear(const std::vector<float>& expected,
                                                    const std::vector<float>& actual,
                                                    const float tol)
    {
        ::testing::Message msg;
        bool test_failed = false;
        if( expected.size() != actual.size() )
        {
            return ::testing::AssertionFailure() << "Expected size: " << expected.size() << " != actual: " << actual.size();
        }
        for(size_t i=0;i<expected.size();++i)
        {
            if(!is_float_near(expected[i], actual[i], tol))
            {
                if(test_failed) msg << " | ";
                msg << "Value("<< i << ") Expected: " << expected[i] << " == Actual: " << actual[i];
                test_failed=true;
            }
        }
        if(test_failed) return ::testing::AssertionFailure(msg << " Tol: " << tol);
        return ::testing::AssertionSuccess();
    }


}}}
#define INTEROP_ASSERT_NEAR(EXPECTED, ACTUAL, TOL) ASSERT_TRUE(::illumina::interop::unittest::AreFloatsNear(EXPECTED, ACTUAL, TOL))
#define INTEROP_EXPECT_NEAR(EXPECTED, ACTUAL, TOL) EXPECT_TRUE(::illumina::interop::unittest::AreFloatsNear(EXPECTED, ACTUAL, TOL))
#define INTEROP_EXPECT_ARRAY_NEAR(EXPECTED, ACTUAL, TOL) EXPECT_TRUE(::illumina::interop::unittest::AreValuesNear(EXPECTED, ACTUAL, TOL))