source: trunk/test/segment.cc @ 3661

Last change on this file since 3661 was 3661, checked in by Peter, 4 years ago

update copyright years

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 12.2 KB
Line 
1// $Id: segment.cc 3661 2017-07-14 01:10:35Z peter $
2
3/*
4  Copyright (C) 2010, 2011, 2012, 2014, 2015, 2016, 2017 Peter Johansson
5
6  This file is part of the yat library, http://dev.thep.lu.se/yat
7
8  The yat library is free software; you can redistribute it and/or
9  modify it under the terms of the GNU General Public License as
10  published by the Free Software Foundation; either version 3 of the
11  License, or (at your option) any later version.
12
13  The yat library is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  General Public License for more details.
17
18  You should have received a copy of the GNU General Public License
19  along with yat. If not, see <http://www.gnu.org/licenses/>.
20*/
21
22#include <config.h>
23
24#include "Suite.h"
25
26#include "yat/utility/Segment.h"
27#include "yat/utility/SegmentMap.h"
28#include "yat/utility/SegmentSet.h"
29
30using namespace theplu::yat;
31using namespace utility;
32void test_compare(test::Suite& suite);
33void test_count(test::Suite&);
34void test_erase(test::Suite&);
35void test_includes(test::Suite&);
36void test_insert(test::Suite&);
37void test_insert_merge(test::Suite&);
38void test_make_segment(test::Suite&);
39void test_overlap(test::Suite&);
40void test_segment(test::Suite& suite);
41void test_operator(test::Suite& suite);
42void test_segment_map(test::Suite& suite);
43void test_set_bound(test::Suite&);
44void test_union(test::Suite&);
45
46template<typename T>
47void avoid_pedantic_warning(T) {}
48
49int main(int argc, char* argv[])
50{
51  test::Suite suite(argc, argv);
52
53  test_compare(suite);
54  test_count(suite);
55  test_erase(suite);
56  test_includes(suite);
57  test_insert(suite);
58  test_insert_merge(suite);
59  test_make_segment(suite);
60  test_overlap(suite);
61  test_segment(suite);
62  test_set_bound(suite);
63  test_union(suite);
64
65  test_segment_map(suite);
66
67  return suite.return_value();
68}
69
70
71void test_compare_(test::Suite& suite, double lhs_begin, double lhs_end, 
72                   double rhs_begin, double rhs_end, int expected)
73{
74  int result = compare_3way(Segment<double>(lhs_begin,lhs_end), 
75                            Segment<double>(rhs_begin,rhs_end));
76  if (result!=expected) {
77    suite.add(false);
78    suite.err() << "error:"
79                << "[" << lhs_begin << ", " << lhs_end << ") vs "
80                << "[" << rhs_begin << ", " << rhs_end << ")\n"
81                << "result: " << result << "\n"
82                << "expected: " << expected << "\n"
83                << "\n";
84  }
85
86  compare_3way(lhs_begin, Segment<double>(rhs_begin,rhs_end));
87  compare_3way(Segment<double>(rhs_begin,rhs_end), lhs_begin);
88}
89
90void test_compare(test::Suite& suite, double lhs_begin, double lhs_end, 
91                  double rhs_begin, double rhs_end, int expected)
92{
93  test_compare_(suite, lhs_begin, lhs_end, rhs_begin, rhs_end, expected);
94  // test symmetry
95  test_compare_(suite, rhs_begin, rhs_end, lhs_begin, lhs_end, -expected);
96}
97
98void test_compare(test::Suite& suite)
99{
100  test_compare(suite, 0, 10, 20, 30, -1);
101  test_compare(suite, 0, 10, 10, 30, -1);
102  test_compare(suite, 0, 10, 5, 30, 0);
103  test_compare(suite, 0, 10, -5, 5, 0);
104  test_compare(suite, 0, 10, -5, 0, 1);
105  test_compare(suite, 0, 10, -5, -1, 1);
106  // zero sized
107  test_compare(suite, 0, 0, 20, 30, -1);
108  test_compare(suite, 0, 0, 0, 1, -1);
109  test_compare(suite, 0, 0, -5, 5, 0);
110  test_compare(suite, 0, 0, -5, 0, 1);
111  test_compare(suite, 0, 0, -5, -1, 1);
112
113  // zero sized on both sides
114  test_compare(suite, 0, 0, 1, 1, -1);
115  test_compare(suite, 0, 0, 0, 0, 0);
116  test_compare(suite, 0, 0, -1, -1, 1);
117}
118
119
120void test_erase(test::Suite& suite)
121{
122  suite.out() << "test_erase\n";
123  suite.out() << "  SegmentSet\n";
124  SegmentSet<double> set;
125  set.insert(Segment<double>(0,2));
126  set.insert(Segment<double>(10,20));
127  set.insert(Segment<double>(30,50));
128  SegmentSet<double>::iterator iter = set.find(15);
129  set.erase(iter);
130  if (!suite.add(set.size()==2))
131    suite.err() << "size: " << set.size() << " expected 2\n";
132  set.erase(set.begin(), set.end());
133  if (!suite.add(set.size()==0))
134    suite.err() << "size: " << set.size() << " expected 0\n";
135  suite.out() << "  SegmentMap\n";
136  typedef SegmentMap<double, std::string> Map;
137  Map map;
138  Map::key_type s(0,2);
139  map.insert(Map::value_type(s, "aha"));
140  map.erase(map.begin());
141  map.erase(map.begin(), map.end());
142}
143
144
145void test_insert(test::Suite& suite)
146{
147  Segment<double> segment;
148  Segment<double> segment2(0,2);
149
150  SegmentSet<double> set;
151  if (set.size()!=0) {
152    suite.add(false);
153    suite.err() << "expected size 0\n";
154  }
155  set.insert(segment2);
156  if (set.size()!=1) {
157    suite.add(false);
158    suite.err() << "expected size 1\n";
159  }
160  set.insert(segment2);
161  if (set.size()!=1) {
162    suite.add(false);
163    suite.err() << "expected size 1\n";
164  }
165  set.insert(Segment<double>(1,3));
166  if (set.size()!=1) {
167    suite.add(false);
168    suite.err() << "expected size 1\n";
169  }
170  else if (set.begin()->begin()!=0.0 || set.begin()->end()!=2.0) {
171    suite.add(false);
172    suite.err() << "error: expected segment to be [0, 2)\n"
173                << "found: [" << set.begin()->begin() 
174                << ", " << set.begin()->end() << ")\n";
175  }
176  if (!suite.add(set.find(0)!=set.end()))
177    suite.err() << "error: set.find(0): expected not end()\n";
178}
179
180void test_count(test::Suite& suite)
181{
182  SegmentSet<double> set;
183  set.insert(Segment<double>(0,2));
184  // test count
185  if (!suite.add(set.count(0)==1))
186    suite.err() << "error: set.count(0): expected 1\n";
187  if (!suite.add(set.count(1)==1))
188    suite.err() << "error: set.count(1): expected 1\n";
189  if (!suite.add(set.count(2)==0))
190    suite.err() << "error: set.count(2): expected 0\n";
191}
192
193void test_insert_merge(test::Suite& suite)
194{
195  SegmentSet<double> set;
196  set.insert(Segment<double>(0,2));
197  set.insert_merge(Segment<double>(3,5));
198  if (!suite.add(set.size()==2))
199    suite.err() << "error: set.size(): expected 2\n";
200
201  set.insert_merge(Segment<double>(12,13));
202  if (!suite.add(set.size()==3))
203    suite.err() << "error: set.size(): expected 3\n";
204
205  set.insert_merge(Segment<double>(1,4));
206  if (!suite.add(set.size()==2))
207    suite.err() << "error: set.size(): " << set.size() << " expected 2\n";
208
209  set.insert_merge(Segment<double>(0,100));
210  if (!suite.add(set.size()==1))
211    suite.err() << "error: set.size(): " << set.size() << " expected 1\n";
212  set.insert_merge(set.end(), Segment<double>(200, 1000));
213
214  SegmentSet<double> set2;
215  set2.insert_merge(set.begin(), set.end());
216  std::vector<Segment<double> > vec(set.size());
217  std::copy(set.begin(), set.end(), vec.begin());
218  set2.insert_merge(vec.begin(), vec.end());
219}
220
221
222void make_segment_foo(Segment<int> seg)
223{
224}
225
226
227void test_make_segment(test::Suite& suite)
228{
229  make_segment_foo(make_segment(12, 18));
230}
231
232
233void test_set_bound(test::Suite& suite)
234{
235  SegmentSet<double> set;
236  set.insert(Segment<double>(0,2));
237  set.begin();
238  set.end();
239  if (!suite.add(set.lower_bound(-1)==set.begin()))
240    suite.err() << "error: expected set.lower_bound to return begin()\n";
241  if (!suite.add(set.lower_bound(1)==set.begin()))
242    suite.err() << "error: expected set.lower_bound to return begin()\n";
243  if (!suite.add(set.lower_bound(2)==set.end()))
244    suite.err() << "error: expected set.lower_bound to return end()\n";
245
246  if (!suite.add(set.upper_bound(0)==set.end()))
247    suite.err() << "error: expected set.upper_bound to return end()\n";
248  if (!suite.add(set.upper_bound(2)==set.end()))
249    suite.err() << "error: expected set.upper_bound to return end()\n";
250
251  set.insert_merge(Segment<double>(3,4));
252  SegmentSet<double>::const_iterator i=set.lower_bound(3.5);
253  if (i->begin() != 3 || i->end() != 4) {
254    suite.add(false);
255    suite.out() << "found: " << i->begin() << " " << i->end() << "\n";
256    suite.out() << "expected: 3 4\n";
257  }
258
259  i=set.lower_bound(1);
260  if (i->begin() != 0 || i->end() != 2) {
261    suite.add(false);
262    suite.out() << "found: " << i->begin() << " " << i->end() << "\n";
263    suite.out() << "expected: 0 2\n";
264  }
265
266  set.clear();
267}
268
269void test_segment_map(test::Suite& suite)
270{
271  typedef SegmentMap<double, std::string> Map;
272  Map map;
273  Map::element_type x = 0.0;
274  avoid_pedantic_warning(x);
275  Map::key_type key = Segment<double>(1.0,2.0);
276  Map::mapped_type  mapped = "foofana";
277
278  map.insert(Map::value_type(key, mapped));
279  suite.add(map.find(1.5) != map.end());
280  suite.add(map.find(1.5)->second == "foofana");
281
282  Map::iterator i = map.begin();
283  i = map.end();
284  const Map const_map(map);
285  Map::const_iterator ci = const_map.begin();
286  ci = const_map.end();
287
288  suite.add(map.size()==1);
289  map.clear();
290  suite.add(map.empty()==true);
291  suite.add(map.size()==0);
292  map = const_map;
293  suite.add(map.size()==1);
294  suite.add(const_map.count(1.0)==1);
295  suite.add(const_map.count(0.0)==0);
296  suite.add(const_map.empty()==false);
297  suite.add(const_map.find(1.0)==const_map.begin());
298  suite.add(const_map.find(30.0)==const_map.end());
299  ci = const_map.lower_bound(0.0);
300  ci = const_map.upper_bound(0.0);
301  i = map.lower_bound(0.0);
302  i = map.upper_bound(0.0);
303}
304
305void test_segment(test::Suite& suite)
306{
307  Segment<double> segment12(0,2);
308  Segment<double> segment13(1,3);
309  if (segment12==segment13) {
310    suite.add(false);
311    suite.err() << "segment12==segment13 : expected false\n";
312  }
313  if (!(segment12!=segment13)) {
314    suite.add(false);
315    suite.err() << "segment12!=segment13 : expected true\n";
316  }
317  Segment<double> segment14 = intersection(segment12, segment13);
318  suite.add(segment14.begin()==1);
319  suite.add(segment14.end()==2);
320
321  if (!suite.add(compare(Segment<double>(0,2), Segment<double>(3,4))))
322    suite.err() << "error: compare: expected 1\n";
323  if (!suite.add(compare_3way(Segment<double>(0,2), Segment<double>(3,4))==-1))
324    suite.err() << "error: compare_3way: expected -1\n";
325
326  if (!suite.add(compare(Segment<double>(0,2), Segment<double>(1,2))==false))
327    suite.err() << "error: compare: expected 0\n";
328  if (!suite.add(compare_3way(Segment<double>(0,2), Segment<double>(1,2))==0))
329    suite.err() << "error: compare_3way: expected 0\n";
330
331  if (!suite.add(compare(Segment<double>(3,4), Segment<double>(0,2))==false))
332    suite.err() << "error: compare: expected 0\n";
333  if (!suite.add(compare_3way(Segment<double>(3,4), Segment<double>(0,2))==1))
334    suite.err() << "error: compare_3way: expected 1\n";
335
336}
337
338
339void test_includes(test::Suite& suite, const Segment<int>& a,
340                   const Segment<int>& b, bool answer)
341{
342  if (includes(a, b) != answer) {
343    suite.add(false);
344    suite.err() << "error: includes: "
345                << "[" << a.begin() << ", "
346                << a.end() << ") "
347                << "[" << b.begin() << ", "
348                << b.end() << ") "
349                << "expected: " << answer << "\n";
350  }
351}
352
353
354void test_includes(test::Suite& suite)
355{
356  Segment<int> a(0, 10);
357  Segment<int> b(0, 5);
358  Segment<int> c(5, 10);
359
360  test_includes(suite, a, a, true);
361  test_includes(suite, a, b, false);
362  test_includes(suite, a, c, false);
363
364  test_includes(suite, b, a, true);
365  test_includes(suite, b, b, true);
366  test_includes(suite, b, c, false);
367
368  test_includes(suite, c, a, true);
369  test_includes(suite, c, b, false);
370  test_includes(suite, c, c, true);
371}
372
373
374void test_overlap(test::Suite& suite, const Segment<int>& a,
375                  const Segment<int>& b, bool answer)
376{
377  if (overlap(a, b) != answer) {
378    suite.add(false);
379    suite.err() << "error: overlap: "
380                << "[" << a.begin() << ", "
381                << a.end() << ") "
382                << "[" << b.begin() << ", "
383                << b.end() << ") "
384                << "expected: " << answer << "\n";
385  }
386}
387
388
389void test_overlap(test::Suite& suite)
390{
391  Segment<int> a(0, 10);
392  Segment<int> b(0, 5);
393  Segment<int> c(5, 10);
394
395  test_overlap(suite, a, a, true);
396  test_overlap(suite, a, b, true);
397  test_overlap(suite, a, c, true);
398
399  test_overlap(suite, b, a, true);
400  test_overlap(suite, b, b, true);
401  test_overlap(suite, b, c, false);
402
403  test_overlap(suite, c, a, true);
404  test_overlap(suite, c, b, false);
405  test_overlap(suite, c, c, true);
406}
407
408
409void test_union(test::Suite& suite, const Segment<int>& a,
410                const Segment<int>& b, const Segment<int>& answer)
411{
412  if (set_union(a, b) != answer) {
413    suite.add(false);
414    suite.err() << "error: union: "
415                << "[" << a.begin() << ", "
416                << a.end() << ") "
417                << "[" << b.begin() << ", "
418                << b.end() << ") "
419                << "expected: [" << answer.begin() << "," << answer.end()
420                << " )\n";
421  }
422}
423
424
425void test_union(test::Suite& suite)
426{
427  Segment<int> a(0, 10);
428  Segment<int> b(0, 5);
429  Segment<int> c(5, 12);
430
431  test_union(suite, a, a, a);
432  test_union(suite, a, b, a);
433  test_union(suite, a, c, Segment<int>(0,12));
434
435  test_union(suite, b, a, a);
436  test_union(suite, b, b, b);
437  test_union(suite, b, c, Segment<int>(0,12));
438
439  test_union(suite, c, a, Segment<int>(0,12));
440  test_union(suite, c, b, Segment<int>(0,12));
441  test_union(suite, c, c, c);
442}
Note: See TracBrowser for help on using the repository browser.