source: trunk/test/utility.cc @ 3322

// $Id: utility.cc 3322 2014-10-06 06:41:48Z peter $

/*
  Copyright (C) 2006 Jari Häkkinen, Markus Ringnér
  Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson
  Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014 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/>.
*/

#include <config.h>

#include "Suite.h"

#include "yat/utility/Exception.h"
#include "yat/utility/Matrix.h"
#include "yat/utility/utility.h"
#include "yat/utility/Vector.h"
#include "yat/utility/VectorConstView.h"
#include "yat/utility/sort_index.h"
#include "yat/utility/stl_utility.h"

#include <boost/concept_archetype.hpp>
#include <boost/iterator/iterator_archetypes.hpp>

#include <cassert>
#include <cerrno>
#include <fstream>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <string>
#include <vector>

using namespace theplu::yat;
void test_errno_error(test::Suite& suite);
void test_errno_error_func(void);
void test_get_map(test::Suite&);
void test_load(test::Suite&);
void test_load2(test::Suite&);
void test_inverse(test::Suite&);

void test_dirname(test::Suite& suite);
void test_basename(test::Suite& suite);
void test_fnmatch(test::Suite& suite);
bool test_fnmatch(bool, std::string, std::string);
void test_remove(test::Suite& suite);
void test_rename(test::Suite& suite);
void test_replace(test::Suite& suite);

template<typename InputIterator, typename Key>
void test_inverse_validate(InputIterator first, InputIterator last,
                           const std::map<Key, std::vector<size_t> >& m,
                           test::Suite& suite);
template<typename InputIterator, typename Key>
void test_inverse_validate(InputIterator first,
                           const std::multimap<Key, size_t>& m,
                           test::Suite& suite);

void test_sort_index(test::Suite& suite);
void test_sum_weight(test::Suite& suite);
void test_less_nan(test::Suite& suite);
void test_ptr_compare(test::Suite& suite);
void test_compose_functors(test::Suite& suite);
void test_dereferencer(test::Suite& suite);

int main(int argc, char* argv[])
{
  using namespace theplu::yat;
  test::Suite suite(argc, argv);
  suite.err() << "testing utility ... " << std::endl;

  // test float/double
  std::string s("1.2");
  if (!utility::is<double>(s)){
    suite.add(false);
  }
  else if (!utility::is<float>(s)) {
    suite.add(false);
  }
  else if (utility::is<int>(s)) {
    suite.add(false);
  }
  else if (utility::is_nan(s)) {
    suite.add(false);
  }

  // test int
  s="23";
  if (!utility::is<double>(s)){
    suite.add(false);
  }
  else if (!utility::is<float>(s)) {
    suite.add(false);
  }
  else if (!utility::is<int>(s)) {
    suite.add(false);
  }
  else if (utility::is_nan(s)) {
    suite.add(false);
  }

  // test nan
  s=" nAn  ";
  if (!utility::is<double>(s)){
    suite.add(false);
    suite.err() << "error: " << s << " is a double\n";
  }
  /* we don't require NaN for float and int
  else if (!utility::is_float(s)) {
    suite.add(false);
    suite.err() << "error: " << s << " is a float\n";
  }
  else if (!utility::is_int(s)) {
    suite.add(false);
    suite.err() << "error: " << s << " is a int\n";
  }
  */
  else if (!utility::is_nan(s)) {
    suite.add(false);
    suite.err() << "error: " << s << " is nan\n";

  }

  // testing trailing values
  s=" 23 23   ";
  if (utility::is<double>(s)){
    suite.add(false);
  }
  else if (utility::is<float>(s)) {
    suite.add(false);
  }
  else if (utility::is<int>(s)) {
    suite.add(false);
  }
  else if (utility::is_nan(s)) {
    suite.add(false);
  }

  if (utility::convert<double>("1.23")!=1.23)
    suite.add(false);
  utility::convert<double>("-inf");
  utility::convert<double>("inf");
  utility::convert<double>("NaN");
  utility::convert<double>("-NaN");
  utility::convert<double>(" -NaN");

  suite.add(utility::convert(1.23)=="1.23");
  suite.add(utility::convert(1)=="1");

  suite.add(utility::is<unsigned int>("1"));
  suite.add(!utility::is<unsigned int>("   "));
  suite.add(!utility::is<unsigned int>("   -1"));
  // test -1 cannot be assigned to unsigned int
  try {
    unsigned int x = utility::convert<unsigned int>("-1");
    suite.err() << "convert<unsigned>(\"-1\") did not throw\n";
    suite.err() << "x: " << x << "\n";
    suite.add(false);
    exit(1);
  }
  catch (std::runtime_error& e) {
    suite.out() << "expected error: " << e.what() << "\n";
  }

  if (!suite.add(utility::is<double>("-inf")))
    suite.err() << "is<double>(\"-inf\") should return true\n";
  if (!suite.add(utility::is<double>("inf")))
    suite.err() << "is<double>(\"inf\") should return true\n";
  if (!suite.add(utility::is<double>("NaN")))
    suite.err() << "is<double>(\"NaN\") should return true\n";
  if (!suite.add(utility::is<double>("1.23")))
    suite.err() << "is<double>(\"1.23\") should return true\n";
  if (!suite.add(!utility::is<double>("1.23.2")))
    suite.err() << "is<double>(\"1.23.2\") should return false\n";
  if (!suite.add(!utility::is<int>("1.23")))
    suite.err() << "is<int>(\"1.23\") should return false\n";
  if (!suite.add(!utility::is<int>("")))
    suite.err() << "is<int>(\"\") should return false\n";

  {
    utility::Log<long double> f;
    utility::Log<double> f2(1.3);
    f(2.0);
    utility::Exp<double> e;
    e(3.2);
  }

  test_get_map(suite);
  test_inverse(suite);
  test_sort_index(suite);
  test_sum_weight(suite);
  test_less_nan(suite);
  test_errno_error(suite);
  test_ptr_compare(suite);
  test_load(suite);
  test_load2(suite);

  test_compose_functors(suite);

  double x = 8.0;
  suite.add(suite.equal(utility::log2(x), 3.0));
  float xf = x;
  suite.add(suite.equal(utility::log2(xf), 3.0));
  long double xld = 8.0;
  suite.add(suite.equal(utility::log2(xld), 3.0));

  test_basename(suite);
  test_dirname(suite);
  test_fnmatch(suite);
  test_remove(suite);
  test_rename(suite);
  test_replace(suite);

  return suite.return_value();
}


void test_errno_error_func(void)
{
  errno=1;
  throw utility::errno_error("");
}


void test_errno_error(test::Suite& suite)
{
  suite.out() << "testing errno_error\n";
  try {
    test_errno_error_func();
  }
  catch ( utility::errno_error& e) {
    suite.out() << "catching expected exception with what():\n";
    suite.out() << e.what() << "\n";
    return;
  }
  suite.err() << "error: expected thrown exception\n";
  suite.add(false);
}


void test_compose_functors(test::Suite& suite)
{
  typedef utility::abs<double> U1;
  // we use float here to check conversion from float to double in functors
  typedef utility::Exp<float> U2;
  typedef std::plus<double> B;
  U1 u1;
  U2 u2;
  B b;

  utility::compose_f_gx_hy<B, U1, U2> binary;
  binary = utility::make_compose_f_gx_hy(b, u1, u2);

  utility::compose_f_gxy<U2, B> binary2;
  binary2 = utility::make_compose_f_gxy(u2, b);

  utility::compose_f_gx<U1, U2> unary;
  unary = utility::make_compose_f_gx(u1, u2);

  utility::compose_f_gx_hx<B, U1, U2> unary2;
  unary2 = utility::make_compose_f_gx_hx(b, u1, u2);
  if (!suite.add(suite.equal_fix(unary2(-2.0), 2.0 + std::exp(-2.0),1e-8)))
    suite.err() << "compose_f_gx_hx failed\n";
}


void test_dereferencer(test::Suite& suite)
{
  using utility::Dereferencer;
  Dereferencer<double*> deref;
  double x = 0;
  double* px = &x;
  deref(px) = 1.662;
  if (!suite.add(x==1.662)) {
    suite.out() << "test_dereferencer failed: x: " << x << "\n";
  }
}


void test_get_map(test::Suite& suite)
{
  std::map<std::string, int> m;
  m["one"] = 1;
  m["two"] = 2;
  const std::map<std::string, int> m2(m);
  int i = utility::get(m2, static_cast<std::string>("one"));
  test::avoid_compiler_warning(i); // avoid compiler warning
  try {
    utility::get(m2, static_cast<std::string>("three"));
    suite.add(false);
  }
  catch (std::runtime_error& e) {
    suite.out() << "expected exception thrown with what() = "
                << e.what() << "\n";
  }
  // test ticket #799
  if (!suite.add(utility::get(m, "one")==1))
    suite.err() << "get(m, \"one\")!=1\n";

  // don't run compiler test code
  if (false) {
    typedef boost::default_constructible_archetype<
      boost::sgi_assignable_archetype<> > key_type;

    typedef boost::default_constructible_archetype<
      boost::sgi_assignable_archetype<
        boost::null_archetype<std::string> > > value_type;

    typedef boost::default_constructible_archetype<
      boost::binary_function_archetype<key_type, key_type, bool> > Compare;

    std::map<key_type, value_type, Compare> m3;

    // create an object that is convertible to key_type
    boost::detail::dummy_constructor x;
    boost::convertible_to_archetype<key_type> my_key(x);
    utility::get(m3, my_key);
  }
}

void test_less_nan(test::Suite& suite)
{
  suite.out() << "test less_nan\n";
  bool prior_ok=suite.ok();
  utility::less_nan<double> f;
  suite.add(f(2.7,3.14));
  suite.add(!f(2.7,-3.14));
  suite.add(!f(2.7,2.7));
  suite.add(f(3.14, std::numeric_limits<double>::quiet_NaN()));
  suite.add(!f(std::numeric_limits<double>::quiet_NaN(), 2.7));
  suite.add(!f(std::numeric_limits<double>::quiet_NaN(),
               std::numeric_limits<double>::quiet_NaN()));
  utility::less_nan<utility::DataWeight> fw;
  suite.add(fw(utility::DataWeight(2), utility::DataWeight(3)));

  bool post_ok=suite.ok();
  if (!post_ok && prior_ok)
    suite.err() << "test_less_nan failed\n";
}


void test_load(test::Suite& suite)
{
  std::istringstream iss(std::string("1.69 3.14"));
  std::vector<double> double_vec;
  utility::load(iss, double_vec);
  suite.add(double_vec.size()==2);

  std::istringstream iss2(std::string("1 2"));
  std::vector<double> uint_vec;
  utility::load(iss2, uint_vec);
  suite.add(uint_vec.size()==2);

  std::istringstream iss3(std::string("1.69 3.14"));
  std::vector<std::string> str_vec;
  utility::load(iss3, str_vec);
  if (str_vec.size()==2) {
    if (str_vec[1]!="3.14") {
      suite.out() << "error: load<string>:" << "\n"
                  << "  str_vec[1] = " << str_vec[1] << "\n"
                  << "  expected:  3.14n";
      suite.add(false);
    }
  }
  else {
    suite.out() << "str_vec.size() is not 2\n";
    suite.add(false);
  }
}


void test_load2(test::Suite& suite)
{
  suite.out() << "test load<double>(matrix)\n";
  std::string str("1.69 3.14\n1.23 1.22\n");
  std::istringstream iss(str);
  std::vector<std::vector<double> > double_m;
  utility::load(iss, double_m, '\0', '\n');
  suite.add(double_m.size()==2);

  suite.out() << "test load<std::string>(matrix)\n";
  suite.out() << str;
  std::istringstream iss2(str);
  std::vector<std::vector<std::string> > str_m;
  utility::load(iss2, str_m, '\0', '\n');
  std::cout << str_m.size() << std::endl;
  for (size_t i=0; i<str_m.size(); ++i)
    for (size_t j=0; j<str_m[i].size(); ++j)
      suite.out() << str_m[i][j] << "\n";
  suite.add(str_m.size()==2);
}


void test_inverse(test::Suite& suite)
{
  suite.err() << "Testing inverse\n";
  std::vector<std::string> vec;
  vec.push_back("No");
  vec.push_back("one");
  vec.push_back("shall");
  vec.push_back("be");
  vec.push_back("subjected");
  std::map<std::string, std::vector<size_t> > map;
  utility::inverse(vec.begin(), vec.end(), map);
  test_inverse_validate(vec.begin(), vec.end(), map, suite);
  utility::inverse(vec.begin()+1, vec.end(), map);
  test_inverse_validate(vec.begin()+1, vec.end(), map, suite);
  const std::vector<std::string> vec2(vec);
  utility::inverse(vec2.begin(), vec2.end(), map);
  test_inverse_validate(vec2.begin(), vec2.end(), map, suite);
  std::multimap<std::string, size_t> mmap;
  utility::inverse(vec.begin(), vec.end(), mmap);
  test_inverse_validate(vec.begin(), mmap, suite);
  utility::inverse(vec.begin()+1, vec.end(), mmap);
  test_inverse_validate(vec.begin()+1, mmap, suite);
  // do not run compile tests
  if (false) {
    std::map<std::string, std::vector<size_t> > m;
    boost::input_iterator_archetype<std::string> start;
    boost::input_iterator_archetype<std::string> end;
    utility::inverse(start, end, m);
    std::map<std::string, std::vector<size_t>, std::greater<std::string> > m2;
    utility::inverse(start, end, m2);
    std::multimap<std::string, size_t> m3;
    utility::inverse(start, end, m3);
    std::multimap<std::string, size_t, std::greater<std::string> > m4;
    utility::inverse(start, end, m4);

    std::map<std::string, size_t> unique_map;
    utility::inverse(start, end, unique_map);
  }
}


template<typename InputIterator, typename Key>
void test_inverse_validate(InputIterator first, InputIterator last,
                           const std::map<Key, std::vector<size_t> >& m,
                           test::Suite& suite)
{
  typedef typename std::map<Key, std::vector<size_t> >::const_iterator Iter;
  for ( InputIterator iter=first; iter != last; ++iter) {
    Iter map_iter = m.find(*iter);
    if (!suite.add(map_iter!=m.end())) {
      suite.err() << "test_inverse_validate() failed\n";
      suite.err() << "  could not find: " << *first << " in map m\n";
    }
    for (size_t i=0; i<map_iter->second.size(); ++i)
      if (!suite.add(map_iter->second[i] ==
                     static_cast<size_t>(distance(first, iter))) ) {
        suite.err() << "test_inverse_validate() failed\n";
        suite.err() << "  comparing: " << map_iter->second[i]
                    << " and " << distance(first, iter)
                    << " expected them to be equal\n";
      }
  }
}


template<typename InputIterator, typename Key>
void test_inverse_validate(InputIterator first,
                           const std::multimap<Key, size_t>& m,
                           test::Suite& suite)
{
  for (typename std::multimap<Key, size_t>::const_iterator iter=m.begin();
       iter!=m.end(); ++iter) {
    suite.add(*(first + iter->second) == iter->first);
  }

}

void test_sort_index(test::Suite& suite)
{
  suite.err() << "testing sort_index" << std::endl;
  utility::Vector a(10);
  for (size_t i=0; i<a.size(); ++i)
    a(i) = std::pow(i-4.2,2);
  std::vector<size_t> vec;
  utility::sort_index(vec, a);

  std::vector<size_t> vec2;
  utility::sort_index(a.begin(), a.end(), vec2);
  if (vec.size()==vec2.size()) {
    if (!suite.equal_range(vec.begin(), vec.end(), vec2.begin())) {
      suite.add(false);
    }
  }
  else {
    suite.add(false);
    suite.err() << "size mismatch: vec.size()=" << vec.size()
                << "vec2.size()=" << vec2.size() << "\n";
  }
  const utility::VectorConstView b(a, 0, 5, 2);

  std::vector<size_t> vec3;
  utility::sort_index(vec3, b);
  std::vector<size_t> vec4;
  utility::sort_index(b.begin(), b.end(), vec4);
  if (vec3.size()!=vec4.size()) {
    suite.add(false);
    suite.err() << "size mismatch: vec3.size()=" << vec3.size()
                << " vec4.size()=" << vec4.size() << "\n";
  }
  else {
    if (!suite.equal_range(vec3.begin(), vec3.end(), vec4.begin())){
      suite.add(false);
    }
  }

  std::list<double> list;
  for (size_t i=0; i<a.size(); ++i)
    list.push_back(a(i));
  std::vector<size_t> vec5;
  utility::sort_index(list.begin(), list.end(), vec5);
  if (vec.size()!=vec5.size()) {
    suite.add(false);
    suite.err() << "size mismatch: vec.size()=" << vec.size()
                << " vec5.size()=" << vec5.size() << "\n";
  }
  else {
    if (!suite.equal_range(vec.begin(), vec.end(), vec5.begin())){
      suite.add(false);
    }
  }

  // do not run compiler tests
  if (false) {
    // value type must be possible to store in a vector so has to be
    // default constructible and assignable
    typedef boost::default_constructible_archetype<
      boost::sgi_assignable_archetype<
        boost::less_than_comparable_archetype<> > > value_type;
    boost::input_iterator_archetype<value_type> iter;
    utility::sort_index(iter, iter, vec);

    // try with a random access container as well
    typedef boost::iterator_archetypes::readable_iterator_t access_type;
    typedef boost::random_access_traversal_tag traversal_type;
    typedef boost::copy_constructible_archetype<
      boost::less_than_comparable_archetype<> > value_type2;
    boost::iterator_archetype<value_type2, access_type, traversal_type> iter2;
    utility::sort_index(iter2, iter2, vec);
  }
  // same thing with four argument version
  if (false) {
    // value type must be possible to store in a vector so has to be
    // default constructible and assignable
    typedef boost::default_constructible_archetype<
      boost::sgi_assignable_archetype<> > value_type;

    boost::input_iterator_archetype<value_type> iter;

    // Create a binary predicate that is copy constructible
    boost::copy_constructible_archetype<
        boost::binary_predicate_archetype<value_type, value_type>
      > comp;

    utility::sort_index(iter, iter, vec, comp);

    // try with a random access iterator as well
    typedef boost::iterator_archetypes::readable_iterator_t access_type;
    typedef boost::random_access_traversal_tag traversal_type;
    typedef boost::copy_constructible_archetype<> value_type2;
    boost::iterator_archetype<value_type2, access_type, traversal_type> iter2;
    // Create a binary predicate that is copy constructible
    boost::copy_constructible_archetype<
        boost::binary_predicate_archetype<value_type2, value_type2>
      > comp2;
    utility::sort_index(iter2, iter2, vec, comp2);
  }
}


void test_sum_weight(test::Suite& suite)
{
  // do not run compile test
  if (false) {
    boost::input_iterator_archetype<double> iter;
    utility::sum_weight(iter, iter);
    boost::input_iterator_archetype_no_proxy<utility::DataWeight> iter2;
    utility::sum_weight(iter2, iter2);
  }
}


void test_ptr_compare(test::Suite& suite)
{
  using utility::make_ptr_compare;
  std::vector<double*> vec(10);
  std::greater<double> d_greater;
  for (size_t i=0; i<vec.size(); ++i)
    vec[i] = new double(i);
  std::sort(vec.begin(), vec.end(), make_ptr_compare(*vec.begin(), d_greater));
  for (size_t i=1; i<vec.size(); ++i) {
    suite.add( *vec[i-1] > *vec[i]);
  }
  std::sort(vec.begin(), vec.end(), make_ptr_compare(*vec.begin()));
  for (size_t i=1; i<vec.size(); ++i) {
    suite.add( *vec[i-1] < *vec[i]);
  }
  for (size_t i=0; i<vec.size(); ++i)
    delete vec[i];

}


void test_fnmatch(test::Suite& suite)
{
  bool ok=true;
  ok &= test_fnmatch(true,"peter", "peter");
  ok &= test_fnmatch(false,"peter", "peterj");

  ok &= test_fnmatch(true,"*", "peterj");
  ok &= test_fnmatch(true,"p*", "peterj");
  ok &= test_fnmatch(true, "p*", "peter");
  ok &= test_fnmatch(false, "p*j", "peter");
  ok &= test_fnmatch(true, "p*j", "peterj");
  ok &= test_fnmatch(true, "*peter", "peter");

  ok &= test_fnmatch(true, "p?ter", "peter");
  ok &= test_fnmatch(false, "p?er", "peter");
  ok &= test_fnmatch(false, "p?eter", "peter");

  ok &= test_fnmatch(true, "filename", "filename");
  ok &= test_fnmatch(true, "*name", "filename");
  ok &= test_fnmatch(true, "[fa]il?name", "filename");
  ok &= test_fnmatch(true, "[fa]*il?name", "ffilename");

  ok &= test_fnmatch(true, "[fa]*il?name", "fafafailename");
  ok &= test_fnmatch(false, "[fa]?il?name", "ilename");
  ok &= test_fnmatch(false, "?[fa]il?name", "ilename");
  ok &= test_fnmatch(true, "[fa]il?name", "filename");
  ok &= test_fnmatch(false, "[fa]?il?name", "fafafailename");

  ok &= test_fnmatch(true, "*name", "/path/to/filename");
  ok &= test_fnmatch(true, "*name", "file.name");
  ok &= test_fnmatch(true, "*.txt", ".file.txt");
  suite.add(ok);
}


void test_dirname(test::Suite& suite)
{
  std::vector<std::string> path;
  path.push_back("/usr/lib");
  path.push_back("/usr/");
  path.push_back("usr");
  path.push_back("/");
  path.push_back(".");
  path.push_back("..");
  std::vector<std::string> dir;
  dir.push_back("/usr");
  dir.push_back("/");
  dir.push_back(".");
  dir.push_back("/");
  dir.push_back(".");
  dir.push_back(".");
  assert(dir.size()==path.size());
  using utility::dirname;
  for (size_t i=0; i<dir.size(); ++i) {
    if (dir[i] != dirname(path[i])) {
      suite.add(false);
      suite.out() << "error:\n";
      suite.out() << "path:           " << path[i] << "\n";
      suite.out() << "directory_name: " << dirname(path[i]) << "\n";
      suite.out() << "expected:       " << dir[i] << "\n";
    }
  }
}


void test_basename(test::Suite& suite)
{
  std::vector<std::string> path;
  path.push_back("/usr/lib");
  path.push_back("/usr/");
  path.push_back("usr");
  path.push_back("/");
  path.push_back(".");
  path.push_back("..");
  std::vector<std::string> file;
  file.push_back("lib");
  file.push_back("usr");
  file.push_back("usr");
  file.push_back("/");
  file.push_back(".");
  file.push_back("..");
  assert(file.size()==path.size());
  using utility::basename;
  for (size_t i=0; i<file.size(); ++i) {
    if (file[i] != basename(path[i])) {
      suite.add(false);
      suite.out() << "error:\n";
      suite.out() << "path:           " << path[i] << "\n";
      suite.out() << "basename:       " << basename(path[i]) << "\n";
      suite.out() << "expected:       " << file[i] << "\n";
    }
  }
}


bool test_fnmatch(bool answ, std::string a, std::string b)
{
  using namespace utility;
  bool res = fnmatch(a, b);
  // check that fnmatch and regexp agree
  if (res == answ)
    return true;
  if (res!=answ)
    std::cerr << "fnmatch(" << a << ", " << b << ") results "
              << res
              << ". Expects " << answ << std::endl;
  return false;
}


void test_remove(test::Suite& suite)
{
  // at least test linking
  if (false)
    utility::remove("foo");
}


void test_rename(test::Suite& suite)
{
  // at least test linking
  if (false)
    utility::rename("foo", "bar");
}


void test_replace(test::Suite& suite)
{
  std::string s = "Some magic string!!!";
  utility::replace(s, "magic", "arbitrary");
  if (!suite.add(s=="Some arbitrary string!!!"))
    suite.err() << "error: " << s << "\n";
}