← Back to branch summary

~ubuntu-branches/ubuntu/trusty/liblas/trusty-proposed

« back to all changes in this revision

Viewing changes to test/unit/lasfile_test.cpp

  • Committer: Package Import Robot
  • Author(s): Francesco Paolo Lovergine
  • Date: 2014-01-05 17:00:29 UTC
  • mfrom: (7.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20140105170029-ddtp0j63x5jvck2u
Tags: 1.7.0+dfsg-2
http://bugs.debian.org/733282
Fixed missing linking of system boost component.
(closes: #733282)

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/unit/lasfile_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/lasfile.hpp>
9
 
#include <liblas/lasheader.hpp>
10
 
#include <liblas/lasreader.hpp>
11
 
#include <liblas/laswriter.hpp>
12
 
#include <tut/tut.hpp>
13
 
#include <stdexcept>
14
 
#include <string>
15
 
#include "liblas_test.hpp"
16
 
#include "common.hpp"
17
 
 
18
 
namespace tut
19
 
{ 
20
 
    struct lasfile_data
21
 
    {
22
 
        std::string tmpfile_;
23
 
        std::string file10_;
24
 
 
25
 
        lasfile_data()
26
 
            : tmpfile_(g_test_data_path + "//lasfile_tmp.las"),
27
 
                file10_(g_test_data_path + "//TO_core_last_clip.las")
28
 
        {}
29
 
 
30
 
        ~lasfile_data()
31
 
        {
32
 
            // remove temporary file after each test case
33
 
            std::remove(tmpfile_.c_str());
34
 
        }
35
 
    };
36
 
 
37
 
    typedef test_group<lasfile_data> tg;
38
 
    typedef tg::object to;
39
 
 
40
 
    tg test_group_lasfile("liblas::LASFile");
41
 
 
42
 
    // Test default constructor
43
 
    template<>
44
 
    template<>
45
 
    void to::test<1>()
46
 
    {
47
 
        liblas::LASFile file;
48
 
        ensure(file.IsNull());
49
 
    }
50
 
 
51
 
    // Test custom constructor
52
 
    template<>
53
 
    template<>
54
 
    void to::test<2>()
55
 
    {
56
 
        liblas::LASFile file(file10_);
57
 
        ensure_not(file.IsNull());
58
 
 
59
 
        ensure_equals(file.GetName(), file10_);
60
 
        ensure_equals(file.GetMode(), liblas::LASFile::eRead);
61
 
 
62
 
        liblas::LASHeader const& header1 = file.GetHeader();
63
 
        test_file10_header(header1);
64
 
 
65
 
        liblas::LASReader& reader = file.GetReader();
66
 
        liblas::LASHeader const& header2 = reader.GetHeader();
67
 
        test_file10_header(header2);
68
 
 
69
 
        try
70
 
        {
71
 
            liblas::LASWriter& writer = file.GetWriter();
72
 
            ensure_equals(writer.GetVersion(), liblas::eLASVersion10);
73
 
            ensure("std::runtime_error not thrown", false);
74
 
        }
75
 
        catch (std::runtime_error const& e)
76
 
        {
77
 
            ensure_equals(std::string(e.what()).substr(0, 6), std::string("Writer"));
78
 
        }
79
 
    }
80
 
 
81
 
    // Test custom constructor
82
 
    template<>
83
 
    template<>
84
 
    void to::test<3>()
85
 
    {
86
 
        liblas::LASHeader header;
87
 
 
88
 
        try
89
 
        {
90
 
            liblas::LASFile file(tmpfile_, header, liblas::LASFile::eRead);
91
 
            ensure_equals(file.GetName(), tmpfile_);
92
 
            ensure("std::runtime_error not thrown", false);
93
 
        }
94
 
        catch (std::runtime_error const& e)
95
 
        {
96
 
            ensure_equals(std::string(e.what()),
97
 
                std::string("File mode must be eWrite or eAppend"));
98
 
        }
99
 
    }
100
 
 
101
 
    // Test custom constructor
102
 
    template<>
103
 
    template<>
104
 
    void to::test<4>()
105
 
    {
106
 
        liblas::LASHeader header;
107
 
        liblas::LASFile file(tmpfile_, header, liblas::LASFile::eWrite);
108
 
        ensure_not(file.IsNull());
109
 
        ensure_equals(file.GetName(), tmpfile_);
110
 
        ensure_equals(file.GetMode(), liblas::LASFile::eWrite);
111
 
 
112
 
        liblas::LASHeader const& header1 = file.GetHeader();
113
 
        test_default_header(header1);
114
 
 
115
 
        liblas::LASWriter& writer = file.GetWriter();
116
 
        liblas::LASHeader const& header2 = writer.GetHeader();
117
 
        test_default_header(header2);
118
 
 
119
 
        try
120
 
        {
121
 
            liblas::LASReader& reader = file.GetReader();
122
 
            ensure_equals(reader.GetVersion(), liblas::eLASVersion10);
123
 
            ensure("std::runtime_error not thrown", false);
124
 
        }
125
 
        catch (std::runtime_error const& e)
126
 
        {
127
 
            ensure_equals(std::string(e.what()).substr(0, 6), std::string("Reader"));
128
 
        }
129
 
    }
130
 
 
131
 
    // Test copy constructor on default initialized object
132
 
    template<>
133
 
    template<>
134
 
    void to::test<5>()
135
 
    {
136
 
        liblas::LASFile file;
137
 
        ensure(file.IsNull());
138
 
 
139
 
        liblas::LASFile file2(file);
140
 
        ensure(file2.IsNull());
141
 
    }
142
 
 
143
 
    // Test assignment operator
144
 
    template<>
145
 
    template<>
146
 
    void to::test<6>()
147
 
    {
148
 
        liblas::LASFile file;
149
 
        ensure(file.IsNull());
150
 
 
151
 
        liblas::LASFile file2;
152
 
        file2 = file;
153
 
        ensure(file2.IsNull());
154
 
    }
155
 
 
156
 
    // Test copy constructor on read-only file
157
 
    template<>
158
 
    template<>
159
 
    void to::test<7>()
160
 
    {
161
 
        liblas::LASFile file(file10_);
162
 
 
163
 
        ensure_not(file.IsNull());
164
 
        ensure_equals(file.GetName(), file10_);
165
 
        ensure_equals(file.GetMode(), liblas::LASFile::eRead);
166
 
 
167
 
        liblas::LASHeader const& header1 = file.GetHeader();
168
 
        test_file10_header(header1);
169
 
 
170
 
        liblas::LASFile file2(file);
171
 
 
172
 
        ensure_not(file2.IsNull());
173
 
        ensure_equals(file2.GetName(), file10_);
174
 
        ensure_equals(file2.GetMode(), liblas::LASFile::eRead);
175
 
 
176
 
        liblas::LASHeader const& header2 = file2.GetHeader();
177
 
        test_file10_header(header2);
178
 
    }
179
 
 
180
 
    // Test assignment operator on read-only file
181
 
    template<>
182
 
    template<>
183
 
    void to::test<8>()
184
 
    {
185
 
        liblas::LASFile file2;
186
 
 
187
 
        {
188
 
            liblas::LASFile file(file10_);
189
 
 
190
 
            ensure_not(file.IsNull());
191
 
            ensure_equals(file.GetName(), file10_);
192
 
            ensure_equals(file.GetMode(), liblas::LASFile::eRead);
193
 
 
194
 
            liblas::LASHeader const& header1 = file.GetHeader();
195
 
            test_file10_header(header1);
196
 
 
197
 
            file2 = file;
198
 
 
199
 
            // file object is deallocated here
200
 
        }
201
 
 
202
 
        ensure_not(file2.IsNull());
203
 
        ensure_equals(file2.GetName(), file10_);
204
 
        ensure_equals(file2.GetMode(), liblas::LASFile::eRead);
205
 
 
206
 
        liblas::LASHeader const& header1 = file2.GetHeader();
207
 
        test_file10_header(header1);
208
 
    }
209
 
 
210
 
    // Test assignment operator on write-only file
211
 
    template<>
212
 
    template<>
213
 
    void to::test<9>()
214
 
    {
215
 
        liblas::LASHeader header;
216
 
        liblas::LASFile file(tmpfile_, header, liblas::LASFile::eWrite);
217
 
 
218
 
        ensure_not(file.IsNull());
219
 
        ensure_equals(file.GetName(), tmpfile_);
220
 
        ensure_equals(file.GetMode(), liblas::LASFile::eWrite);
221
 
 
222
 
        liblas::LASHeader const& header1 = file.GetHeader();
223
 
        test_default_header(header1);
224
 
 
225
 
        liblas::LASFile file2(file);
226
 
 
227
 
        ensure_not(file2.IsNull());
228
 
        ensure_equals(file2.GetName(), tmpfile_);
229
 
        ensure_equals(file2.GetMode(), liblas::LASFile::eWrite);
230
 
 
231
 
        liblas::LASHeader const& header2 = file2.GetHeader();
232
 
        test_default_header(header2);
233
 
    }
234
 
 
235
 
    // Test assignment operator on write-only file
236
 
    template<>
237
 
    template<>
238
 
    void to::test<10>()
239
 
    {
240
 
        liblas::LASFile file2;
241
 
 
242
 
        {
243
 
            liblas::LASHeader header;
244
 
            liblas::LASFile file(tmpfile_, header, liblas::LASFile::eWrite);
245
 
 
246
 
            ensure_not(file.IsNull());
247
 
            ensure_equals(file.GetName(), tmpfile_);
248
 
            ensure_equals(file.GetMode(), liblas::LASFile::eWrite);
249
 
 
250
 
            liblas::LASHeader const& header1 = file.GetHeader();
251
 
            test_default_header(header1);
252
 
 
253
 
            file2 = file;
254
 
 
255
 
            // file object is deallocated here
256
 
        }
257
 
 
258
 
        ensure_not(file2.IsNull());
259
 
        ensure_equals(file2.GetName(), tmpfile_);
260
 
        ensure_equals(file2.GetMode(), liblas::LASFile::eWrite);
261
 
 
262
 
        liblas::LASHeader const& header1 = file2.GetHeader();
263
 
        test_default_header(header1);
264
 
    }
265
 
}
266