source: trunk/test/Suite.h

#ifndef _theplu_yat_test_suite_
#define _theplu_yat_test_suite_

// $Id: Suite.h 4359 2023-08-23 01:28:46Z peter $

/*
  Copyright (C) 2008 Jari Häkkinen, Peter Johansson
  Copyright (C) 2009, 2010, 2011, 2013, 2014, 2015, 2016, 2018, 2019, 2020, 2021, 2022, 2023 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 3 of the
  License, or (at your option) any later version.

  The yat library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with yat. If not, see <http://www.gnu.org/licenses/>.
*/

// ensure that config.h always is included first
#ifndef YAT_VERSION
#error header 'config.h' not included
#endif

#include <yat/utility/config_public.h>

#define YAT_TEST_PROLOGUE "\n=== " << __func__ << " ===\n"

// used to tell automake that test should be skipped
#define EXIT_SKIP 77
#define EXIT_HARD_FAILURE 99

// SKIP_BAM_TEST is defined if we should skip bam tests
#if !defined (YAT_HAVE_HTSLIB) || !defined (HAVE_SAMTOOLS_EXECUTABLE)
#define SKIP_BAM_TEST
#endif

#include <yat/utility/Matrix.h>
#include <yat/utility/VectorMutable.h>
#include <yat/utility/WeightedIteratorArchetype.h>
#include <yat/classifier/Target.h>

#include <boost/concept_archetype.hpp>
#include <boost/concept_check.hpp>
#include <boost/iterator/iterator_categories.hpp>
#include <boost/iterator/iterator_concepts.hpp>

#include <iosfwd>
#include <sstream>
#include <vector>

namespace theplu {
namespace yat {
namespace test {

  /**
     \internal utility class for tests
   */
  class Suite
  {
  public:
    Suite(int argc, char* argv[], bool require_bam=false);

    /**
     */
    ~Suite(void);

    /**
       set ok to 'b && ok'

       \return b
    */
    bool add(bool b);

    /**
       \return In verbose mode std::cerr, else a ofstream to "/dev/null".
    */
    std::ostream& err(void) const;

    /**
       \return true if \f$ |a-b| <= N * \epsilon * min(|a|,|b|) \f$
       where \f$ \epsilon \f$ is std::numeric_limits<double>().epsilon()
    */
    bool equal(double a, double b, unsigned long int N=1);

    /**
       \return true if |\a a - \a b| <= \a margin
    */
    bool equal_fix(double a, double b, double margin=0);

    /**
       \return true if \f$ |a-b| <= N * sqrt(\epsilon) * min(|a|,|b|) \f$
       where \f$ \epsilon \f$ is std::numeric_limits<double>().epsilon()
    */
    bool equal_sqrt(double a, double b, unsigned long int N=1);

    template<class MATRIX1, class MATRIX2>
    bool equal_matrix(const MATRIX1& a, const MATRIX2& b,unsigned long int N=1);

    /**
       apply equal on ranges [first1, last1) and [first2, ...)
    */
    template<typename Iterator1, typename Iterator2>
    bool equal_range(Iterator1 first1, Iterator1 last1, Iterator2 first2,
                     unsigned int N=1);

    /**
       apply equal_fix on ranges [first1, last1) and [first2, ...)
    */
    template<typename Iterator1, typename Iterator2>
    bool equal_range_fix(Iterator1 first1, Iterator1 last1, Iterator2 first2,
                         double margin);

    /**
      \return true if test is ok
    */
    bool ok(void) const;

    /**
       \return In verbose mode std::cout, else a ofstream to "/dev/null".
    */
    std::ostream& out(void) const;

    /**
       Call this function from tests that require file data/foo.vcf.gz

       If bcftools is not available call exit(EXIT_SKIP).
     */
    void require_foo_vcf_gz(void) const;

    /**
       In verbose mode a final message is sent to std::cout.

       If ok() is true: "Test is ok." otherwise
       "Test failed."

       \return 0 if ok.
     */
    int return_value(void) const;

    template<typename TrivialIterator>
    void test_trivial_iterator(const TrivialIterator&);

    template<typename InputIterator>
    void test_input_iterator(InputIterator&);

    template<typename OutputIterator>
    void test_output_iterator(OutputIterator&);

    // assumes that value_type has operator==
    template<typename ForwardIterator>
    void test_forward_iterator(ForwardIterator);

    // assumes that value_type has operator==
    template<typename BidirectionalIterator>
    void test_bidirectional_iterator(BidirectionalIterator);

    // assumes that value_type has operator==
    template<typename RandomAccessIterator>
    void test_random_access_iterator(RandomAccessIterator);

    template<typename Container2D>
    void test_concept_container2d(const Container2D&);

    template<typename MutableContainer2D>
    void test_concept_mutable_container2d(MutableContainer2D&);

    /**
       Function writes to a stream using operator<<, creates a new
       object using stream constructor, and the new object is written
       to another stream, and function check if the two outputs are
       equal.
    */
    template<class T>
    bool test_stream(const T&) const;

    /**
       This function is similar to add(bool) and could be used to
       detect/count known issues. When the issue is fixed, one can
       replace the call to xadd(bool) with a call to add(bool).

       If \a b is false a counter is incremented, which is used to in
       return_value() to generate some printout on how many known
       issues were detected.

       If \a b is true, ok_ is set to false, becasue the known issue
       is no longer an issue and one should replace the call with a
       call to add(bool).
     */
    bool xadd(bool b);

  private:
    unsigned int known_issues_;
    bool ok_;
  };


  struct Generator
  {
    Generator(void);
    double operator()(void);
  private:
    size_t k_;
  };

  utility::Matrix generate_Matrix(size_t row, size_t col, double seed);

  /**
     If top source directory is located in /home/strangelove/yat,
     function returns "/home/strangelove/yat" + "test/" + local_path

     \return absolute path to file
     \param local_path path relative to srcdir
   */
  std::string filename(const std::string& local_path);

  /*
    class to test (at compile time) that a function (or class) works
    with a Container2D. Do not run any test using this class because
    the class is not really functional at run time.

    \see boost/concept_archetype.hpp
   */
  template<typename T>
  class container2d_archetype
  {
  public:
    typedef T value_type;
    typedef const T& const_reference;
    typedef const T* const_iterator;
    typedef const_iterator const_column_iterator;
    typedef const_iterator const_row_iterator;
    const_iterator begin(void) const { return &element_; }
    const_column_iterator begin_column(size_t) const { return &element_; }
    const_iterator begin_row(size_t) const { return &element_; }
    const_iterator end(void) const { return NULL; }
    const_column_iterator end_column(size_t) const { return NULL; }
    const_iterator end_row(size_t) const { return NULL; }
    size_t columns(void) const { return 0; }
    size_t rows(void) const { return 0; }
    const_reference operator()(size_t row, size_t column) const
    { return element_; }

  protected:
    T element_;
  };

  /*
    class to test (at compile time) that a function (or class) works
    with a MutableContainer2D. Do not run any test using this class because
    the class is not really functional at run time.

    \see boost/concept_archetype.hpp
   */
  template<typename T>
  class mutable_container2d_archetype : public container2d_archetype<T>
  {
  public:
    typedef T& reference;
    typedef T* iterator;
    typedef iterator column_iterator;
    typedef iterator row_iterator;
    iterator begin(void) { return &this->element_; }
    column_iterator begin_column(size_t) { return &this->element_; }
    iterator begin_row(size_t) { return &this->element_; }
    iterator end(void) { return NULL; }
    column_iterator end_column(size_t) { return NULL; }
    iterator end_row(size_t) { return NULL; }
    reference operator()(size_t row, size_t column)
    { return this->element_; }
  };

  /*
    class to test (at compile time) that a function (or class) works
    with a Distance. Do not run any test using this class because
    the class is not really functional at run time.

    \see boost/concept_archetype.hpp
   */
  class distance_archetype
  {
  public:
    /// class must be constructible somehow, but we don't wanna assume
    /// void constructor or any other common constructor so we use the
    /// signature to allow construction without assuming too much.
    distance_archetype(const boost::detail::dummy_constructor&) {};
    distance_archetype(const distance_archetype&) {};
    template<typename T1, typename T2>
    double operator()(T1 first1, T1 last1, T2 first2) const { return 0.0; }
  private:
    distance_archetype(void);
    distance_archetype& operator=(const distance_archetype&);
  };

  /*
    class to test (at compile time) that a function (or class) works
    with a NeighborWeighting. Do not run any test using this class because
    the class is not really functional at run time.

    \see boost/concept_archetype.hpp
   */
  class neighbor_weighting_archetype
  {
  public:
    neighbor_weighting_archetype(void) {}
    void operator()(const utility::VectorBase& distance,
                    const std::vector<size_t>& k_sorted,
                    const classifier::Target& target,
                    utility::VectorMutable& prediction) const {}
    neighbor_weighting_archetype& operator=(const neighbor_weighting_archetype&)
    { return *this; }
  private:
    neighbor_weighting_archetype(const neighbor_weighting_archetype&) {};
  };


  // compilation tests on iterators

  template<typename Iterator>
  void test_readable_iterator(Iterator iterator)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::ReadableIterator<Iterator>));
  }


  template<typename Iterator>
  void test_writable_iterator(Iterator iterator)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::WritableIterator<Iterator>));
  }


  template<typename Iterator>
  void test_swappable_iterator(Iterator iterator)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::SwappableIterator<Iterator>));
  }

  template<typename Iterator>
  void test_lvalue_iterator(Iterator iterator)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::LvalueIterator<Iterator>));
  }

  template<typename Iterator>
  void test_incrementable_iterator(Iterator iterator)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::IncrementableIterator<Iterator>));
  }

  template<typename Iterator>
  void test_single_pass_iterator(Iterator iterator)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::SinglePassIterator<Iterator>));
  }


  template<typename Iterator>
  void test_forward_traversal_iterator(Iterator iterator)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::ForwardTraversal<Iterator>));
  }


  template<typename Iterator>
  void test_bidirectional_traversal_iterator(Iterator iterator)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::BidirectionalTraversal<Iterator>));
  }


  template<typename Iterator>
  void test_random_access_traversal_iterator(Iterator iterator)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::RandomAccessTraversal<Iterator>));
  }


  // This function pulls out the iterator_category and checks that the
  // iterator has implemented what is promised in the category.
  //
  // Likewise it pulls out the boost::iterator_traversal type and
  // checks that the traversal is implemented as promised.
  //
  // Iterator is a model of input iterator (output iterator makes no
  // sense as a const iterator)
  template<typename Iterator>
  void test_const_iterator(Iterator iterator);


  // Similar to test_const_iterator but function also works for
  // output_iterator and it tests that the iterator is mutable.
  template<typename Iterator>
  void test_mutable_iterator(Iterator iterator);

  // functions used by test_const_iterator and test_mutable_iterator
  namespace detail {

    template<typename Iterator>
    void test_iterator_traversal(Iterator iterator,
                                 boost::incrementable_traversal_tag tag)
    {
      test_incrementable_iterator(iterator);
    }


    template<typename Iterator>
    void test_iterator_traversal(Iterator iterator,
                                 boost::single_pass_traversal_tag tag)
    {
      test_single_pass_iterator(iterator);
    }


    template<typename Iterator>
    void test_iterator_traversal(Iterator iterator,
                                 boost::forward_traversal_tag tag)
    {
      test_forward_traversal_iterator(iterator);
    }


    template<typename Iterator>
    void test_iterator_traversal(Iterator iterator,
                                 boost::bidirectional_traversal_tag tag)
    {
      test_bidirectional_traversal_iterator(iterator);
    }


    template<typename Iterator>
    void test_iterator_traversal(Iterator iterator,
                                 boost::random_access_traversal_tag tag)
    {
      test_random_access_traversal_iterator(iterator);
    }


    template<typename Iterator>
    void test_iterator(Iterator iterator, std::forward_iterator_tag tag)
    {
      test_lvalue_iterator(iterator);
      test_forward_traversal_iterator(iterator);
    }


    template<typename Iterator>
    void test_iterator(Iterator iterator, std::bidirectional_iterator_tag tag)
    {
      test_lvalue_iterator(iterator);
      test_bidirectional_traversal_iterator(iterator);
    }


    template<typename Iterator>
    void test_iterator(Iterator iterator, std::random_access_iterator_tag tag)
    {
      test_lvalue_iterator(iterator);
      test_random_access_traversal_iterator(iterator);
    }


    // testing forward iterator (or bidirectional or random access)
    template<typename Iterator>
    void test_iterator(Iterator iterator)
    {
      typename boost::iterator_category<Iterator>::type tag;
      test_iterator(iterator, tag);
      typename boost::iterator_traversal<Iterator>::type trav_tag;
      test_iterator_traversal(iterator, trav_tag);
    }


    template<typename Iterator>
    void test_mutable_iterator(Iterator iterator, std::output_iterator_tag tag)
    {
      test_incrementable_iterator(iterator);
    }


    template<typename Iterator>
    void test_mutable_iterator(Iterator iterator, std::input_iterator_tag tag)
    {
      test_single_pass_iterator(iterator);
    }


    template<typename Iterator>
    void test_mutable_iterator(Iterator iterator, std::forward_iterator_tag tag)
    {
      test_lvalue_iterator(iterator);
      test_iterator(iterator);
    }


    template<typename Iterator>
    void test_const_iterator(Iterator iterator, std::input_iterator_tag tag)
    {
      test_single_pass_iterator(iterator);
      test_readable_iterator(iterator);
    }


    template<typename Iterator>
    void test_const_iterator(Iterator iterator, std::forward_iterator_tag tag)
    {
      test_lvalue_iterator(iterator);
      test_iterator(iterator);
    }


  } // end of namespace detail


  // template implementations

  template<class MATRIX1, class MATRIX2>
  bool Suite::equal_matrix(const MATRIX1& a, const MATRIX2& b,
                           unsigned long int N)
  {
    if (a.rows() != b.rows() || a.columns() != b.columns()) {
      err() << "incorrect dimensions: "
            << a.rows() << " x " << a.columns() << " : "
            << b.rows() << " x " << b.columns() << "\n";
      return false;
    }
    for (size_t i=0; i<a.rows(); ++i)
      for (size_t j=0; j<a.columns(); ++j)
        if (!equal(a(i,j), b(i,j), N)) {
          err() << "  Matrix comparison: row: " << i << " column: " << j
                << "\n";
          return false;
        }
    return true;
  }


  template<typename Iterator1, typename Iterator2>
  bool Suite::equal_range(Iterator1 first1, Iterator1 last1, Iterator2 first2,
                          unsigned int N)
  {
    while (first1!=last1){
      if (!this->equal(*first1, *first2, N) )  {
        return false;
      }
      ++first1;
      ++first2;
    }
    return true;
  }


  template<typename Iterator1, typename Iterator2>
  bool Suite::equal_range_fix(Iterator1 first1, Iterator1 last1,
                              Iterator2 first2, double margin)
  {
    while (first1!=last1){
      if (!this->equal_fix(*first1, *first2, margin) )   {
        return false;
      }
      ++first1;
      ++first2;
    }
    return true;
  }


  // return true if we can write to a write-protected file
  bool run_as_root(void);

  // function that can be used to avoid warning: '-Wunused-but-set-variable'
  template<typename T>
  void avoid_compiler_warning(T) {}

  template<class T>
  bool Suite::test_stream(const T& t) const
  {
    this->err() << "Checking that output stream is valid as an input stream\n";
    std::stringstream ss;
    this->err() << "writing to output\n";
    ss << t;
    this->err() << "creating a new object from output\n";
    T t2(ss);
    std::stringstream ss2;
    this->err() << "writing to output\n";
    ss2 << t2;
    bool ok = ss2.str()==ss.str();
    if (!ok) {
      this->err() << "ERROR: first object gave following output:\n"
                  << ss.str() << "\n"
                  << "ERROR: and second object gave following output:\n"
                  << ss2.str() << "\n";
    }
    return ok;
  }

  template<typename TrivialIterator>
  void Suite::test_trivial_iterator(const TrivialIterator& iter)
  {
    err() << "  testing Trivial features" << std::endl;
    typename std::iterator_traits<TrivialIterator>::value_type tmp = *iter;
    avoid_compiler_warning(tmp);
    TrivialIterator default_constructed;
    avoid_compiler_warning(default_constructed);
  }

  template<typename InputIterator>
  void Suite::test_input_iterator(InputIterator& iter)
  {
    BOOST_CONCEPT_ASSERT((boost::InputIterator<InputIterator>));
    test_trivial_iterator(iter);
    err() << "  testing Input features" << std::endl;
    // just to check compilation
    if (false) {
      ++iter;
      iter++;
    }
  }

  template<typename OutputIterator>
  void Suite::test_output_iterator(OutputIterator& iter)
  {
    err() << "  testing Output features" << std::endl;
    // OutputIterator should be default constructible and assignable
    OutputIterator oi;
    oi = iter;
    ++oi;
  }

  template<typename ForwardIterator>
  void Suite::test_forward_iterator(ForwardIterator iter)
  {
    BOOST_CONCEPT_ASSERT((boost::ForwardIterator<ForwardIterator>));
    test_output_iterator(iter);
    test_input_iterator(iter);
    err() << "  testing Forward features" << std::endl;

    typename std::iterator_traits<ForwardIterator>::value_type tmp = *iter;
    // testing multiple traversing is possible and does not change the data
    ForwardIterator iter1 = iter;
    ++iter1;
    add(iter!=iter1);
    ForwardIterator iter2 = iter;
    ++iter2;
    add(tmp==*iter);
  }

  template<typename BidirectionalIterator>
  void Suite::test_bidirectional_iterator(BidirectionalIterator iter)
  {
    BOOST_CONCEPT_ASSERT((boost::BidirectionalIterator<BidirectionalIterator>));
    test_forward_iterator(iter);
    bool ok_cached = ok();
    err() << "  testing Bidirectional features" << std::endl;
    const BidirectionalIterator i = iter;
    BidirectionalIterator tmp = iter++;
    if (!add(tmp==i)) {
      err() << "iter++ does not return iter\n";
    }
    if (!add(++tmp==iter)) {
      err() << "++iter failed\n";
    }
    if (!add(--tmp==i)) {
      err() << "--iter failed\n";
    }
    tmp = iter--;
    if (!add(--tmp==iter))
      err() << "iter-- failed" << std::endl;
    if (ok_cached && !ok())
      err() << "failed" << std::endl;
  }

  template<typename RandomAccessIterator>
  void Suite::test_random_access_iterator(RandomAccessIterator iter)
  {
    BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<RandomAccessIterator>));
    test_bidirectional_iterator(iter);
    err() << "  testing RandomAccess features" << std::endl;
    bool ok_cached = ok();
    RandomAccessIterator iter2 = iter;
    iter2 += 1;
    iter2 -= 1;
    RandomAccessIterator& iter3 = (iter2 += 1);
    RandomAccessIterator& iter4 = (iter3 -= 1);
    if (!add(iter2 == iter4))
      err() << "operator-(int) failed" << std::endl;
    add(++iter2 == iter3);

    RandomAccessIterator iter5 = iter + 0;
    RandomAccessIterator iter6 = 0 + iter;
    add(iter6 == iter5);

    RandomAccessIterator iter7 = iter - 0;
    add(iter7 == iter);
    add(iter7 - iter == 0);
    add(! (iter7<iter));

    typename RandomAccessIterator::value_type tmp = iter[0];
    typename RandomAccessIterator::value_type tmp2 = *iter;
    tmp = tmp; // avoid compiler warning
    if (!add(tmp == tmp2))
      err() << "operator[] failed" << std::endl;
    if (!add(iter[0] == *iter))
      err() << "operator[] failed" << std::endl;
    if (ok_cached && !ok())
      err() << "failed" << std::endl;
  }

  template<typename Container2D>
  void Suite::test_concept_container2d(const Container2D& c)
  {
    typedef typename Container2D::value_type value_type;
    typedef typename Container2D::const_reference const_reference;
    typedef typename Container2D::const_iterator const_iterator;
    typedef typename Container2D::const_column_iterator const_column_iterator;
    typedef typename Container2D::const_row_iterator const_row_iterator;
    const_iterator ci = c.begin();
    const_column_iterator cci = c.begin_column(0);
    const_row_iterator cri = c.begin_row(0);
    ci = c.end();
    cci = c.end_column(0);
    cri = c.end_row(0);
    size_t cols = c.columns();
    size_t rows = c.rows();
    // just to avoid compiler warning
    avoid_compiler_warning(cols);
    avoid_compiler_warning(rows);
    const_reference x = c(0,0);
    value_type y;
    y = x;
    avoid_compiler_warning(y);
  }

  template<typename MutableContainer2D>
  void Suite::test_concept_mutable_container2d(MutableContainer2D& mc)
  {
    test_concept_container2d(mc);
    typedef typename MutableContainer2D::reference reference;
    typedef typename MutableContainer2D::iterator iterator;
    typedef typename MutableContainer2D::column_iterator column_iterator;
    typedef typename MutableContainer2D::row_iterator row_iterator;
    iterator i = mc.begin();
    column_iterator ci = mc.begin_column(0);
    row_iterator ri = mc.begin_row(0);
    *i = *ci;
    *ci = *i;
    *ri = *i;
    i = mc.end();
    ci = mc.end_column(0);
    ri = mc.end_row(0);
    reference x = mc(0,0);
    x = *mc.begin();
  }


  template<typename Iterator>
  void test_const_iterator(Iterator iterator)
  {
    typename boost::iterator_category<Iterator>::type tag;
    detail::test_const_iterator(iterator, tag);
  }


  template<typename Iterator>
  void test_mutable_iterator(Iterator iterator)
  {
    typename boost::iterator_category<Iterator>::type tag;
    detail::test_mutable_iterator(iterator, tag);
    test_writable_iterator(iterator);
  }


  // For convenience to create data iterator. This class typedefs four
  // classes that can be conveniently constructed in tests
  // (const/mutable and weighted/unweighted. Traversal
  // is expected to be one of:
  //// boost::incrementable_traversal_tag (problematic with unweighted)
  // boost::single_pass_traversal_tag (problematic with unweighted)
  // boost::forward_traversal_tag
  // boost::bidirectional_traversal_tag
  // boost::random_access_traversal_tag
  template<typename Traversal>
  struct DataIterator
  {
    typedef boost::iterator_archetype<
      double,
      boost::iterator_archetypes::readable_iterator_t,
      Traversal
      > unweighted_const_iterator;

    typedef boost::iterator_archetype<
      double,
      boost::iterator_archetypes::readable_writable_iterator_t,
      Traversal
      > unweighted_iterator;


    typedef utility::WeightedIteratorArchetype<
      boost::iterator_archetypes::readable_iterator_t, Traversal
      >
    weighted_const_iterator;

    typedef utility::WeightedIteratorArchetype<
      boost::iterator_archetypes::readable_writable_iterator_t,
      Traversal
      >
    weighted_iterator;
  };
}}}

#endif