← Back to branch summary

~paparazzi-uav/paparazzi/v5.0-manual

« back to all changes in this revision

Viewing changes to sw/ext/opencv_bebop/opencv/modules/core/test/test_ptr.cpp

  • Committer: Paparazzi buildbot
  • Date: 2016-05-18 15:00:29 UTC
  • Revision ID: felix.ruess+docbot@gmail.com-20160518150029-e8lgzi5kvb4p7un9
Manual import commit 4b8bbb730080dac23cf816b98908dacfabe2a8ec from v5.0 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sw/ext/opencv_bebop/opencv/modules/core/test/test_ptr.cpp
 
1
/*M///////////////////////////////////////////////////////////////////////////////////////
 
2
//
 
3
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
 
4
//
 
5
//  By downloading, copying, installing or using the software you agree to this license.
 
6
//  If you do not agree to this license, do not download, install,
 
7
//  copy or use the software.
 
8
//
 
9
//
 
10
//                           License Agreement
 
11
//                For Open Source Computer Vision Library
 
12
//
 
13
// Copyright (C) 2013, NVIDIA Corporation, all rights reserved.
 
14
// Third party copyrights are property of their respective owners.
 
15
//
 
16
// Redistribution and use in source and binary forms, with or without modification,
 
17
// are permitted provided that the following conditions are met:
 
18
//
 
19
//   * Redistribution's of source code must retain the above copyright notice,
 
20
//     this list of conditions and the following disclaimer.
 
21
//
 
22
//   * Redistribution's in binary form must reproduce the above copyright notice,
 
23
//     this list of conditions and the following disclaimer in the documentation
 
24
//     and/or other materials provided with the distribution.
 
25
//
 
26
//   * The name of the copyright holders may not be used to endorse or promote products
 
27
//     derived from this software without specific prior written permission.
 
28
//
 
29
// This software is provided by the copyright holders and contributors "as is" and
 
30
// any express or implied warranties, including, but not limited to, the implied
 
31
// warranties of merchantability and fitness for a particular purpose are disclaimed.
 
32
// In no event shall the copyright holders or contributors be liable for any direct,
 
33
// indirect, incidental, special, exemplary, or consequential damages
 
34
// (including, but not limited to, procurement of substitute goods or services;
 
35
// loss of use, data, or profits; or business interruption) however caused
 
36
// and on any theory of liability, whether in contract, strict liability,
 
37
// or tort (including negligence or otherwise) arising in any way out of
 
38
// the use of this software, even if advised of the possibility of such damage.
 
39
//
 
40
//M*/
 
41
 
 
42
#include "test_precomp.hpp"
 
43
 
 
44
using namespace cv;
 
45
 
 
46
namespace {
 
47
 
 
48
struct Reporter {
 
49
    Reporter(bool* deleted) : deleted_(deleted)
 
50
    { *deleted_ = false; }
 
51
 
 
52
    // the destructor is virtual, so that we can test dynamic_cast later
 
53
    virtual ~Reporter()
 
54
    { *deleted_ = true; }
 
55
 
 
56
private:
 
57
    bool* deleted_;
 
58
 
 
59
    Reporter(const Reporter&);
 
60
    Reporter& operator = (const Reporter&);
 
61
};
 
62
 
 
63
struct ReportingDeleter {
 
64
    ReportingDeleter(bool* deleted) : deleted_(deleted)
 
65
    { *deleted_ = false; }
 
66
 
 
67
    void operator()(void*)
 
68
    { *deleted_ = true; }
 
69
 
 
70
private:
 
71
    bool* deleted_;
 
72
};
 
73
 
 
74
int dummyObject;
 
75
 
 
76
}
 
77
 
 
78
TEST(Core_Ptr, default_ctor)
 
79
{
 
80
    Ptr<int> p;
 
81
    EXPECT_EQ(NULL, p.get());
 
82
}
 
83
 
 
84
TEST(Core_Ptr, owning_ctor)
 
85
{
 
86
    bool deleted = false;
 
87
 
 
88
    {
 
89
        Reporter* r = new Reporter(&deleted);
 
90
        Ptr<void> p(r);
 
91
        EXPECT_EQ(r, p.get());
 
92
    }
 
93
 
 
94
    EXPECT_TRUE(deleted);
 
95
 
 
96
    {
 
97
        Ptr<int> p(&dummyObject, ReportingDeleter(&deleted));
 
98
        EXPECT_EQ(&dummyObject, p.get());
 
99
    }
 
100
 
 
101
    EXPECT_TRUE(deleted);
 
102
 
 
103
    {
 
104
        Ptr<void> p((void*)0, ReportingDeleter(&deleted));
 
105
        EXPECT_EQ(NULL, p.get());
 
106
    }
 
107
 
 
108
    EXPECT_FALSE(deleted);
 
109
}
 
110
 
 
111
TEST(Core_Ptr, sharing_ctor)
 
112
{
 
113
    bool deleted = false;
 
114
 
 
115
    {
 
116
        Ptr<Reporter> p1(new Reporter(&deleted));
 
117
        Ptr<Reporter> p2(p1);
 
118
        EXPECT_EQ(p1.get(), p2.get());
 
119
        p1.release();
 
120
        EXPECT_FALSE(deleted);
 
121
    }
 
122
 
 
123
    EXPECT_TRUE(deleted);
 
124
 
 
125
    {
 
126
        Ptr<Reporter> p1(new Reporter(&deleted));
 
127
        Ptr<void> p2(p1);
 
128
        EXPECT_EQ(p1.get(), p2.get());
 
129
        p1.release();
 
130
        EXPECT_FALSE(deleted);
 
131
    }
 
132
 
 
133
    EXPECT_TRUE(deleted);
 
134
 
 
135
    {
 
136
        Ptr<Reporter> p1(new Reporter(&deleted));
 
137
        Ptr<int> p2(p1, &dummyObject);
 
138
        EXPECT_EQ(&dummyObject, p2.get());
 
139
        p1.release();
 
140
        EXPECT_FALSE(deleted);
 
141
    }
 
142
 
 
143
    EXPECT_TRUE(deleted);
 
144
}
 
145
 
 
146
TEST(Core_Ptr, assignment)
 
147
{
 
148
    bool deleted1 = false, deleted2 = false;
 
149
 
 
150
    {
 
151
        Ptr<Reporter> p1(new Reporter(&deleted1));
 
152
        p1 = p1;
 
153
        EXPECT_FALSE(deleted1);
 
154
    }
 
155
 
 
156
    EXPECT_TRUE(deleted1);
 
157
 
 
158
    {
 
159
        Ptr<Reporter> p1(new Reporter(&deleted1));
 
160
        Ptr<Reporter> p2(new Reporter(&deleted2));
 
161
        p2 = p1;
 
162
        EXPECT_TRUE(deleted2);
 
163
        EXPECT_EQ(p1.get(), p2.get());
 
164
        p1.release();
 
165
        EXPECT_FALSE(deleted1);
 
166
    }
 
167
 
 
168
    EXPECT_TRUE(deleted1);
 
169
 
 
170
    {
 
171
        Ptr<Reporter> p1(new Reporter(&deleted1));
 
172
        Ptr<void> p2(new Reporter(&deleted2));
 
173
        p2 = p1;
 
174
        EXPECT_TRUE(deleted2);
 
175
        EXPECT_EQ(p1.get(), p2.get());
 
176
        p1.release();
 
177
        EXPECT_FALSE(deleted1);
 
178
    }
 
179
 
 
180
    EXPECT_TRUE(deleted1);
 
181
}
 
182
 
 
183
TEST(Core_Ptr, release)
 
184
{
 
185
    bool deleted = false;
 
186
 
 
187
    Ptr<Reporter> p1(new Reporter(&deleted));
 
188
    p1.release();
 
189
    EXPECT_TRUE(deleted);
 
190
    EXPECT_EQ(NULL, p1.get());
 
191
}
 
192
 
 
193
TEST(Core_Ptr, reset)
 
194
{
 
195
    bool deleted_old = false, deleted_new = false;
 
196
 
 
197
    {
 
198
        Ptr<void> p(new Reporter(&deleted_old));
 
199
        Reporter* r = new Reporter(&deleted_new);
 
200
        p.reset(r);
 
201
        EXPECT_TRUE(deleted_old);
 
202
        EXPECT_EQ(r, p.get());
 
203
    }
 
204
 
 
205
    EXPECT_TRUE(deleted_new);
 
206
 
 
207
    {
 
208
        Ptr<void> p(new Reporter(&deleted_old));
 
209
        p.reset(&dummyObject, ReportingDeleter(&deleted_new));
 
210
        EXPECT_TRUE(deleted_old);
 
211
        EXPECT_EQ(&dummyObject, p.get());
 
212
    }
 
213
 
 
214
    EXPECT_TRUE(deleted_new);
 
215
}
 
216
 
 
217
TEST(Core_Ptr, swap)
 
218
{
 
219
    bool deleted1 = false, deleted2 = false;
 
220
 
 
221
    {
 
222
        Reporter* r1 = new Reporter(&deleted1);
 
223
        Reporter* r2 = new Reporter(&deleted2);
 
224
        Ptr<Reporter> p1(r1), p2(r2);
 
225
        p1.swap(p2);
 
226
        EXPECT_EQ(r1, p2.get());
 
227
        EXPECT_EQ(r2, p1.get());
 
228
        EXPECT_FALSE(deleted1);
 
229
        EXPECT_FALSE(deleted2);
 
230
        p1.release();
 
231
        EXPECT_TRUE(deleted2);
 
232
    }
 
233
 
 
234
    EXPECT_TRUE(deleted1);
 
235
 
 
236
    {
 
237
        Reporter* r1 = new Reporter(&deleted1);
 
238
        Reporter* r2 = new Reporter(&deleted2);
 
239
        Ptr<Reporter> p1(r1), p2(r2);
 
240
        swap(p1, p2);
 
241
        EXPECT_EQ(r1, p2.get());
 
242
        EXPECT_EQ(r2, p1.get());
 
243
        EXPECT_FALSE(deleted1);
 
244
        EXPECT_FALSE(deleted2);
 
245
        p1.release();
 
246
        EXPECT_TRUE(deleted2);
 
247
    }
 
248
 
 
249
    EXPECT_TRUE(deleted1);
 
250
}
 
251
 
 
252
TEST(Core_Ptr, accessors)
 
253
{
 
254
    {
 
255
        Ptr<int> p;
 
256
        EXPECT_EQ(NULL, static_cast<int*>(p));
 
257
        EXPECT_TRUE(p.empty());
 
258
    }
 
259
 
 
260
    {
 
261
        Size* s = new Size();
 
262
        Ptr<Size> p(s);
 
263
        EXPECT_EQ(s, static_cast<Size*>(p));
 
264
        EXPECT_EQ(s, &*p);
 
265
        EXPECT_EQ(&s->width, &p->width);
 
266
        EXPECT_FALSE(p.empty());
 
267
    }
 
268
}
 
269
 
 
270
namespace {
 
271
 
 
272
struct SubReporterBase {
 
273
    virtual ~SubReporterBase() {}
 
274
    int padding;
 
275
};
 
276
 
 
277
/* multiple inheritance, so that casts do something interesting */
 
278
struct SubReporter : SubReporterBase, Reporter
 
279
{
 
280
    SubReporter(bool* deleted) : Reporter(deleted)
 
281
    {}
 
282
};
 
283
 
 
284
}
 
285
 
 
286
TEST(Core_Ptr, casts)
 
287
{
 
288
    bool deleted = false;
 
289
 
 
290
    {
 
291
        Ptr<const Reporter> p1(new Reporter(&deleted));
 
292
        Ptr<Reporter> p2 = p1.constCast<Reporter>();
 
293
        EXPECT_EQ(p1.get(), p2.get());
 
294
        p1.release();
 
295
        EXPECT_FALSE(deleted);
 
296
    }
 
297
 
 
298
    EXPECT_TRUE(deleted);
 
299
 
 
300
    {
 
301
        SubReporter* sr = new SubReporter(&deleted);
 
302
        Ptr<Reporter> p1(sr);
 
303
        // This next check isn't really for Ptr itself; it checks that Reporter
 
304
        // is at a non-zero offset within SubReporter, so that the next
 
305
        // check will give us more confidence that the cast actually did something.
 
306
        EXPECT_NE(static_cast<void*>(sr), static_cast<void*>(p1.get()));
 
307
        Ptr<SubReporter> p2 = p1.staticCast<SubReporter>();
 
308
        EXPECT_EQ(sr, p2.get());
 
309
        p1.release();
 
310
        EXPECT_FALSE(deleted);
 
311
    }
 
312
 
 
313
    EXPECT_TRUE(deleted);
 
314
 
 
315
    {
 
316
        SubReporter* sr = new SubReporter(&deleted);
 
317
        Ptr<Reporter> p1(sr);
 
318
        EXPECT_NE(static_cast<void*>(sr), static_cast<void*>(p1.get()));
 
319
        Ptr<void> p2 = p1.dynamicCast<void>();
 
320
        EXPECT_EQ(sr, p2.get());
 
321
        p1.release();
 
322
        EXPECT_FALSE(deleted);
 
323
    }
 
324
 
 
325
    EXPECT_TRUE(deleted);
 
326
 
 
327
    {
 
328
        Ptr<Reporter> p1(new Reporter(&deleted));
 
329
        Ptr<SubReporter> p2 = p1.dynamicCast<SubReporter>();
 
330
        EXPECT_EQ(NULL, p2.get());
 
331
        p1.release();
 
332
        EXPECT_FALSE(deleted);
 
333
    }
 
334
 
 
335
    EXPECT_TRUE(deleted);
 
336
}
 
337
 
 
338
TEST(Core_Ptr, comparisons)
 
339
{
 
340
    Ptr<int> p1, p2(new int), p3(new int);
 
341
    Ptr<int> p4(p2, p3.get());
 
342
 
 
343
    // Not using EXPECT_EQ here, since none of them are really "expected" or "actual".
 
344
    EXPECT_TRUE(p1 == p1);
 
345
    EXPECT_TRUE(p2 == p2);
 
346
    EXPECT_TRUE(p2 != p3);
 
347
    EXPECT_TRUE(p2 != p4);
 
348
    EXPECT_TRUE(p3 == p4);
 
349
}
 
350
 
 
351
TEST(Core_Ptr, make)
 
352
{
 
353
    bool deleted = true;
 
354
 
 
355
    {
 
356
        Ptr<void> p = makePtr<Reporter>(&deleted);
 
357
        EXPECT_FALSE(deleted);
 
358
    }
 
359
 
 
360
    EXPECT_TRUE(deleted);
 
361
}
 
362
 
 
363
namespace {
 
364
 
 
365
struct SpeciallyDeletable
 
366
{
 
367
    SpeciallyDeletable() : deleted(false)
 
368
    {}
 
369
    bool deleted;
 
370
};
 
371
 
 
372
}
 
373
 
 
374
namespace cv {
 
375
 
 
376
template<>
 
377
void DefaultDeleter<SpeciallyDeletable>::operator()(SpeciallyDeletable * obj) const
 
378
{ obj->deleted = true; }
 
379
 
 
380
}
 
381
 
 
382
TEST(Core_Ptr, specialized_deleter)
 
383
{
 
384
    SpeciallyDeletable sd;
 
385
 
 
386
    { Ptr<void> p(&sd); }
 
387
 
 
388
    ASSERT_TRUE(sd.deleted);
 
389
}