← Back to branch summary

~ubuntu-branches/ubuntu/wily/liblas/wily

« back to all changes in this revision

Viewing changes to test/unit/laspoint_test.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Francesco Paolo Lovergine
  • Date: 2009-10-02 12:36:21 UTC
  • Revision ID: james.westby@ubuntu.com-20091002123621-xrf0hhzxbwloga43
Tags: upstream-1.2.1
Import upstream version 1.2.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/unit/laspoint_test.cpp
 
1
// $Id$
 
2
//
 
3
// (C) Copyright Mateusz Loskot 2008, mateusz@loskot.net
 
4
// Distributed under the BSD License
 
5
// (See accompanying file LICENSE.txt or copy at
 
6
// http://www.opensource.org/licenses/bsd-license.php)
 
7
//
 
8
#include <liblas/laspoint.hpp>
 
9
#include <liblas/lascolor.hpp>
 
10
#include <liblas/exception.hpp>
 
11
#include <tut/tut.hpp>
 
12
#include <bitset>
 
13
#include <stdexcept>
 
14
#include "common.hpp"
 
15
 
 
16
namespace tut
 
17
{ 
 
18
    struct laspoint_data
 
19
    {
 
20
        liblas::LASPoint m_default;
 
21
    };
 
22
 
 
23
    typedef test_group<laspoint_data> tg;
 
24
    typedef tg::object to;
 
25
 
 
26
    tg test_group_laspoint("liblas::LASPoint");
 
27
 
 
28
    // Test default construction
 
29
    template<>
 
30
    template<>
 
31
    void to::test<1>()
 
32
    {
 
33
        test_default_point(m_default);
 
34
    }
 
35
 
 
36
    // Test copy constructor
 
37
    template<>
 
38
    template<>
 
39
    void to::test<2>()
 
40
    {
 
41
        liblas::LASPoint p(m_default);
 
42
 
 
43
        test_default_point(p);
 
44
    }
 
45
 
 
46
    // Test assignment operator
 
47
    template<>
 
48
    template<>
 
49
    void to::test<3>()
 
50
    {
 
51
        liblas::LASPoint p;
 
52
        p = m_default;
 
53
 
 
54
        test_default_point(p);
 
55
    }
 
56
 
 
57
    // Test equal-to operator
 
58
    template<>
 
59
    template<>
 
60
    void to::test<4>()
 
61
    {
 
62
        liblas::LASPoint p;
 
63
        
 
64
        ensure("points are not equal", m_default == p);
 
65
    }
 
66
 
 
67
    // Test not-equal-to operator
 
68
    template<>
 
69
    template<>
 
70
    void to::test<5>()
 
71
    {
 
72
        liblas::LASPoint p;
 
73
        p.SetCoordinates(1.123, 2.456, 3.789);
 
74
        
 
75
        ensure("points are equal", m_default != p);
 
76
    }
 
77
 
 
78
    // Test Get/SetReturnNumber
 
79
    template<>
 
80
    template<>
 
81
    void to::test<6>()
 
82
    {
 
83
        ensure_equals("invalid default return number",
 
84
                      m_default.GetReturnNumber(), 0);
 
85
 
 
86
        liblas::uint16_t const num1 = 7;
 
87
        m_default.SetReturnNumber(num1);
 
88
        ensure_equals("invalid return number",
 
89
                      m_default.GetReturnNumber(), num1);
 
90
 
 
91
        liblas::uint16_t const num2 = 3;
 
92
        m_default.SetReturnNumber(num2);
 
93
        ensure_equals("invalid return number",
 
94
                      m_default.GetReturnNumber(), num2);
 
95
 
 
96
        try
 
97
        {
 
98
            liblas::uint16_t const outofrange = 8;
 
99
            m_default.SetReturnNumber(outofrange);
 
100
            m_default.Validate(); // throws
 
101
 
 
102
            // XXX - mloskot: Flag gets reset because of value overflow,
 
103
            // so in-range value is returned.
 
104
            //ensure("std::invalid_point_data not thrown", false);
 
105
        }
 
106
        catch (liblas::invalid_point_data const& e)
 
107
        {
 
108
            ensure_equals(e.who() & liblas::LASPoint::eReturnNumber,
 
109
                liblas::LASPoint::eReturnNumber);
 
110
        }
 
111
    }
 
112
 
 
113
    // Test Get/SetNumberOfReturns
 
114
    template<>
 
115
    template<>
 
116
    void to::test<7>()
 
117
    {
 
118
        ensure_equals("invalid default number of returns",
 
119
                      m_default.GetNumberOfReturns(), 0);
 
120
 
 
121
        liblas::uint16_t const num1 = 7;
 
122
        m_default.SetNumberOfReturns(num1);
 
123
        ensure_equals("invalid number of returns",
 
124
                      m_default.GetNumberOfReturns(), num1);
 
125
 
 
126
        liblas::uint16_t const num2 = 3;
 
127
        m_default.SetNumberOfReturns(num2);
 
128
        ensure_equals("invalid number of returns",
 
129
                      m_default.GetNumberOfReturns(), num2);
 
130
 
 
131
        try
 
132
        {
 
133
            liblas::uint16_t const outofrange = 8;
 
134
            m_default.SetNumberOfReturns(outofrange);
 
135
            m_default.Validate(); // throws
 
136
 
 
137
            // XXX - mloskot: Flag gets reset because of value overflow,
 
138
            // so in-range value is returned.
 
139
            //ensure("std::invalid_point_data not thrown", false);
 
140
        }
 
141
        catch (liblas::invalid_point_data const& e)
 
142
        {
 
143
            ensure_equals(e.who() & liblas::LASPoint::eNumberOfReturns,
 
144
                liblas::LASPoint::eNumberOfReturns);
 
145
        }
 
146
    }
 
147
 
 
148
    // Test Get/SetScanDirection
 
149
    template<>
 
150
    template<>
 
151
    void to::test<8>()
 
152
    {
 
153
        ensure_equals("invalid default scan direction flag",
 
154
                      m_default.GetScanDirection(), 0);
 
155
 
 
156
        liblas::uint16_t const positive = 1;
 
157
        m_default.SetScanDirection(positive);
 
158
        ensure_equals("invalid scan direction flag",
 
159
                      m_default.GetScanDirection(), positive);
 
160
 
 
161
        liblas::uint16_t const negative = 0;
 
162
        m_default.SetScanDirection(negative);
 
163
        ensure_equals("invalid scan direction flag",
 
164
                      m_default.GetScanDirection(), negative);
 
165
 
 
166
        try
 
167
        {
 
168
            liblas::uint16_t const outofrange = 2;
 
169
            m_default.SetScanDirection(outofrange);
 
170
            m_default.Validate(); // throws
 
171
 
 
172
            // XXX - mloskot: Flag gets reset because of value overflow,
 
173
            // so in-range value is returned.
 
174
            //ensure("std::invalid_point_data not thrown", false);
 
175
        }
 
176
        catch (liblas::invalid_point_data const& e)
 
177
        {
 
178
            ensure_equals(e.who() & liblas::LASPoint::eScanDirection,
 
179
                liblas::LASPoint::eScanDirection);
 
180
        }
 
181
    }
 
182
 
 
183
    // Test Get/SetFlightLineEdge
 
184
    template<>
 
185
    template<>
 
186
    void to::test<9>()
 
187
    {
 
188
        ensure_equals("invalid default edge of flight line",
 
189
                      m_default.GetFlightLineEdge(), 0);
 
190
 
 
191
        liblas::uint16_t const endofscan = 1;
 
192
        m_default.SetFlightLineEdge(endofscan);
 
193
        ensure_equals("invalid edge of flight line",
 
194
                      m_default.GetFlightLineEdge(), endofscan);
 
195
 
 
196
        liblas::uint16_t const notendofscan = 0;
 
197
        m_default.SetFlightLineEdge(notendofscan);
 
198
        ensure_equals("invalid edge of flight line",
 
199
                      m_default.GetFlightLineEdge(), notendofscan);
 
200
 
 
201
        try
 
202
        {
 
203
            liblas::uint16_t const outofrange = 2;
 
204
            m_default.SetFlightLineEdge(outofrange);
 
205
            m_default.Validate(); // throws
 
206
 
 
207
            // XXX - mloskot: Flag gets reset because of value overflow,
 
208
            // so in-range value is returned.
 
209
            //ensure("std::invalid_point_data not thrown", false);
 
210
        }
 
211
        catch (liblas::invalid_point_data const& e)
 
212
        {
 
213
            ensure_equals(e.who() & liblas::LASPoint::eFlightLineEdge,
 
214
                liblas::LASPoint::eFlightLineEdge);
 
215
        }
 
216
    }
 
217
 
 
218
    // Test Get/SetScanFlags
 
219
    template<>
 
220
    template<>
 
221
    void to::test<10>()
 
222
    {
 
223
        std::bitset<8> zeros;
 
224
        std::bitset<8> bits = m_default.GetScanFlags();
 
225
        
 
226
        ensure_equals("invalid default scan flags", bits, zeros);
 
227
 
 
228
        m_default.SetReturnNumber(3);
 
229
        m_default.SetNumberOfReturns(7);
 
230
        m_default.SetScanDirection(0);
 
231
        m_default.SetFlightLineEdge(1);
 
232
 
 
233
        std::bitset<8> expected(std::string("10111011"));
 
234
        bits = m_default.GetScanFlags();
 
235
        
 
236
        ensure_equals("invalid scan flags pattern", bits, expected);
 
237
 
 
238
        liblas::LASPoint copy(m_default);
 
239
        bits = copy.GetScanFlags();
 
240
        
 
241
        ensure_equals("invalid copy of scan flags pattern", bits, expected);
 
242
    }
 
243
 
 
244
    // Test Get/SetClassification
 
245
    template<>
 
246
    template<>
 
247
    void to::test<11>()
 
248
    {
 
249
        ensure_equals("invalid default classification",
 
250
            m_default.GetClassification(), 0);
 
251
 
 
252
        liblas::uint8_t const begclass = 0;
 
253
        m_default.SetClassification(begclass);
 
254
        ensure_equals("invalid classification",
 
255
            m_default.GetClassification(), begclass);
 
256
 
 
257
        liblas::uint8_t const endclass = 31;
 
258
        m_default.SetClassification(endclass);
 
259
        ensure_equals("invalid classification",
 
260
            m_default.GetClassification(), endclass);
 
261
    }
 
262
 
 
263
    // Test Get/SetScanAngleRank
 
264
    template<>
 
265
    template<>
 
266
    void to::test<12>()
 
267
    {
 
268
        ensure_equals("invalid default scan angle rank",
 
269
                      m_default.GetScanAngleRank(), 0);
 
270
 
 
271
        liblas::int8_t const rank1 = -90;
 
272
        m_default.SetScanAngleRank(rank1);
 
273
        ensure_equals("invalid scan angle rank",
 
274
                      m_default.GetScanAngleRank(), rank1);
 
275
 
 
276
        liblas::int8_t const rank2 = 90;
 
277
        m_default.SetScanAngleRank(rank2);
 
278
        ensure_equals("invalid scan angle rank",
 
279
                      m_default.GetScanAngleRank(), rank2);
 
280
 
 
281
        try
 
282
        {
 
283
            liblas::int8_t const outofrange = 91;
 
284
            m_default.SetScanAngleRank(outofrange);
 
285
            m_default.Validate(); // throws
 
286
 
 
287
            ensure("invalid_point_data not thrown", false);
 
288
        }
 
289
        catch (liblas::invalid_point_data const& e)
 
290
        {
 
291
            ensure_equals(e.who() & liblas::LASPoint::eScanAngleRank,
 
292
                liblas::LASPoint::eScanAngleRank);
 
293
        }
 
294
    }
 
295
 
 
296
    // Test Get/SetUserData
 
297
    template<>
 
298
    template<>
 
299
    void to::test<13>()
 
300
    {
 
301
        ensure_equals("invalid default user data value",
 
302
                      m_default.GetUserData(), 0);
 
303
 
 
304
        liblas::uint8_t const data = 7; // dummy value
 
305
        m_default.SetUserData(data);
 
306
 
 
307
        ensure_equals("invalid user data value",
 
308
                      m_default.GetUserData(), data);
 
309
    }
 
310
 
 
311
    // Test Get/SetTime
 
312
    template<>
 
313
    template<>
 
314
    void to::test<14>()
 
315
    {
 
316
        ensure_equals("invalid default time",
 
317
            m_default.GetTime(), 0);
 
318
 
 
319
        double const time = 3.14; // dummy value
 
320
        m_default.SetTime(time);
 
321
 
 
322
        ensure_equals("invalid time",
 
323
            m_default.GetTime(), time);
 
324
    }
 
325
 
 
326
    // Test IsValid method
 
327
    template<>
 
328
    template<>
 
329
    void to::test<15>()
 
330
    {
 
331
        {
 
332
            liblas::LASPoint p;
 
333
            liblas::uint16_t const outofrange = 8;
 
334
            p.SetReturnNumber(outofrange);
 
335
            // XXX: Bit flag overflowed, so point data recognized as valid
 
336
            //ensure_not(p.IsValid());
 
337
        }
 
338
 
 
339
        {
 
340
            liblas::LASPoint p;
 
341
            liblas::uint16_t const outofrange = 8;
 
342
            p.SetNumberOfReturns(outofrange);
 
343
            // XXX: Bit flag overflowed, so point data recognized as valid
 
344
            //ensure_not(p.IsValid());
 
345
        }
 
346
 
 
347
        {
 
348
            liblas::LASPoint p;
 
349
            liblas::uint16_t const outofrange = 2;
 
350
            p.SetScanDirection(outofrange);
 
351
            // XXX: Bit flag overflowed, so point data recognized as valid
 
352
            //ensure_not(p.IsValid());
 
353
        }
 
354
 
 
355
        {
 
356
            liblas::LASPoint p;
 
357
            liblas::uint16_t const outofrange = 2;
 
358
            p.SetFlightLineEdge(outofrange);
 
359
            // XXX: Bit flag overflowed, so point data recognized as valid
 
360
            //ensure_not(p.IsValid());
 
361
        }
 
362
 
 
363
        {
 
364
            liblas::LASPoint p;
 
365
            liblas::int8_t const outofrange = 91;
 
366
            p.SetScanAngleRank(outofrange);
 
367
            ensure_not(p.IsValid());
 
368
        }
 
369
    }
 
370
 
 
371
    // Test Get/SetColor
 
372
    template<>
 
373
    template<>
 
374
    void to::test<16>()
 
375
    {
 
376
        ensure_equals("invalid default red color",
 
377
            m_default.GetColor().GetRed(), 0);
 
378
 
 
379
        ensure_equals("invalid default green color",
 
380
            m_default.GetColor().GetGreen(), 0);
 
381
 
 
382
        ensure_equals("invalid default blue color",
 
383
            m_default.GetColor().GetBlue(), 0);
 
384
                        
 
385
        liblas::LASColor color;
 
386
        color.SetRed(211);
 
387
        color.SetGreen(211);
 
388
        color.SetBlue(211);
 
389
        
 
390
        m_default.SetColor(color);
 
391
 
 
392
        ensure_equals("invalid set red color",
 
393
            m_default.GetColor().GetRed(), 211);
 
394
 
 
395
        ensure_equals("invalid set green color",
 
396
            m_default.GetColor().GetGreen(), 211);
 
397
 
 
398
        ensure_equals("invalid set blue color",
 
399
            m_default.GetColor().GetBlue(), 211);
 
400
        
 
401
        liblas::LASPoint p = m_default;
 
402
 
 
403
        ensure_equals("invalid copied red color",
 
404
            p.GetColor().GetRed(), 211);
 
405
 
 
406
        ensure_equals("invalid copied green color",
 
407
            p.GetColor().GetGreen(), 211);
 
408
            
 
409
        ensure_equals("invalid copied blue color",
 
410
            p.GetColor().GetBlue(), 211);        
 
411
        
 
412
    }
 
413
}
 
414