source: trunk/test/utility.cc @ 4102

// $Id: utility.cc 4102 2021-09-22 07:50:18Z 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, 2015, 2016, 2017, 2018, 2019 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_binary_weight(void);
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_contains(test::Suite& suite);
void test_dirname(test::Suite& suite);
void test_ends_with(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_getcwd(test::Suite& suite);
void test_remove(test::Suite& suite);
void test_rename(test::Suite& suite);
void test_replace(test::Suite& suite);
void test_starts_with(test::Suite& suite);
void test_symlink(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);
void test_ticket842(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";
  }
  double result;
  if (!suite.add(utility::convert_try<double>("3.14", result)))
    suite.err() << "convert_tr<double>(\"3.14\", ...) failed\n";
  if (!suite.add(!utility::convert_try<double>("3.14xx", result)))
    suite.err() << "convert_tr<double>(\"3.14xx\", ...) succeeded\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));

  std::vector<std::string> vec(1, "text");
  utility::clear(vec);
  suite.add(vec.size()==0);

  test_basename(suite);
  test_binary_weight();
  test_dirname(suite);
  test_fnmatch(suite);
  test_getcwd(suite);
  test_remove(suite);
  test_rename(suite);
  test_replace(suite);
  test_symlink(suite);
  test_ticket842(suite);
  test_starts_with(suite);
  test_contains(suite);
  test_ends_with(suite);

  return suite.return_value();
}


void test_binary_weight(void)
{
  // do not run compilation test
  return;
  // this does not work, see ticket #865
  // boost::input_iterator_archetype<double> in;
  boost::input_iterator_archetype_no_proxy<double> in;
  boost::detail::dummy_constructor arg;
  boost::output_iterator_archetype<double> out(arg);
  utility::binary_weight(in, in, out);
}


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

}


template<typename Access, typename Traversal>
void test_sort_index2(Access access, Traversal traversal)
{
  typedef boost::default_constructible_archetype<
    boost::sgi_assignable_archetype<
      boost::less_than_comparable_archetype<> > > Value;
  boost::iterator_archetype<Value, Access, Traversal> iterator;
  std::vector<size_t> index;
  utility::sort_index(iterator, iterator, index);

  typedef boost::default_constructible_archetype<
    boost::sgi_assignable_archetype<> > Value2;
  boost::iterator_archetype<Value2, Access, Traversal> iterator2;
  typedef boost::default_constructible_archetype<
    boost::binary_predicate_archetype<Value2, Value2>
    > Compare;
  Compare comp;
  utility::sort_index(iterator2, iterator2, index, comp);
}


template<typename Access>
void test_sort_index2(Access access)
{
  // cannot create iterator_archetype w incrementable_traversal_tag
  //test_sort_index2(access, boost::incrementable_traversal_tag());
  test_sort_index2(access, boost::forward_traversal_tag());
  test_sort_index2(access, boost::bidirectional_traversal_tag());
  test_sort_index2(access, boost::random_access_traversal_tag());
}


void test_sort_index2(void)
{
  using namespace boost::iterator_archetypes;

  test_sort_index2(readable_iterator_t());
  test_sort_index2(readable_writable_iterator_t());
  test_sort_index2(writable_lvalue_iterator_t());
}


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

  test_sort_index2();
}


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("..");
  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(".");
  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("..");
  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("..");
  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_getcwd(test::Suite& suite)
{
  std::string cwd = utility::getcwd();
  suite.out() << "cwd: " << cwd << "\n";
  if (cwd.find("/test/testSubDir/") == std::string::npos) {
    suite.add(false);
    suite.err() << "error: cwd: expect path to contain 'test/testSubDir/'\n";
  }
}


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


void test_symlink(test::Suite& suite)
{
  // at least test function links
  if (false)
    utility::symlink("/from/to/path", "my/symlink");
}


void test_ticket842(test::Suite& suite)
{
  suite.out() << "test_ticket842\n";
  std::vector<std::pair<std::string, int> > data;
  data.push_back(std::make_pair("Orange", 2));
  data.push_back(std::make_pair("Orange", 1));
  data.push_back(std::make_pair("Apple", 10));

  typedef utility::PairFirst<const std::pair<std::string, int> > PF;
  typedef std::less<std::string> strLess;
  utility::compose_f_gx_hy<strLess, PF, PF> compare;
  // stable sort should shuffle 'Apple' first, and then keep the order
  // of the equaivalent 'Orange' elements, i.e., <Orange, 2> should stay
  // before <Orange, 1>.
  std::stable_sort(data.begin(), data.end(), compare);
  if (!suite.add(data[0].first == "Apple"))
    suite.err() << "incorrect data[0].first: " << data[0].first << "\n";
  if (!suite.add(data[1].first == "Orange"))
    suite.err() << "incorrect data[1].first: " << data[1].first << "\n";
  if (!suite.add(data[1].second == 2))
    suite.err() << "incorrect data[1].second: " << data[1].second << "\n";
}


void test_starts_with(test::Suite& suite)
{
  std::string name("Jane Doe");
  if (!utility::starts_with(name, "Jane")) {
    suite.add(false);
    suite.err() << "error: 'Jane Doe' does not start with 'Jane'\n";
  }
  if (!utility::starts_with(name, 'J')) {
    suite.add(false);
    suite.err() << "error: starts_with(x,x) failed\n";
  }
  if (!utility::starts_with(name, name)) {
    suite.add(false);
    suite.err() << "error: starts_with(x,x) failed\n";
  }
}


void test_contains(test::Suite& suite)
{
  std::string name("Jane Doe");
  if (!utility::contains(name, "ne")) {
    suite.add(false);
    suite.err() << "error: " << name << " does not contain \"ne\"\n";
  }
  if (!utility::contains(name, name)) {
    suite.add(false);
    suite.err() << "error: contains(x,x) failed\n";
  }
  if (!utility::contains(name, 'D')) {
    suite.add(false);
    suite.err() << "error: contains(string,char) failed\n";
  }
}


void test_ends_with(test::Suite& suite)
{
  std::string name("Jane Doe");
  if (!utility::ends_with(name, name)) {
    suite.add(false);
    suite.err() << "error: ends_with(x,x) failed\n";
  }
  if (!utility::ends_with(name, 'e')) {
    suite.add(false);
    suite.err() << "error: ends_with(x,x) failed\n";
  }
  if (!utility::ends_with(name, "Doe")) {
    suite.add(false);
    suite.err() << "error: 'Jane Doe' does not end with 'Doe'\n";
  }
}