source: branches/0.10-stable/test/utility.cc @ 2926

// $Id: utility.cc 2926 2012-12-20 11:06:07Z jari $

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

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_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");

  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_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);

  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 =
    utility::make_compose_f_gx_hy(b, u1, u2);

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

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


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"));
  i = 0; // 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";
  }
}

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) {
    std::vector<size_t> vec;
    utility::sort_index(boost::forward_iterator_archetype<double>(),
                        boost::forward_iterator_archetype<double>(),
                        vec);
  }
}

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;
}