test/utility.cc

Code
Comments
Other
Rev Date Author Line
609 30 Aug 06 markus 1 // $Id$
609 30 Aug 06 markus 2
675 10 Oct 06 jari 3 /*
2119 12 Dec 09 peter 4   Copyright (C) 2006 Jari Häkkinen, Markus Ringnér
2119 12 Dec 09 peter 5   Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson
4207 26 Aug 22 peter 6   Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2021 Peter Johansson
609 30 Aug 06 markus 7
1437 25 Aug 08 peter 8   This file is part of the yat library, http://dev.thep.lu.se/yat
675 10 Oct 06 jari 9
675 10 Oct 06 jari 10   The yat library is free software; you can redistribute it and/or
675 10 Oct 06 jari 11   modify it under the terms of the GNU General Public License as
1486 09 Sep 08 jari 12   published by the Free Software Foundation; either version 3 of the
675 10 Oct 06 jari 13   License, or (at your option) any later version.
675 10 Oct 06 jari 14
675 10 Oct 06 jari 15   The yat library is distributed in the hope that it will be useful,
675 10 Oct 06 jari 16   but WITHOUT ANY WARRANTY; without even the implied warranty of
675 10 Oct 06 jari 17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
675 10 Oct 06 jari 18   General Public License for more details.
675 10 Oct 06 jari 19
675 10 Oct 06 jari 20   You should have received a copy of the GNU General Public License
1487 10 Sep 08 jari 21   along with yat. If not, see <http://www.gnu.org/licenses/>.
675 10 Oct 06 jari 22 */
675 10 Oct 06 jari 23
2881 18 Nov 12 peter 24 #include <config.h>
2881 18 Nov 12 peter 25
1248 19 Mar 08 peter 26 #include "Suite.h"
1248 19 Mar 08 peter 27
2209 05 Mar 10 peter 28 #include "yat/utility/Exception.h"
1304 14 May 08 peter 29 #include "yat/utility/Matrix.h"
676 10 Oct 06 jari 30 #include "yat/utility/utility.h"
1491 11 Sep 08 peter 31 #include "yat/utility/Vector.h"
1491 11 Sep 08 peter 32 #include "yat/utility/VectorConstView.h"
1491 11 Sep 08 peter 33 #include "yat/utility/sort_index.h"
1288 24 Apr 08 peter 34 #include "yat/utility/stl_utility.h"
675 10 Oct 06 jari 35
2202 21 Feb 10 peter 36 #include <boost/concept_archetype.hpp>
3285 11 Jul 14 peter 37 #include <boost/iterator/iterator_archetypes.hpp>
2202 21 Feb 10 peter 38
2943 04 Jan 13 peter 39 #include <cassert>
2209 05 Mar 10 peter 40 #include <cerrno>
609 30 Aug 06 markus 41 #include <fstream>
609 30 Aug 06 markus 42 #include <iostream>
1966 08 May 09 peter 43 #include <limits>
1492 12 Sep 08 peter 44 #include <list>
1385 22 Jul 08 peter 45 #include <map>
609 30 Aug 06 markus 46 #include <string>
1385 22 Jul 08 peter 47 #include <vector>
609 30 Aug 06 markus 48
1304 14 May 08 peter 49 using namespace theplu::yat;
3507 19 Jul 16 peter 50 void test_binary_weight(void);
2209 05 Mar 10 peter 51 void test_errno_error(test::Suite& suite);
2209 05 Mar 10 peter 52 void test_errno_error_func(void);
2181 02 Feb 10 peter 53 void test_get_map(test::Suite&);
2248 22 Apr 10 peter 54 void test_load(test::Suite&);
2273 15 Jun 10 peter 55 void test_load2(test::Suite&);
1385 22 Jul 08 peter 56 void test_inverse(test::Suite&);
1304 14 May 08 peter 57
4102 22 Sep 21 peter 58 void test_contains(test::Suite& suite);
2908 15 Dec 12 peter 59 void test_dirname(test::Suite& suite);
4102 22 Sep 21 peter 60 void test_ends_with(test::Suite& suite);
2908 15 Dec 12 peter 61 void test_basename(test::Suite& suite);
2908 15 Dec 12 peter 62 void test_fnmatch(test::Suite& suite);
2908 15 Dec 12 peter 63 bool test_fnmatch(bool, std::string, std::string);
3803 12 May 19 peter 64 void test_getcwd(test::Suite& suite);
3295 25 Jul 14 peter 65 void test_remove(test::Suite& suite);
3295 25 Jul 14 peter 66 void test_rename(test::Suite& suite);
3098 28 Oct 13 peter 67 void test_replace(test::Suite& suite);
4102 22 Sep 21 peter 68 void test_starts_with(test::Suite& suite);
3746 13 Aug 18 peter 69 void test_symlink(test::Suite& suite);
2908 15 Dec 12 peter 70
1385 22 Jul 08 peter 71 template<typename InputIterator, typename Key>
1385 22 Jul 08 peter 72 void test_inverse_validate(InputIterator first, InputIterator last,
1385 22 Jul 08 peter 73                            const std::map<Key, std::vector<size_t> >& m,
1385 22 Jul 08 peter 74                            test::Suite& suite);
1385 22 Jul 08 peter 75 template<typename InputIterator, typename Key>
1385 22 Jul 08 peter 76 void test_inverse_validate(InputIterator first,
1385 22 Jul 08 peter 77                            const std::multimap<Key, size_t>& m,
1385 22 Jul 08 peter 78                            test::Suite& suite);
1385 22 Jul 08 peter 79
1491 11 Sep 08 peter 80 void test_sort_index(test::Suite& suite);
3287 12 Jul 14 peter 81 void test_sum_weight(test::Suite& suite);
1966 08 May 09 peter 82 void test_less_nan(test::Suite& suite);
2239 10 Apr 10 peter 83 void test_ptr_compare(test::Suite& suite);
2274 22 Jun 10 peter 84 void test_compose_functors(test::Suite& suite);
2285 27 Jun 10 peter 85 void test_dereferencer(test::Suite& suite);
3466 10 Feb 16 peter 86 void test_ticket842(test::Suite& suite);
1491 11 Sep 08 peter 87
1248 19 Mar 08 peter 88 int main(int argc, char* argv[])
2673 03 Dec 11 peter 89 {
680 11 Oct 06 jari 90   using namespace theplu::yat;
1248 19 Mar 08 peter 91   test::Suite suite(argc, argv);
1248 19 Mar 08 peter 92   suite.err() << "testing utility ... " << std::endl;
609 30 Aug 06 markus 93
609 30 Aug 06 markus 94   // test float/double
609 30 Aug 06 markus 95   std::string s("1.2");
1500 15 Sep 08 peter 96   if (!utility::is<double>(s)){
1248 19 Mar 08 peter 97     suite.add(false);
609 30 Aug 06 markus 98   }
1500 15 Sep 08 peter 99   else if (!utility::is<float>(s)) {
1248 19 Mar 08 peter 100     suite.add(false);
609 30 Aug 06 markus 101   }
1500 15 Sep 08 peter 102   else if (utility::is<int>(s)) {
1248 19 Mar 08 peter 103     suite.add(false);
609 30 Aug 06 markus 104   }
609 30 Aug 06 markus 105   else if (utility::is_nan(s)) {
1248 19 Mar 08 peter 106     suite.add(false);
609 30 Aug 06 markus 107   }
609 30 Aug 06 markus 108
609 30 Aug 06 markus 109   // test int
609 30 Aug 06 markus 110   s="23";
1500 15 Sep 08 peter 111   if (!utility::is<double>(s)){
1248 19 Mar 08 peter 112     suite.add(false);
609 30 Aug 06 markus 113   }
1500 15 Sep 08 peter 114   else if (!utility::is<float>(s)) {
1248 19 Mar 08 peter 115     suite.add(false);
609 30 Aug 06 markus 116   }
1500 15 Sep 08 peter 117   else if (!utility::is<int>(s)) {
1248 19 Mar 08 peter 118     suite.add(false);
609 30 Aug 06 markus 119   }
609 30 Aug 06 markus 120   else if (utility::is_nan(s)) {
1248 19 Mar 08 peter 121     suite.add(false);
609 30 Aug 06 markus 122   }
609 30 Aug 06 markus 123
609 30 Aug 06 markus 124   // test nan
609 30 Aug 06 markus 125   s=" nAn  ";
1500 15 Sep 08 peter 126   if (!utility::is<double>(s)){
1248 19 Mar 08 peter 127     suite.add(false);
1312 19 May 08 peter 128     suite.err() << "error: " << s << " is a double\n";
609 30 Aug 06 markus 129   }
1312 19 May 08 peter 130   /* we don't require NaN for float and int
918 30 Sep 07 peter 131   else if (!utility::is_float(s)) {
1248 19 Mar 08 peter 132     suite.add(false);
1312 19 May 08 peter 133     suite.err() << "error: " << s << " is a float\n";
609 30 Aug 06 markus 134   }
918 30 Sep 07 peter 135   else if (!utility::is_int(s)) {
1248 19 Mar 08 peter 136     suite.add(false);
1312 19 May 08 peter 137     suite.err() << "error: " << s << " is a int\n";
609 30 Aug 06 markus 138   }
1312 19 May 08 peter 139   */
609 30 Aug 06 markus 140   else if (!utility::is_nan(s)) {
1248 19 Mar 08 peter 141     suite.add(false);
1312 19 May 08 peter 142     suite.err() << "error: " << s << " is nan\n";
1312 19 May 08 peter 143
609 30 Aug 06 markus 144   }
2673 03 Dec 11 peter 145
609 30 Aug 06 markus 146   // testing trailing values
609 30 Aug 06 markus 147   s=" 23 23   ";
1500 15 Sep 08 peter 148   if (utility::is<double>(s)){
1248 19 Mar 08 peter 149     suite.add(false);
609 30 Aug 06 markus 150   }
1500 15 Sep 08 peter 151   else if (utility::is<float>(s)) {
1248 19 Mar 08 peter 152     suite.add(false);
609 30 Aug 06 markus 153   }
1500 15 Sep 08 peter 154   else if (utility::is<int>(s)) {
1248 19 Mar 08 peter 155     suite.add(false);
609 30 Aug 06 markus 156   }
609 30 Aug 06 markus 157   else if (utility::is_nan(s)) {
1248 19 Mar 08 peter 158     suite.add(false);
609 30 Aug 06 markus 159   }
609 30 Aug 06 markus 160
1195 29 Feb 08 peter 161   if (utility::convert<double>("1.23")!=1.23)
1248 19 Mar 08 peter 162     suite.add(false);
1195 29 Feb 08 peter 163   utility::convert<double>("-inf");
1195 29 Feb 08 peter 164   utility::convert<double>("inf");
1195 29 Feb 08 peter 165   utility::convert<double>("NaN");
3177 15 Mar 14 peter 166   utility::convert<double>("-NaN");
3177 15 Mar 14 peter 167   utility::convert<double>(" -NaN");
609 30 Aug 06 markus 168
2426 13 Feb 11 peter 169   suite.add(utility::convert(1.23)=="1.23");
2426 13 Feb 11 peter 170   suite.add(utility::convert(1)=="1");
2426 13 Feb 11 peter 171
2673 03 Dec 11 peter 172   suite.add(utility::is<unsigned int>("1"));
2673 03 Dec 11 peter 173   suite.add(!utility::is<unsigned int>("   "));
2673 03 Dec 11 peter 174   suite.add(!utility::is<unsigned int>("   -1"));
2673 03 Dec 11 peter 175   // test -1 cannot be assigned to unsigned int
2673 03 Dec 11 peter 176   try {
2673 03 Dec 11 peter 177     unsigned int x = utility::convert<unsigned int>("-1");
2673 03 Dec 11 peter 178     suite.err() << "convert<unsigned>(\"-1\") did not throw\n";
2673 03 Dec 11 peter 179     suite.err() << "x: " << x << "\n";
2673 03 Dec 11 peter 180     suite.add(false);
2673 03 Dec 11 peter 181     exit(1);
2673 03 Dec 11 peter 182   }
2673 03 Dec 11 peter 183   catch (std::runtime_error& e) {
2673 03 Dec 11 peter 184     suite.out() << "expected error: " << e.what() << "\n";
2673 03 Dec 11 peter 185   }
3597 22 Jan 17 peter 186   double result;
3597 22 Jan 17 peter 187   if (!suite.add(utility::convert_try<double>("3.14", result)))
3597 22 Jan 17 peter 188     suite.err() << "convert_tr<double>(\"3.14\", ...) failed\n";
3597 22 Jan 17 peter 189   if (!suite.add(!utility::convert_try<double>("3.14xx", result)))
3597 22 Jan 17 peter 190     suite.err() << "convert_tr<double>(\"3.14xx\", ...) succeeded\n";
2673 03 Dec 11 peter 191
1312 19 May 08 peter 192   if (!suite.add(utility::is<double>("-inf")))
1312 19 May 08 peter 193     suite.err() << "is<double>(\"-inf\") should return true\n";
1312 19 May 08 peter 194   if (!suite.add(utility::is<double>("inf")))
1312 19 May 08 peter 195     suite.err() << "is<double>(\"inf\") should return true\n";
1312 19 May 08 peter 196   if (!suite.add(utility::is<double>("NaN")))
1312 19 May 08 peter 197     suite.err() << "is<double>(\"NaN\") should return true\n";
1312 19 May 08 peter 198   if (!suite.add(utility::is<double>("1.23")))
1312 19 May 08 peter 199     suite.err() << "is<double>(\"1.23\") should return true\n";
1312 19 May 08 peter 200   if (!suite.add(!utility::is<double>("1.23.2")))
1312 19 May 08 peter 201     suite.err() << "is<double>(\"1.23.2\") should return false\n";
1312 19 May 08 peter 202   if (!suite.add(!utility::is<int>("1.23")))
1313 19 May 08 peter 203     suite.err() << "is<int>(\"1.23\") should return false\n";
1313 19 May 08 peter 204   if (!suite.add(!utility::is<int>("")))
1313 19 May 08 peter 205     suite.err() << "is<int>(\"\") should return false\n";
1312 19 May 08 peter 206
1288 24 Apr 08 peter 207   {
1289 26 Apr 08 peter 208     utility::Log<long double> f;
1289 26 Apr 08 peter 209     utility::Log<double> f2(1.3);
1288 24 Apr 08 peter 210     f(2.0);
1289 26 Apr 08 peter 211     utility::Exp<double> e;
1288 24 Apr 08 peter 212     e(3.2);
1288 24 Apr 08 peter 213   }
1288 24 Apr 08 peter 214
2181 02 Feb 10 peter 215   test_get_map(suite);
1385 22 Jul 08 peter 216   test_inverse(suite);
1491 11 Sep 08 peter 217   test_sort_index(suite);
3287 12 Jul 14 peter 218   test_sum_weight(suite);
1966 08 May 09 peter 219   test_less_nan(suite);
2209 05 Mar 10 peter 220   test_errno_error(suite);
2239 10 Apr 10 peter 221   test_ptr_compare(suite);
2248 22 Apr 10 peter 222   test_load(suite);
2273 15 Jun 10 peter 223   test_load2(suite);
1304 14 May 08 peter 224
2274 22 Jun 10 peter 225   test_compose_functors(suite);
2274 22 Jun 10 peter 226
2867 12 Nov 12 peter 227   double x = 8.0;
2867 12 Nov 12 peter 228   suite.add(suite.equal(utility::log2(x), 3.0));
2867 12 Nov 12 peter 229   float xf = x;
2867 12 Nov 12 peter 230   suite.add(suite.equal(utility::log2(xf), 3.0));
2867 12 Nov 12 peter 231   long double xld = 8.0;
2867 12 Nov 12 peter 232   suite.add(suite.equal(utility::log2(xld), 3.0));
2867 12 Nov 12 peter 233
3404 03 Apr 15 peter 234   std::vector<std::string> vec(1, "text");
3404 03 Apr 15 peter 235   utility::clear(vec);
3404 03 Apr 15 peter 236   suite.add(vec.size()==0);
3404 03 Apr 15 peter 237
2908 15 Dec 12 peter 238   test_basename(suite);
3507 19 Jul 16 peter 239   test_binary_weight();
2908 15 Dec 12 peter 240   test_dirname(suite);
2908 15 Dec 12 peter 241   test_fnmatch(suite);
3803 12 May 19 peter 242   test_getcwd(suite);
3295 25 Jul 14 peter 243   test_remove(suite);
3295 25 Jul 14 peter 244   test_rename(suite);
3098 28 Oct 13 peter 245   test_replace(suite);
3746 13 Aug 18 peter 246   test_symlink(suite);
3466 10 Feb 16 peter 247   test_ticket842(suite);
4102 22 Sep 21 peter 248   test_starts_with(suite);
4102 22 Sep 21 peter 249   test_contains(suite);
4102 22 Sep 21 peter 250   test_ends_with(suite);
2908 15 Dec 12 peter 251
1248 19 Mar 08 peter 252   return suite.return_value();
609 30 Aug 06 markus 253 }
1304 14 May 08 peter 254
1385 22 Jul 08 peter 255
3507 19 Jul 16 peter 256 void test_binary_weight(void)
3507 19 Jul 16 peter 257 {
3507 19 Jul 16 peter 258   // do not run compilation test
3507 19 Jul 16 peter 259   return;
3507 19 Jul 16 peter 260   // this does not work, see ticket #865
3507 19 Jul 16 peter 261   // boost::input_iterator_archetype<double> in;
3507 19 Jul 16 peter 262   boost::input_iterator_archetype_no_proxy<double> in;
3507 19 Jul 16 peter 263   boost::detail::dummy_constructor arg;
3507 19 Jul 16 peter 264   boost::output_iterator_archetype<double> out(arg);
3507 19 Jul 16 peter 265   utility::binary_weight(in, in, out);
3507 19 Jul 16 peter 266 }
3507 19 Jul 16 peter 267
3507 19 Jul 16 peter 268
2209 05 Mar 10 peter 269 void test_errno_error_func(void)
2209 05 Mar 10 peter 270 {
2209 05 Mar 10 peter 271   errno=1;
2209 05 Mar 10 peter 272   throw utility::errno_error("");
2209 05 Mar 10 peter 273 }
2209 05 Mar 10 peter 274
2209 05 Mar 10 peter 275
2209 05 Mar 10 peter 276 void test_errno_error(test::Suite& suite)
2209 05 Mar 10 peter 277 {
2209 05 Mar 10 peter 278   suite.out() << "testing errno_error\n";
2209 05 Mar 10 peter 279   try {
2209 05 Mar 10 peter 280     test_errno_error_func();
2209 05 Mar 10 peter 281   }
2209 05 Mar 10 peter 282   catch ( utility::errno_error& e) {
2209 05 Mar 10 peter 283     suite.out() << "catching expected exception with what():\n";
2209 05 Mar 10 peter 284     suite.out() << e.what() << "\n";
2209 05 Mar 10 peter 285     return;
2209 05 Mar 10 peter 286   }
2209 05 Mar 10 peter 287   suite.err() << "error: expected thrown exception\n";
2209 05 Mar 10 peter 288   suite.add(false);
2209 05 Mar 10 peter 289 }
2209 05 Mar 10 peter 290
2209 05 Mar 10 peter 291
2274 22 Jun 10 peter 292 void test_compose_functors(test::Suite& suite)
2274 22 Jun 10 peter 293 {
2274 22 Jun 10 peter 294   typedef utility::abs<double> U1;
2274 22 Jun 10 peter 295   // we use float here to check conversion from float to double in functors
2274 22 Jun 10 peter 296   typedef utility::Exp<float> U2;
2274 22 Jun 10 peter 297   typedef std::plus<double> B;
2274 22 Jun 10 peter 298   U1 u1;
2274 22 Jun 10 peter 299   U2 u2;
2274 22 Jun 10 peter 300   B b;
2274 22 Jun 10 peter 301
2963 21 Jan 13 peter 302   utility::compose_f_gx_hy<B, U1, U2> binary;
2963 21 Jan 13 peter 303   binary = utility::make_compose_f_gx_hy(b, u1, u2);
2274 22 Jun 10 peter 304
2963 21 Jan 13 peter 305   utility::compose_f_gxy<U2, B> binary2;
2963 21 Jan 13 peter 306   binary2 = utility::make_compose_f_gxy(u2, b);
2274 22 Jun 10 peter 307
2963 21 Jan 13 peter 308   utility::compose_f_gx<U1, U2> unary;
2963 21 Jan 13 peter 309   unary = utility::make_compose_f_gx(u1, u2);
3082 18 Sep 13 peter 310
3082 18 Sep 13 peter 311   utility::compose_f_gx_hx<B, U1, U2> unary2;
3082 18 Sep 13 peter 312   unary2 = utility::make_compose_f_gx_hx(b, u1, u2);
3082 18 Sep 13 peter 313   if (!suite.add(suite.equal_fix(unary2(-2.0), 2.0 + std::exp(-2.0),1e-8)))
3082 18 Sep 13 peter 314     suite.err() << "compose_f_gx_hx failed\n";
2274 22 Jun 10 peter 315 }
2274 22 Jun 10 peter 316
2274 22 Jun 10 peter 317
2285 27 Jun 10 peter 318 void test_dereferencer(test::Suite& suite)
2285 27 Jun 10 peter 319 {
2285 27 Jun 10 peter 320   using utility::Dereferencer;
2285 27 Jun 10 peter 321   Dereferencer<double*> deref;
2285 27 Jun 10 peter 322   double x = 0;
2285 27 Jun 10 peter 323   double* px = &x;
2285 27 Jun 10 peter 324   deref(px) = 1.662;
2285 27 Jun 10 peter 325   if (!suite.add(x==1.662)) {
2285 27 Jun 10 peter 326     suite.out() << "test_dereferencer failed: x: " << x << "\n";
2285 27 Jun 10 peter 327   }
2285 27 Jun 10 peter 328 }
2274 22 Jun 10 peter 329
2285 27 Jun 10 peter 330
2181 02 Feb 10 peter 331 void test_get_map(test::Suite& suite)
2181 02 Feb 10 peter 332 {
2181 02 Feb 10 peter 333   std::map<std::string, int> m;
2181 02 Feb 10 peter 334   m["one"] = 1;
2181 02 Feb 10 peter 335   m["two"] = 2;
2181 02 Feb 10 peter 336   const std::map<std::string, int> m2(m);
2181 02 Feb 10 peter 337   int i = utility::get(m2, static_cast<std::string>("one"));
3322 06 Oct 14 peter 338   test::avoid_compiler_warning(i); // avoid compiler warning
2181 02 Feb 10 peter 339   try {
2181 02 Feb 10 peter 340     utility::get(m2, static_cast<std::string>("three"));
2181 02 Feb 10 peter 341     suite.add(false);
2181 02 Feb 10 peter 342   }
2181 02 Feb 10 peter 343   catch (std::runtime_error& e) {
2673 03 Dec 11 peter 344     suite.out() << "expected exception thrown with what() = "
2181 02 Feb 10 peter 345                 << e.what() << "\n";
2181 02 Feb 10 peter 346   }
3254 09 Jun 14 peter 347   // test ticket #799
3254 09 Jun 14 peter 348   if (!suite.add(utility::get(m, "one")==1))
3254 09 Jun 14 peter 349     suite.err() << "get(m, \"one\")!=1\n";
3254 09 Jun 14 peter 350
3253 07 Jun 14 peter 351   // don't run compiler test code
3253 07 Jun 14 peter 352   if (false) {
3253 07 Jun 14 peter 353     typedef boost::default_constructible_archetype<
3253 07 Jun 14 peter 354       boost::sgi_assignable_archetype<>  > key_type;
3253 07 Jun 14 peter 355
3253 07 Jun 14 peter 356     typedef boost::default_constructible_archetype<
3253 07 Jun 14 peter 357       boost::sgi_assignable_archetype<
3253 07 Jun 14 peter 358         boost::null_archetype<std::string> > > value_type;
3253 07 Jun 14 peter 359
3253 07 Jun 14 peter 360     typedef boost::default_constructible_archetype<
3253 07 Jun 14 peter 361       boost::binary_function_archetype<key_type, key_type, bool> > Compare;
3253 07 Jun 14 peter 362
3253 07 Jun 14 peter 363     std::map<key_type, value_type, Compare> m3;
3254 09 Jun 14 peter 364
3254 09 Jun 14 peter 365     // create an object that is convertible to key_type
3254 09 Jun 14 peter 366     boost::detail::dummy_constructor x;
3254 09 Jun 14 peter 367     boost::convertible_to_archetype<key_type> my_key(x);
3253 07 Jun 14 peter 368     utility::get(m3, my_key);
3253 07 Jun 14 peter 369   }
2181 02 Feb 10 peter 370 }
2181 02 Feb 10 peter 371
1966 08 May 09 peter 372 void test_less_nan(test::Suite& suite)
1966 08 May 09 peter 373 {
2273 15 Jun 10 peter 374   suite.out() << "test less_nan\n";
1966 08 May 09 peter 375   bool prior_ok=suite.ok();
1966 08 May 09 peter 376   utility::less_nan<double> f;
1966 08 May 09 peter 377   suite.add(f(2.7,3.14));
1966 08 May 09 peter 378   suite.add(!f(2.7,-3.14));
1966 08 May 09 peter 379   suite.add(!f(2.7,2.7));
1966 08 May 09 peter 380   suite.add(f(3.14, std::numeric_limits<double>::quiet_NaN()));
1966 08 May 09 peter 381   suite.add(!f(std::numeric_limits<double>::quiet_NaN(), 2.7));
1966 08 May 09 peter 382   suite.add(!f(std::numeric_limits<double>::quiet_NaN(),
1966 08 May 09 peter 383                std::numeric_limits<double>::quiet_NaN()));
1970 11 May 09 peter 384   utility::less_nan<utility::DataWeight> fw;
1972 12 May 09 peter 385   suite.add(fw(utility::DataWeight(2), utility::DataWeight(3)));
1970 11 May 09 peter 386
1966 08 May 09 peter 387   bool post_ok=suite.ok();
1966 08 May 09 peter 388   if (!post_ok && prior_ok)
1966 08 May 09 peter 389     suite.err() << "test_less_nan failed\n";
1966 08 May 09 peter 390 }
1966 08 May 09 peter 391
1966 08 May 09 peter 392
2248 22 Apr 10 peter 393 void test_load(test::Suite& suite)
2248 22 Apr 10 peter 394 {
2248 22 Apr 10 peter 395   std::istringstream iss(std::string("1.69 3.14"));
2248 22 Apr 10 peter 396   std::vector<double> double_vec;
2248 22 Apr 10 peter 397   utility::load(iss, double_vec);
2248 22 Apr 10 peter 398   suite.add(double_vec.size()==2);
2248 22 Apr 10 peter 399
2248 22 Apr 10 peter 400   std::istringstream iss2(std::string("1 2"));
2248 22 Apr 10 peter 401   std::vector<double> uint_vec;
2248 22 Apr 10 peter 402   utility::load(iss2, uint_vec);
2248 22 Apr 10 peter 403   suite.add(uint_vec.size()==2);
2248 22 Apr 10 peter 404
2248 22 Apr 10 peter 405   std::istringstream iss3(std::string("1.69 3.14"));
2248 22 Apr 10 peter 406   std::vector<std::string> str_vec;
2248 22 Apr 10 peter 407   utility::load(iss3, str_vec);
2248 22 Apr 10 peter 408   if (str_vec.size()==2) {
2248 22 Apr 10 peter 409     if (str_vec[1]!="3.14") {
2248 22 Apr 10 peter 410       suite.out() << "error: load<string>:" << "\n"
2248 22 Apr 10 peter 411                   << "  str_vec[1] = " << str_vec[1] << "\n"
2248 22 Apr 10 peter 412                   << "  expected:  3.14n";
2248 22 Apr 10 peter 413       suite.add(false);
2248 22 Apr 10 peter 414     }
2248 22 Apr 10 peter 415   }
2248 22 Apr 10 peter 416   else {
2248 22 Apr 10 peter 417     suite.out() << "str_vec.size() is not 2\n";
2248 22 Apr 10 peter 418     suite.add(false);
2248 22 Apr 10 peter 419   }
2248 22 Apr 10 peter 420 }
2248 22 Apr 10 peter 421
2248 22 Apr 10 peter 422
2273 15 Jun 10 peter 423 void test_load2(test::Suite& suite)
2273 15 Jun 10 peter 424 {
2273 15 Jun 10 peter 425   suite.out() << "test load<double>(matrix)\n";
2273 15 Jun 10 peter 426   std::string str("1.69 3.14\n1.23 1.22\n");
2273 15 Jun 10 peter 427   std::istringstream iss(str);
2273 15 Jun 10 peter 428   std::vector<std::vector<double> > double_m;
2673 03 Dec 11 peter 429   utility::load(iss, double_m, '\0', '\n');
2273 15 Jun 10 peter 430   suite.add(double_m.size()==2);
2273 15 Jun 10 peter 431
2273 15 Jun 10 peter 432   suite.out() << "test load<std::string>(matrix)\n";
2273 15 Jun 10 peter 433   suite.out() << str;
2273 15 Jun 10 peter 434   std::istringstream iss2(str);
2273 15 Jun 10 peter 435   std::vector<std::vector<std::string> > str_m;
2673 03 Dec 11 peter 436   utility::load(iss2, str_m, '\0', '\n');
2273 15 Jun 10 peter 437   std::cout << str_m.size() << std::endl;
2273 15 Jun 10 peter 438   for (size_t i=0; i<str_m.size(); ++i)
2273 15 Jun 10 peter 439     for (size_t j=0; j<str_m[i].size(); ++j)
2273 15 Jun 10 peter 440       suite.out() << str_m[i][j] << "\n";
2273 15 Jun 10 peter 441   suite.add(str_m.size()==2);
2273 15 Jun 10 peter 442 }
2273 15 Jun 10 peter 443
2273 15 Jun 10 peter 444
1385 22 Jul 08 peter 445 void test_inverse(test::Suite& suite)
1385 22 Jul 08 peter 446 {
1385 22 Jul 08 peter 447   suite.err() << "Testing inverse\n";
1385 22 Jul 08 peter 448   std::vector<std::string> vec;
1385 22 Jul 08 peter 449   vec.push_back("No");
1385 22 Jul 08 peter 450   vec.push_back("one");
1385 22 Jul 08 peter 451   vec.push_back("shall");
1385 22 Jul 08 peter 452   vec.push_back("be");
1385 22 Jul 08 peter 453   vec.push_back("subjected");
1385 22 Jul 08 peter 454   std::map<std::string, std::vector<size_t> > map;
1385 22 Jul 08 peter 455   utility::inverse(vec.begin(), vec.end(), map);
1385 22 Jul 08 peter 456   test_inverse_validate(vec.begin(), vec.end(), map, suite);
1385 22 Jul 08 peter 457   utility::inverse(vec.begin()+1, vec.end(), map);
1385 22 Jul 08 peter 458   test_inverse_validate(vec.begin()+1, vec.end(), map, suite);
1385 22 Jul 08 peter 459   const std::vector<std::string> vec2(vec);
1385 22 Jul 08 peter 460   utility::inverse(vec2.begin(), vec2.end(), map);
1385 22 Jul 08 peter 461   test_inverse_validate(vec2.begin(), vec2.end(), map, suite);
1385 22 Jul 08 peter 462   std::multimap<std::string, size_t> mmap;
1385 22 Jul 08 peter 463   utility::inverse(vec.begin(), vec.end(), mmap);
1385 22 Jul 08 peter 464   test_inverse_validate(vec.begin(), mmap, suite);
1385 22 Jul 08 peter 465   utility::inverse(vec.begin()+1, vec.end(), mmap);
1385 22 Jul 08 peter 466   test_inverse_validate(vec.begin()+1, mmap, suite);
2202 21 Feb 10 peter 467   // do not run compile tests
2202 21 Feb 10 peter 468   if (false) {
2202 21 Feb 10 peter 469     std::map<std::string, std::vector<size_t> > m;
2202 21 Feb 10 peter 470     boost::input_iterator_archetype<std::string> start;
2202 21 Feb 10 peter 471     boost::input_iterator_archetype<std::string> end;
2202 21 Feb 10 peter 472     utility::inverse(start, end, m);
2202 21 Feb 10 peter 473     std::map<std::string, std::vector<size_t>, std::greater<std::string> > m2;
2202 21 Feb 10 peter 474     utility::inverse(start, end, m2);
2202 21 Feb 10 peter 475     std::multimap<std::string, size_t> m3;
2202 21 Feb 10 peter 476     utility::inverse(start, end, m3);
2202 21 Feb 10 peter 477     std::multimap<std::string, size_t, std::greater<std::string> > m4;
2202 21 Feb 10 peter 478     utility::inverse(start, end, m4);
2857 27 Sep 12 peter 479
2857 27 Sep 12 peter 480     std::map<std::string, size_t> unique_map;
2857 27 Sep 12 peter 481     utility::inverse(start, end, unique_map);
2202 21 Feb 10 peter 482   }
1385 22 Jul 08 peter 483 }
1385 22 Jul 08 peter 484
1385 22 Jul 08 peter 485
1385 22 Jul 08 peter 486 template<typename InputIterator, typename Key>
1385 22 Jul 08 peter 487 void test_inverse_validate(InputIterator first, InputIterator last,
1385 22 Jul 08 peter 488                            const std::map<Key, std::vector<size_t> >& m,
1385 22 Jul 08 peter 489                            test::Suite& suite)
1385 22 Jul 08 peter 490 {
1385 22 Jul 08 peter 491   typedef typename std::map<Key, std::vector<size_t> >::const_iterator Iter;
1385 22 Jul 08 peter 492   for ( InputIterator iter=first; iter != last; ++iter) {
1385 22 Jul 08 peter 493     Iter map_iter = m.find(*iter);
1385 22 Jul 08 peter 494     if (!suite.add(map_iter!=m.end())) {
1385 22 Jul 08 peter 495       suite.err() << "test_inverse_validate() failed\n";
1385 22 Jul 08 peter 496       suite.err() << "  could not find: " << *first << " in map m\n";
1385 22 Jul 08 peter 497     }
1385 22 Jul 08 peter 498     for (size_t i=0; i<map_iter->second.size(); ++i)
1385 22 Jul 08 peter 499       if (!suite.add(map_iter->second[i] ==
1385 22 Jul 08 peter 500                      static_cast<size_t>(distance(first, iter))) ) {
1385 22 Jul 08 peter 501         suite.err() << "test_inverse_validate() failed\n";
2673 03 Dec 11 peter 502         suite.err() << "  comparing: " << map_iter->second[i]
2673 03 Dec 11 peter 503                     << " and " << distance(first, iter)
1385 22 Jul 08 peter 504                     << " expected them to be equal\n";
1385 22 Jul 08 peter 505       }
1385 22 Jul 08 peter 506   }
1385 22 Jul 08 peter 507 }
1385 22 Jul 08 peter 508
1385 22 Jul 08 peter 509
1385 22 Jul 08 peter 510 template<typename InputIterator, typename Key>
1385 22 Jul 08 peter 511 void test_inverse_validate(InputIterator first,
1385 22 Jul 08 peter 512                            const std::multimap<Key, size_t>& m,
1385 22 Jul 08 peter 513                            test::Suite& suite)
1385 22 Jul 08 peter 514 {
1385 22 Jul 08 peter 515   for (typename std::multimap<Key, size_t>::const_iterator iter=m.begin();
1385 22 Jul 08 peter 516        iter!=m.end(); ++iter) {
1385 22 Jul 08 peter 517     suite.add(*(first + iter->second) == iter->first);
1385 22 Jul 08 peter 518   }
2673 03 Dec 11 peter 519
1385 22 Jul 08 peter 520 }
1491 11 Sep 08 peter 521
3490 22 May 16 peter 522
3490 22 May 16 peter 523 template<typename Access, typename Traversal>
3490 22 May 16 peter 524 void test_sort_index2(Access access, Traversal traversal)
3490 22 May 16 peter 525 {
3490 22 May 16 peter 526   typedef boost::default_constructible_archetype<
3490 22 May 16 peter 527     boost::sgi_assignable_archetype<
3490 22 May 16 peter 528       boost::less_than_comparable_archetype<> > > Value;
3490 22 May 16 peter 529   boost::iterator_archetype<Value, Access, Traversal> iterator;
3490 22 May 16 peter 530   std::vector<size_t> index;
3490 22 May 16 peter 531   utility::sort_index(iterator, iterator, index);
3490 22 May 16 peter 532
3490 22 May 16 peter 533   typedef boost::default_constructible_archetype<
3490 22 May 16 peter 534     boost::sgi_assignable_archetype<> > Value2;
3490 22 May 16 peter 535   boost::iterator_archetype<Value2, Access, Traversal> iterator2;
3490 22 May 16 peter 536   typedef boost::default_constructible_archetype<
3490 22 May 16 peter 537     boost::binary_predicate_archetype<Value2, Value2>
3490 22 May 16 peter 538     > Compare;
3490 22 May 16 peter 539   Compare comp;
3490 22 May 16 peter 540   utility::sort_index(iterator2, iterator2, index, comp);
3490 22 May 16 peter 541 }
3490 22 May 16 peter 542
3490 22 May 16 peter 543
3490 22 May 16 peter 544 template<typename Access>
3490 22 May 16 peter 545 void test_sort_index2(Access access)
3490 22 May 16 peter 546 {
3490 22 May 16 peter 547   // cannot create iterator_archetype w incrementable_traversal_tag
3490 22 May 16 peter 548   //test_sort_index2(access, boost::incrementable_traversal_tag());
3490 22 May 16 peter 549   test_sort_index2(access, boost::forward_traversal_tag());
3490 22 May 16 peter 550   test_sort_index2(access, boost::bidirectional_traversal_tag());
3490 22 May 16 peter 551   test_sort_index2(access, boost::random_access_traversal_tag());
3490 22 May 16 peter 552 }
3490 22 May 16 peter 553
3490 22 May 16 peter 554
3490 22 May 16 peter 555 void test_sort_index2(void)
3490 22 May 16 peter 556 {
3490 22 May 16 peter 557   using namespace boost::iterator_archetypes;
3490 22 May 16 peter 558
3490 22 May 16 peter 559   test_sort_index2(readable_iterator_t());
3490 22 May 16 peter 560   test_sort_index2(readable_writable_iterator_t());
3490 22 May 16 peter 561   test_sort_index2(writable_lvalue_iterator_t());
3490 22 May 16 peter 562 }
3490 22 May 16 peter 563
3490 22 May 16 peter 564
1491 11 Sep 08 peter 565 void test_sort_index(test::Suite& suite)
1491 11 Sep 08 peter 566 {
1491 11 Sep 08 peter 567   suite.err() << "testing sort_index" << std::endl;
1491 11 Sep 08 peter 568   utility::Vector a(10);
1491 11 Sep 08 peter 569   for (size_t i=0; i<a.size(); ++i)
1491 11 Sep 08 peter 570     a(i) = std::pow(i-4.2,2);
1491 11 Sep 08 peter 571   std::vector<size_t> vec;
1491 11 Sep 08 peter 572   utility::sort_index(vec, a);
1491 11 Sep 08 peter 573
1491 11 Sep 08 peter 574   std::vector<size_t> vec2;
1491 11 Sep 08 peter 575   utility::sort_index(a.begin(), a.end(), vec2);
1491 11 Sep 08 peter 576   if (vec.size()==vec2.size()) {
1491 11 Sep 08 peter 577     if (!suite.equal_range(vec.begin(), vec.end(), vec2.begin())) {
1491 11 Sep 08 peter 578       suite.add(false);
1491 11 Sep 08 peter 579     }
1491 11 Sep 08 peter 580   }
1491 11 Sep 08 peter 581   else {
1491 11 Sep 08 peter 582     suite.add(false);
2673 03 Dec 11 peter 583     suite.err() << "size mismatch: vec.size()=" << vec.size()
2673 03 Dec 11 peter 584                 << "vec2.size()=" << vec2.size() << "\n";
1491 11 Sep 08 peter 585   }
1491 11 Sep 08 peter 586   const utility::VectorConstView b(a, 0, 5, 2);
1491 11 Sep 08 peter 587
1491 11 Sep 08 peter 588   std::vector<size_t> vec3;
1491 11 Sep 08 peter 589   utility::sort_index(vec3, b);
1491 11 Sep 08 peter 590   std::vector<size_t> vec4;
1491 11 Sep 08 peter 591   utility::sort_index(b.begin(), b.end(), vec4);
1491 11 Sep 08 peter 592   if (vec3.size()!=vec4.size()) {
1491 11 Sep 08 peter 593     suite.add(false);
2673 03 Dec 11 peter 594     suite.err() << "size mismatch: vec3.size()=" << vec3.size()
2673 03 Dec 11 peter 595                 << " vec4.size()=" << vec4.size() << "\n";
1491 11 Sep 08 peter 596   }
1491 11 Sep 08 peter 597   else {
1491 11 Sep 08 peter 598     if (!suite.equal_range(vec3.begin(), vec3.end(), vec4.begin())){
1491 11 Sep 08 peter 599       suite.add(false);
1491 11 Sep 08 peter 600     }
1491 11 Sep 08 peter 601   }
1492 12 Sep 08 peter 602
1492 12 Sep 08 peter 603   std::list<double> list;
1492 12 Sep 08 peter 604   for (size_t i=0; i<a.size(); ++i)
1492 12 Sep 08 peter 605     list.push_back(a(i));
1492 12 Sep 08 peter 606   std::vector<size_t> vec5;
1492 12 Sep 08 peter 607   utility::sort_index(list.begin(), list.end(), vec5);
1492 12 Sep 08 peter 608   if (vec.size()!=vec5.size()) {
1492 12 Sep 08 peter 609     suite.add(false);
2673 03 Dec 11 peter 610     suite.err() << "size mismatch: vec.size()=" << vec.size()
2673 03 Dec 11 peter 611                 << " vec5.size()=" << vec5.size() << "\n";
1492 12 Sep 08 peter 612   }
1492 12 Sep 08 peter 613   else {
1492 12 Sep 08 peter 614     if (!suite.equal_range(vec.begin(), vec.end(), vec5.begin())){
1492 12 Sep 08 peter 615       suite.add(false);
1492 12 Sep 08 peter 616     }
1492 12 Sep 08 peter 617   }
1492 12 Sep 08 peter 618
3490 22 May 16 peter 619   test_sort_index2();
1491 11 Sep 08 peter 620 }
2239 10 Apr 10 peter 621
3287 12 Jul 14 peter 622
3287 12 Jul 14 peter 623 void test_sum_weight(test::Suite& suite)
3287 12 Jul 14 peter 624 {
3287 12 Jul 14 peter 625   // do not run compile test
3287 12 Jul 14 peter 626   if (false) {
3287 12 Jul 14 peter 627     boost::input_iterator_archetype<double> iter;
3287 12 Jul 14 peter 628     utility::sum_weight(iter, iter);
3287 12 Jul 14 peter 629     boost::input_iterator_archetype_no_proxy<utility::DataWeight> iter2;
3287 12 Jul 14 peter 630     utility::sum_weight(iter2, iter2);
3287 12 Jul 14 peter 631   }
3287 12 Jul 14 peter 632 }
3287 12 Jul 14 peter 633
3287 12 Jul 14 peter 634
2239 10 Apr 10 peter 635 void test_ptr_compare(test::Suite& suite)
2239 10 Apr 10 peter 636 {
2286 27 Jun 10 peter 637   using utility::make_ptr_compare;
2239 10 Apr 10 peter 638   std::vector<double*> vec(10);
2239 10 Apr 10 peter 639   std::greater<double> d_greater;
2239 10 Apr 10 peter 640   for (size_t i=0; i<vec.size(); ++i)
2239 10 Apr 10 peter 641     vec[i] = new double(i);
2286 27 Jun 10 peter 642   std::sort(vec.begin(), vec.end(), make_ptr_compare(*vec.begin(), d_greater));
2239 10 Apr 10 peter 643   for (size_t i=1; i<vec.size(); ++i) {
2239 10 Apr 10 peter 644     suite.add( *vec[i-1] > *vec[i]);
2239 10 Apr 10 peter 645   }
2286 27 Jun 10 peter 646   std::sort(vec.begin(), vec.end(), make_ptr_compare(*vec.begin()));
2286 27 Jun 10 peter 647   for (size_t i=1; i<vec.size(); ++i) {
2286 27 Jun 10 peter 648     suite.add( *vec[i-1] < *vec[i]);
2286 27 Jun 10 peter 649   }
2239 10 Apr 10 peter 650   for (size_t i=0; i<vec.size(); ++i)
2239 10 Apr 10 peter 651     delete vec[i];
2239 10 Apr 10 peter 652
2239 10 Apr 10 peter 653 }
2908 15 Dec 12 peter 654
2908 15 Dec 12 peter 655
2908 15 Dec 12 peter 656 void test_fnmatch(test::Suite& suite)
2908 15 Dec 12 peter 657 {
2908 15 Dec 12 peter 658   bool ok=true;
2908 15 Dec 12 peter 659   ok &= test_fnmatch(true,"peter", "peter");
2908 15 Dec 12 peter 660   ok &= test_fnmatch(false,"peter", "peterj");
2908 15 Dec 12 peter 661
2908 15 Dec 12 peter 662   ok &= test_fnmatch(true,"*", "peterj");
2908 15 Dec 12 peter 663   ok &= test_fnmatch(true,"p*", "peterj");
2908 15 Dec 12 peter 664   ok &= test_fnmatch(true, "p*", "peter");
2908 15 Dec 12 peter 665   ok &= test_fnmatch(false, "p*j", "peter");
2908 15 Dec 12 peter 666   ok &= test_fnmatch(true, "p*j", "peterj");
2908 15 Dec 12 peter 667   ok &= test_fnmatch(true, "*peter", "peter");
2908 15 Dec 12 peter 668
2908 15 Dec 12 peter 669   ok &= test_fnmatch(true, "p?ter", "peter");
2908 15 Dec 12 peter 670   ok &= test_fnmatch(false, "p?er", "peter");
2908 15 Dec 12 peter 671   ok &= test_fnmatch(false, "p?eter", "peter");
2908 15 Dec 12 peter 672
2908 15 Dec 12 peter 673   ok &= test_fnmatch(true, "filename", "filename");
2908 15 Dec 12 peter 674   ok &= test_fnmatch(true, "*name", "filename");
2908 15 Dec 12 peter 675   ok &= test_fnmatch(true, "[fa]il?name", "filename");
2908 15 Dec 12 peter 676   ok &= test_fnmatch(true, "[fa]*il?name", "ffilename");
2908 15 Dec 12 peter 677
2908 15 Dec 12 peter 678   ok &= test_fnmatch(true, "[fa]*il?name", "fafafailename");
2908 15 Dec 12 peter 679   ok &= test_fnmatch(false, "[fa]?il?name", "ilename");
2908 15 Dec 12 peter 680   ok &= test_fnmatch(false, "?[fa]il?name", "ilename");
2908 15 Dec 12 peter 681   ok &= test_fnmatch(true, "[fa]il?name", "filename");
2908 15 Dec 12 peter 682   ok &= test_fnmatch(false, "[fa]?il?name", "fafafailename");
2908 15 Dec 12 peter 683
2908 15 Dec 12 peter 684   ok &= test_fnmatch(true, "*name", "/path/to/filename");
2908 15 Dec 12 peter 685   ok &= test_fnmatch(true, "*name", "file.name");
2908 15 Dec 12 peter 686   ok &= test_fnmatch(true, "*.txt", ".file.txt");
2908 15 Dec 12 peter 687   suite.add(ok);
2908 15 Dec 12 peter 688 }
2908 15 Dec 12 peter 689
2908 15 Dec 12 peter 690
2908 15 Dec 12 peter 691 void test_dirname(test::Suite& suite)
2908 15 Dec 12 peter 692 {
2908 15 Dec 12 peter 693   std::vector<std::string> path;
2908 15 Dec 12 peter 694   path.push_back("/usr/lib");
2908 15 Dec 12 peter 695   path.push_back("/usr/");
2908 15 Dec 12 peter 696   path.push_back("usr");
2908 15 Dec 12 peter 697   path.push_back("/");
2908 15 Dec 12 peter 698   path.push_back(".");
2908 15 Dec 12 peter 699   path.push_back("..");
3698 25 Sep 17 peter 700   path.push_back("");
2908 15 Dec 12 peter 701   std::vector<std::string> dir;
2908 15 Dec 12 peter 702   dir.push_back("/usr");
2908 15 Dec 12 peter 703   dir.push_back("/");
2908 15 Dec 12 peter 704   dir.push_back(".");
2908 15 Dec 12 peter 705   dir.push_back("/");
2908 15 Dec 12 peter 706   dir.push_back(".");
2908 15 Dec 12 peter 707   dir.push_back(".");
3698 25 Sep 17 peter 708   dir.push_back(".");
2908 15 Dec 12 peter 709   assert(dir.size()==path.size());
2908 15 Dec 12 peter 710   using utility::dirname;
2908 15 Dec 12 peter 711   for (size_t i=0; i<dir.size(); ++i) {
2908 15 Dec 12 peter 712     if (dir[i] != dirname(path[i])) {
2908 15 Dec 12 peter 713       suite.add(false);
2908 15 Dec 12 peter 714       suite.out() << "error:\n";
2908 15 Dec 12 peter 715       suite.out() << "path:           " << path[i] << "\n";
2908 15 Dec 12 peter 716       suite.out() << "directory_name: " << dirname(path[i]) << "\n";
2908 15 Dec 12 peter 717       suite.out() << "expected:       " << dir[i] << "\n";
2908 15 Dec 12 peter 718     }
2908 15 Dec 12 peter 719   }
2908 15 Dec 12 peter 720 }
2908 15 Dec 12 peter 721
2908 15 Dec 12 peter 722
2908 15 Dec 12 peter 723 void test_basename(test::Suite& suite)
2908 15 Dec 12 peter 724 {
2908 15 Dec 12 peter 725   std::vector<std::string> path;
2908 15 Dec 12 peter 726   path.push_back("/usr/lib");
2908 15 Dec 12 peter 727   path.push_back("/usr/");
2908 15 Dec 12 peter 728   path.push_back("usr");
2908 15 Dec 12 peter 729   path.push_back("/");
2908 15 Dec 12 peter 730   path.push_back(".");
2908 15 Dec 12 peter 731   path.push_back("..");
3698 25 Sep 17 peter 732   path.push_back("");
2908 15 Dec 12 peter 733   std::vector<std::string> file;
2908 15 Dec 12 peter 734   file.push_back("lib");
2908 15 Dec 12 peter 735   file.push_back("usr");
2908 15 Dec 12 peter 736   file.push_back("usr");
2908 15 Dec 12 peter 737   file.push_back("/");
2908 15 Dec 12 peter 738   file.push_back(".");
2908 15 Dec 12 peter 739   file.push_back("..");
3698 25 Sep 17 peter 740   file.push_back(".");
2908 15 Dec 12 peter 741   assert(file.size()==path.size());
2908 15 Dec 12 peter 742   using utility::basename;
2908 15 Dec 12 peter 743   for (size_t i=0; i<file.size(); ++i) {
2908 15 Dec 12 peter 744     if (file[i] != basename(path[i])) {
2908 15 Dec 12 peter 745       suite.add(false);
2908 15 Dec 12 peter 746       suite.out() << "error:\n";
2908 15 Dec 12 peter 747       suite.out() << "path:           " << path[i] << "\n";
2908 15 Dec 12 peter 748       suite.out() << "basename:       " << basename(path[i]) << "\n";
2908 15 Dec 12 peter 749       suite.out() << "expected:       " << file[i] << "\n";
2908 15 Dec 12 peter 750     }
2908 15 Dec 12 peter 751   }
2908 15 Dec 12 peter 752 }
2908 15 Dec 12 peter 753
2908 15 Dec 12 peter 754
2908 15 Dec 12 peter 755 bool test_fnmatch(bool answ, std::string a, std::string b)
2908 15 Dec 12 peter 756 {
2908 15 Dec 12 peter 757   using namespace utility;
2908 15 Dec 12 peter 758   bool res = fnmatch(a, b);
2908 15 Dec 12 peter 759   // check that fnmatch and regexp agree
2908 15 Dec 12 peter 760   if (res == answ)
2908 15 Dec 12 peter 761     return true;
2908 15 Dec 12 peter 762   if (res!=answ)
2908 15 Dec 12 peter 763     std::cerr << "fnmatch(" << a << ", " << b << ") results "
2908 15 Dec 12 peter 764               << res
2908 15 Dec 12 peter 765               << ". Expects " << answ << std::endl;
2908 15 Dec 12 peter 766   return false;
2908 15 Dec 12 peter 767 }
3098 28 Oct 13 peter 768
3098 28 Oct 13 peter 769
3803 12 May 19 peter 770 void test_getcwd(test::Suite& suite)
3803 12 May 19 peter 771 {
3803 12 May 19 peter 772   std::string cwd = utility::getcwd();
3803 12 May 19 peter 773   suite.out() << "cwd: " << cwd << "\n";
3803 12 May 19 peter 774   if (cwd.find("/test/testSubDir/") == std::string::npos) {
3803 12 May 19 peter 775     suite.add(false);
3803 12 May 19 peter 776     suite.err() << "error: cwd: expect path to contain 'test/testSubDir/'\n";
3803 12 May 19 peter 777   }
3803 12 May 19 peter 778 }
3803 12 May 19 peter 779
3803 12 May 19 peter 780
3295 25 Jul 14 peter 781 void test_remove(test::Suite& suite)
3295 25 Jul 14 peter 782 {
3295 25 Jul 14 peter 783   // at least test linking
3295 25 Jul 14 peter 784   if (false)
3295 25 Jul 14 peter 785     utility::remove("foo");
3295 25 Jul 14 peter 786 }
3295 25 Jul 14 peter 787
3295 25 Jul 14 peter 788
3295 25 Jul 14 peter 789 void test_rename(test::Suite& suite)
3295 25 Jul 14 peter 790 {
3295 25 Jul 14 peter 791   // at least test linking
3295 25 Jul 14 peter 792   if (false)
3295 25 Jul 14 peter 793     utility::rename("foo", "bar");
3295 25 Jul 14 peter 794 }
3295 25 Jul 14 peter 795
3295 25 Jul 14 peter 796
3098 28 Oct 13 peter 797 void test_replace(test::Suite& suite)
3098 28 Oct 13 peter 798 {
3098 28 Oct 13 peter 799   std::string s = "Some magic string!!!";
3098 28 Oct 13 peter 800   utility::replace(s, "magic", "arbitrary");
3098 28 Oct 13 peter 801   if (!suite.add(s=="Some arbitrary string!!!"))
3098 28 Oct 13 peter 802     suite.err() << "error: " << s << "\n";
3098 28 Oct 13 peter 803 }
3466 10 Feb 16 peter 804
3466 10 Feb 16 peter 805
3746 13 Aug 18 peter 806 void test_symlink(test::Suite& suite)
3746 13 Aug 18 peter 807 {
3746 13 Aug 18 peter 808   // at least test function links
3746 13 Aug 18 peter 809   if (false)
3746 13 Aug 18 peter 810     utility::symlink("/from/to/path", "my/symlink");
3746 13 Aug 18 peter 811 }
3746 13 Aug 18 peter 812
3746 13 Aug 18 peter 813
3466 10 Feb 16 peter 814 void test_ticket842(test::Suite& suite)
3466 10 Feb 16 peter 815 {
3466 10 Feb 16 peter 816   suite.out() << "test_ticket842\n";
3466 10 Feb 16 peter 817   std::vector<std::pair<std::string, int> > data;
3466 10 Feb 16 peter 818   data.push_back(std::make_pair("Orange", 2));
3466 10 Feb 16 peter 819   data.push_back(std::make_pair("Orange", 1));
3466 10 Feb 16 peter 820   data.push_back(std::make_pair("Apple", 10));
3466 10 Feb 16 peter 821
3466 10 Feb 16 peter 822   typedef  utility::PairFirst<const std::pair<std::string, int> > PF;
3466 10 Feb 16 peter 823   typedef std::less<std::string> strLess;
3466 10 Feb 16 peter 824   utility::compose_f_gx_hy<strLess, PF, PF> compare;
3466 10 Feb 16 peter 825   // stable sort should shuffle 'Apple' first, and then keep the order
3466 10 Feb 16 peter 826   // of the equaivalent 'Orange' elements, i.e., <Orange, 2> should stay
3466 10 Feb 16 peter 827   // before <Orange, 1>.
3466 10 Feb 16 peter 828   std::stable_sort(data.begin(), data.end(), compare);
3466 10 Feb 16 peter 829   if (!suite.add(data[0].first == "Apple"))
3466 10 Feb 16 peter 830     suite.err() << "incorrect data[0].first: " << data[0].first << "\n";
3466 10 Feb 16 peter 831   if (!suite.add(data[1].first == "Orange"))
3466 10 Feb 16 peter 832     suite.err() << "incorrect data[1].first: " << data[1].first << "\n";
3466 10 Feb 16 peter 833   if (!suite.add(data[1].second == 2))
3466 10 Feb 16 peter 834     suite.err() << "incorrect data[1].second: " << data[1].second << "\n";
3466 10 Feb 16 peter 835 }
4102 22 Sep 21 peter 836
4102 22 Sep 21 peter 837
4102 22 Sep 21 peter 838 void test_starts_with(test::Suite& suite)
4102 22 Sep 21 peter 839 {
4102 22 Sep 21 peter 840   std::string name("Jane Doe");
4102 22 Sep 21 peter 841   if (!utility::starts_with(name, "Jane")) {
4102 22 Sep 21 peter 842     suite.add(false);
4102 22 Sep 21 peter 843     suite.err() << "error: 'Jane Doe' does not start with 'Jane'\n";
4102 22 Sep 21 peter 844   }
4102 22 Sep 21 peter 845   if (!utility::starts_with(name, 'J')) {
4102 22 Sep 21 peter 846     suite.add(false);
4102 22 Sep 21 peter 847     suite.err() << "error: starts_with(x,x) failed\n";
4102 22 Sep 21 peter 848   }
4102 22 Sep 21 peter 849   if (!utility::starts_with(name, name)) {
4102 22 Sep 21 peter 850     suite.add(false);
4102 22 Sep 21 peter 851     suite.err() << "error: starts_with(x,x) failed\n";
4102 22 Sep 21 peter 852   }
4102 22 Sep 21 peter 853 }
4102 22 Sep 21 peter 854
4102 22 Sep 21 peter 855
4102 22 Sep 21 peter 856 void test_contains(test::Suite& suite)
4102 22 Sep 21 peter 857 {
4102 22 Sep 21 peter 858   std::string name("Jane Doe");
4102 22 Sep 21 peter 859   if (!utility::contains(name, "ne")) {
4102 22 Sep 21 peter 860     suite.add(false);
4102 22 Sep 21 peter 861     suite.err() << "error: " << name << " does not contain \"ne\"\n";
4102 22 Sep 21 peter 862   }
4102 22 Sep 21 peter 863   if (!utility::contains(name, name)) {
4102 22 Sep 21 peter 864     suite.add(false);
4102 22 Sep 21 peter 865     suite.err() << "error: contains(x,x) failed\n";
4102 22 Sep 21 peter 866   }
4102 22 Sep 21 peter 867   if (!utility::contains(name, 'D')) {
4102 22 Sep 21 peter 868     suite.add(false);
4102 22 Sep 21 peter 869     suite.err() << "error: contains(string,char) failed\n";
4102 22 Sep 21 peter 870   }
4102 22 Sep 21 peter 871 }
4102 22 Sep 21 peter 872
4102 22 Sep 21 peter 873
4102 22 Sep 21 peter 874 void test_ends_with(test::Suite& suite)
4102 22 Sep 21 peter 875 {
4102 22 Sep 21 peter 876   std::string name("Jane Doe");
4102 22 Sep 21 peter 877   if (!utility::ends_with(name, name)) {
4102 22 Sep 21 peter 878     suite.add(false);
4102 22 Sep 21 peter 879     suite.err() << "error: ends_with(x,x) failed\n";
4102 22 Sep 21 peter 880   }
4102 22 Sep 21 peter 881   if (!utility::ends_with(name, 'e')) {
4102 22 Sep 21 peter 882     suite.add(false);
4102 22 Sep 21 peter 883     suite.err() << "error: ends_with(x,x) failed\n";
4102 22 Sep 21 peter 884   }
4102 22 Sep 21 peter 885   if (!utility::ends_with(name, "Doe")) {
4102 22 Sep 21 peter 886     suite.add(false);
4102 22 Sep 21 peter 887     suite.err() << "error: 'Jane Doe' does not end with 'Doe'\n";
4102 22 Sep 21 peter 888   }
4102 22 Sep 21 peter 889 }

Generated on Tue Apr 25 01:20:41 2023 (UTC) by svndigest 0.10.4pre (dev build 1607)