source: trunk/test/utility_test.cc @ 1619

Last change on this file since 1619 was 1500, checked in by Peter, 13 years ago

Added structure to deprecate functions. I chose to use a gcc style,
and it is tested in configure whether the compiler supports it. If not
the deprecation has no effect. Using a deprecated function will cause
a compiler warning. In gcc the warning can be turned off with
'-Wno-deprecated'. Possibly we should turn off the warning by default,
so a user has to turn it on by defining
-DYAT_DISABLE_DEPRECATED...

fixes #367

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 7.7 KB
Line 
1// $Id: utility_test.cc 1500 2008-09-15 18:47:37Z peter $
2
3/*
4  Copyright (C) 2006 Jari Häkkinen, Markus Ringnér
5  Copyright (C) 2007 Jari Häkkinen, Peter Johansson
6  Copyright (C) 2008 Peter Johansson
7
8  This file is part of the yat library, http://dev.thep.lu.se/yat
9
10  The yat library is free software; you can redistribute it and/or
11  modify it under the terms of the GNU General Public License as
12  published by the Free Software Foundation; either version 3 of the
13  License, or (at your option) any later version.
14
15  The yat library is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  General Public License for more details.
19
20  You should have received a copy of the GNU General Public License
21  along with yat. If not, see <http://www.gnu.org/licenses/>.
22*/
23
24#include "Suite.h"
25
26#include "yat/utility/Matrix.h"
27#include "yat/utility/utility.h"
28#include "yat/utility/Vector.h"
29#include "yat/utility/VectorConstView.h"
30#include "yat/utility/sort_index.h"
31#include "yat/utility/stl_utility.h"
32
33#include <fstream>
34#include <iostream>
35#include <list>
36#include <map>
37#include <string>
38#include <vector>
39
40using namespace theplu::yat;
41void test_inverse(test::Suite&);
42
43template<typename InputIterator, typename Key>
44void test_inverse_validate(InputIterator first, InputIterator last,
45                           const std::map<Key, std::vector<size_t> >& m,
46                           test::Suite& suite);
47template<typename InputIterator, typename Key>
48void test_inverse_validate(InputIterator first,
49                           const std::multimap<Key, size_t>& m,
50                           test::Suite& suite);
51
52void test_sort_index(test::Suite& suite);
53
54int main(int argc, char* argv[])
55{ 
56  using namespace theplu::yat;
57  test::Suite suite(argc, argv);
58  suite.err() << "testing utility ... " << std::endl;
59
60  // test float/double
61  std::string s("1.2");
62  if (!utility::is<double>(s)){
63    suite.add(false);
64  }
65  else if (!utility::is<float>(s)) {
66    suite.add(false);
67  }
68  else if (utility::is<int>(s)) {
69    suite.add(false);
70  }
71  else if (utility::is_nan(s)) {
72    suite.add(false);
73  }
74
75  // test int
76  s="23";
77  if (!utility::is<double>(s)){
78    suite.add(false);
79  }
80  else if (!utility::is<float>(s)) {
81    suite.add(false);
82  }
83  else if (!utility::is<int>(s)) {
84    suite.add(false);
85  }
86  else if (utility::is_nan(s)) {
87    suite.add(false);
88  }
89
90  // test nan
91  s=" nAn  ";
92  if (!utility::is<double>(s)){
93    suite.add(false);
94    suite.err() << "error: " << s << " is a double\n";
95  }
96  /* we don't require NaN for float and int
97  else if (!utility::is_float(s)) {
98    suite.add(false);
99    suite.err() << "error: " << s << " is a float\n";
100  }
101  else if (!utility::is_int(s)) {
102    suite.add(false);
103    suite.err() << "error: " << s << " is a int\n";
104  }
105  */
106  else if (!utility::is_nan(s)) {
107    suite.add(false);
108    suite.err() << "error: " << s << " is nan\n";
109
110  }
111 
112  // testing trailing values
113  s=" 23 23   ";
114  if (utility::is<double>(s)){
115    suite.add(false);
116  }
117  else if (utility::is<float>(s)) {
118    suite.add(false);
119  }
120  else if (utility::is<int>(s)) {
121    suite.add(false);
122  }
123  else if (utility::is_nan(s)) {
124    suite.add(false);
125  }
126
127  if (utility::convert<double>("1.23")!=1.23)
128    suite.add(false);
129  utility::convert<double>("-inf");
130  utility::convert<double>("inf");
131  utility::convert<double>("NaN");
132
133  if (!suite.add(utility::is<double>("-inf")))
134    suite.err() << "is<double>(\"-inf\") should return true\n";
135  if (!suite.add(utility::is<double>("inf")))
136    suite.err() << "is<double>(\"inf\") should return true\n";
137  if (!suite.add(utility::is<double>("NaN")))
138    suite.err() << "is<double>(\"NaN\") should return true\n";
139  if (!suite.add(utility::is<double>("1.23")))
140    suite.err() << "is<double>(\"1.23\") should return true\n";
141  if (!suite.add(!utility::is<double>("1.23.2")))
142    suite.err() << "is<double>(\"1.23.2\") should return false\n";
143  if (!suite.add(!utility::is<int>("1.23")))
144    suite.err() << "is<int>(\"1.23\") should return false\n";
145  if (!suite.add(!utility::is<int>("")))
146    suite.err() << "is<int>(\"\") should return false\n";
147
148  {
149    utility::Log<long double> f;
150    utility::Log<double> f2(1.3);
151    f(2.0);
152    utility::Exp<double> e;
153    e(3.2);
154  }
155
156  test_inverse(suite);
157  test_sort_index(suite);
158
159  return suite.return_value();
160}
161
162
163void test_inverse(test::Suite& suite)
164{
165  suite.err() << "Testing inverse\n";
166  std::vector<std::string> vec;
167  vec.push_back("No");
168  vec.push_back("one");
169  vec.push_back("shall");
170  vec.push_back("be");
171  vec.push_back("subjected");
172  std::map<std::string, std::vector<size_t> > map;
173  utility::inverse(vec.begin(), vec.end(), map);
174  test_inverse_validate(vec.begin(), vec.end(), map, suite);
175  utility::inverse(vec.begin()+1, vec.end(), map);
176  test_inverse_validate(vec.begin()+1, vec.end(), map, suite);
177  const std::vector<std::string> vec2(vec);
178  utility::inverse(vec2.begin(), vec2.end(), map);
179  test_inverse_validate(vec2.begin(), vec2.end(), map, suite);
180  std::multimap<std::string, size_t> mmap;
181  utility::inverse(vec.begin(), vec.end(), mmap);
182  test_inverse_validate(vec.begin(), mmap, suite);
183  utility::inverse(vec.begin()+1, vec.end(), mmap);
184  test_inverse_validate(vec.begin()+1, mmap, suite);
185}
186
187
188template<typename InputIterator, typename Key>
189void test_inverse_validate(InputIterator first, InputIterator last,
190                           const std::map<Key, std::vector<size_t> >& m,
191                           test::Suite& suite)
192{
193  typedef typename std::map<Key, std::vector<size_t> >::const_iterator Iter;
194  for ( InputIterator iter=first; iter != last; ++iter) {
195    Iter map_iter = m.find(*iter);
196    if (!suite.add(map_iter!=m.end())) {
197      suite.err() << "test_inverse_validate() failed\n";
198      suite.err() << "  could not find: " << *first << " in map m\n";
199    }
200    for (size_t i=0; i<map_iter->second.size(); ++i)
201      if (!suite.add(map_iter->second[i] ==
202                     static_cast<size_t>(distance(first, iter))) ) {
203        suite.err() << "test_inverse_validate() failed\n";
204        suite.err() << "  comparing: " << map_iter->second[i] 
205                    << " and " << distance(first, iter) 
206                    << " expected them to be equal\n";
207      }
208  }
209}
210
211
212template<typename InputIterator, typename Key>
213void test_inverse_validate(InputIterator first,
214                           const std::multimap<Key, size_t>& m,
215                           test::Suite& suite)
216{
217  for (typename std::multimap<Key, size_t>::const_iterator iter=m.begin();
218       iter!=m.end(); ++iter) {
219    suite.add(*(first + iter->second) == iter->first);
220  }
221 
222}
223
224void test_sort_index(test::Suite& suite)
225{
226  suite.err() << "testing sort_index" << std::endl;
227  utility::Vector a(10);
228  for (size_t i=0; i<a.size(); ++i)
229    a(i) = std::pow(i-4.2,2);
230  std::vector<size_t> vec;
231  utility::sort_index(vec, a);
232
233  std::vector<size_t> vec2;
234  utility::sort_index(a.begin(), a.end(), vec2);
235  if (vec.size()==vec2.size()) {
236    if (!suite.equal_range(vec.begin(), vec.end(), vec2.begin())) {
237      suite.add(false);
238    }
239  }
240  else {
241    suite.add(false);
242    suite.err() << "size mismatch: vec.size()=" << vec.size() 
243                << "vec2.size()=" << vec2.size() << "\n"; 
244  }
245  const utility::VectorConstView b(a, 0, 5, 2);
246
247  std::vector<size_t> vec3;
248  utility::sort_index(vec3, b);
249  std::vector<size_t> vec4;
250  utility::sort_index(b.begin(), b.end(), vec4);
251  if (vec3.size()!=vec4.size()) {
252    suite.add(false);
253    suite.err() << "size mismatch: vec3.size()=" << vec3.size() 
254                << " vec4.size()=" << vec4.size() << "\n"; 
255  }
256  else {
257    if (!suite.equal_range(vec3.begin(), vec3.end(), vec4.begin())){
258      suite.add(false);
259    }
260  }
261
262  std::list<double> list;
263  for (size_t i=0; i<a.size(); ++i)
264    list.push_back(a(i));
265  std::vector<size_t> vec5;
266  utility::sort_index(list.begin(), list.end(), vec5);
267  if (vec.size()!=vec5.size()) {
268    suite.add(false);
269    suite.err() << "size mismatch: vec.size()=" << vec.size() 
270                << " vec5.size()=" << vec5.size() << "\n"; 
271  }
272  else {
273    if (!suite.equal_range(vec.begin(), vec.end(), vec5.begin())){
274      suite.add(false);
275    }
276  }
277
278}
Note: See TracBrowser for help on using the repository browser.