1 /*
2  * Copyright 2016 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 //#define LOG_NDEBUG 0
18 #define LOG_TAG "AData_test"
19 
20 #include <gtest/gtest.h>
21 #include <utils/RefBase.h>
22 //#include <utils/StrongPointer.h>
23 
24 #include <media/stagefright/foundation/AData.h>
25 #include <media/stagefright/foundation/ABuffer.h>
26 
27 namespace android {
28 
29 class ADataTest : public ::testing::Test {
30 };
31 
32 // ============ AUnion
33 
34 struct Events {
35     int dtor;
36     int ctor_empty;
37     int ctor_copy;
38 };
39 
40 struct EventCounter : public RefBase {
EventCounterandroid::EventCounter41     EventCounter(int *counter, int magic=1234) : mCounter(counter), mMagic(magic) { }
~EventCounterandroid::EventCounter42     virtual ~EventCounter() { ++*mCounter; mMagic = 0; }
magicandroid::EventCounter43     int magic() const { return mMagic; }
44 private:
45     int *mCounter;
46     int mMagic;
47 };
48 
49 struct DerivedCounter : public EventCounter {
DerivedCounterandroid::DerivedCounter50     DerivedCounter(int *counter, int magic=1234) : EventCounter(counter, magic) { }
51 };
52 
TEST_F(ADataTest,AUnion_Test)53 TEST_F(ADataTest, AUnion_Test) {
54     AUnion<int, const char *, char> u;
55     u.emplace<int>(4);
56     u.del<int>();
57     EXPECT_EQ(4, u.get<int>()); // verify that del<> is a no-op for trivial types, such as int.
58                                 // specifically, verify that it does not clear the objet memory
59 
60     u.emplace<const char *>("hello");
61     EXPECT_STREQ("hello", u.get<const char *>());
62     u.del<const char *>();
63 
64     // u.del<char *>();
65     // u.emplace<const int>(4);
66     u.emplace<void>();
67     u.del<void>();
68 
69     u.emplace<int>(~0);
70     u.del<int>();
71     EXPECT_EQ(~0, u.get<int>());
72     u.emplace<char>(0x15);
73     // verify that rest of memory after char is cleared upon construction
74     EXPECT_EQ(0, memcmp((char *)(&u) + sizeof(char), "\0\0\0", 3));
75     EXPECT_EQ(0x15, u.get<char>());
76     u.del<char>();
77 
78     AUnion<EventCounter, EventCounter *> d;
79     int destructions = 0;
80 
81     d.emplace<EventCounter>(&destructions);
82     d.del<EventCounter>();
83     EXPECT_EQ(1, destructions);
84 
85     EventCounter *ctr = new EventCounter(&destructions);
86     d.emplace<EventCounter *>(ctr);
87     d.del<EventCounter *>();
88     EXPECT_EQ(1, destructions);
89 
90     delete ctr;
91     EXPECT_EQ(2, destructions);
92 
93     AUnion<std::shared_ptr<EventCounter>, std::unique_ptr<EventCounter>> md;
94     md.emplace<std::shared_ptr<EventCounter>>(new EventCounter(&destructions));
95     std::shared_ptr<EventCounter> copy(md.get<std::shared_ptr<EventCounter>>());
96     std::weak_ptr<EventCounter> weak(copy);
97     EXPECT_EQ(2, destructions);
98 
99     copy.reset();
100     EXPECT_EQ(2, destructions);
101     md.del<std::shared_ptr<EventCounter>>();
102     EXPECT_EQ(3, destructions);
103     EXPECT_TRUE(weak.expired());
104 
105     md.emplace<std::unique_ptr<EventCounter>>(new EventCounter(&destructions));
106     EXPECT_EQ(3, destructions);
107 
108     std::unique_ptr<EventCounter> unique = std::move(md.get<std::unique_ptr<EventCounter>>());
109     EXPECT_EQ(3, destructions);
110     EXPECT_FALSE((bool)md.get<std::unique_ptr<EventCounter>>());
111 
112     md.del<std::unique_ptr<EventCounter>>();
113     EXPECT_EQ(3, destructions);
114     md.emplace<std::unique_ptr<EventCounter>>(std::move(unique));
115     EXPECT_TRUE((bool)md.get<std::unique_ptr<EventCounter>>());
116     EXPECT_EQ(3, destructions);
117 
118     md.del<std::unique_ptr<EventCounter>>();
119     EXPECT_EQ(4, destructions);
120 }
121 
TEST_F(ADataTest,AData_StaticTest)122 TEST_F(ADataTest, AData_StaticTest) {
123     using namespace std;
124 
125     static_assert(is_copy_assignable<shared_ptr<EventCounter>>::value, "");
126     static_assert(is_copy_constructible<shared_ptr<EventCounter>>::value, "");
127     static_assert(is_default_constructible<shared_ptr<EventCounter>>::value, "");
128 
129     static_assert(is_copy_assignable<weak_ptr<DerivedCounter>>::value, "");
130     static_assert(is_copy_constructible<weak_ptr<DerivedCounter>>::value, "");
131     static_assert(is_default_constructible<weak_ptr<DerivedCounter>>::value, "");
132 
133     static_assert(!is_copy_assignable<unique_ptr<DerivedCounter>>::value, "");
134     static_assert(!is_copy_constructible<unique_ptr<DerivedCounter>>::value, "");
135     static_assert(is_default_constructible<unique_ptr<DerivedCounter>>::value, "");
136 
137     static_assert(is_copy_assignable<sp<EventCounter>>::value, "");
138     static_assert(is_copy_constructible<sp<EventCounter>>::value, "");
139     static_assert(is_default_constructible<sp<EventCounter>>::value, "");
140 
141     static_assert(is_copy_assignable<wp<EventCounter>>::value, "");
142     static_assert(is_copy_constructible<wp<EventCounter>>::value, "");
143     static_assert(is_default_constructible<wp<EventCounter>>::value, "");
144 
145     static_assert(is_convertible<shared_ptr<DerivedCounter>, shared_ptr<EventCounter>>::value, "");
146     static_assert(!is_convertible<shared_ptr<EventCounter>, shared_ptr<DerivedCounter>>::value, "");
147 
148     static_assert(is_convertible<unique_ptr<DerivedCounter>, unique_ptr<EventCounter>>::value, "");
149     static_assert(!is_convertible<unique_ptr<EventCounter>, unique_ptr<DerivedCounter>>::value, "");
150 
151     static_assert(is_convertible<unique_ptr<DerivedCounter>, shared_ptr<EventCounter>>::value, "");
152     static_assert(!is_convertible<shared_ptr<DerivedCounter>, unique_ptr<EventCounter>>::value, "");
153 
154     static_assert(is_convertible<weak_ptr<DerivedCounter>, weak_ptr<EventCounter>>::value, "");
155     static_assert(!is_convertible<weak_ptr<EventCounter>, weak_ptr<DerivedCounter>>::value, "");
156 
157     static_assert(is_convertible<shared_ptr<DerivedCounter>, weak_ptr<EventCounter>>::value, "");
158     static_assert(!is_convertible<weak_ptr<DerivedCounter>, shared_ptr<EventCounter>>::value, "");
159 
160     static_assert(is_convertible<sp<EventCounter>, sp<RefBase>>::value, "");
161     static_assert(is_convertible<sp<RefBase>, sp<EventCounter>>::value, "YES");
162 
163     static_assert(is_convertible<wp<EventCounter>, wp<RefBase>>::value, "");
164     static_assert(is_convertible<wp<RefBase>, wp<EventCounter>>::value, "YES");
165 
166     static_assert(is_convertible<sp<EventCounter>, wp<RefBase>>::value, "");
167     static_assert(!is_convertible<wp<EventCounter>, sp<RefBase>>::value, "");
168 }
169 
TEST_F(ADataTest,AData_SampleTest)170 TEST_F(ADataTest, AData_SampleTest) {
171     AData<int, float>::Basic data;
172     int i = 1;
173     float f = 7.0f;
174 
175     data.set(5);
176     EXPECT_TRUE(data.find(&i));
177     EXPECT_FALSE(data.find(&f));
178     EXPECT_EQ(i, 5);
179 
180     data.set(6.0f);
181     EXPECT_FALSE(data.find(&i));
182     EXPECT_TRUE(data.find(&f));
183     EXPECT_EQ(f, 6.0f);
184 
185     AData<int, sp<RefBase>>::RelaxedBasic objdata; // relaxed type support
186     sp<ABuffer> buf = new ABuffer(16), buf2;
187     sp<RefBase> obj;
188 
189     objdata.set(buf);
190     EXPECT_TRUE(objdata.find(&buf2));
191     EXPECT_EQ(buf, buf2);
192     EXPECT_FALSE(objdata.find(&i));
193     EXPECT_TRUE(objdata.find(&obj));
194     EXPECT_TRUE(obj == buf);
195 
196     obj = buf;
197     objdata.set(obj); // storing as sp<RefBase>
198     EXPECT_FALSE(objdata.find(&buf2));  // not stored as ABuffer(!)
199     EXPECT_TRUE(objdata.find(&obj));
200 }
201 
202 struct SampleTypeFlagger {
203     typedef unsigned type;
204     enum Flags : type {
205         kEmpty = 100,
206         kInt,
207         kConstCharPtr,
208         kEventCounter,
209         kEventCounterPointer,
210         kEventCounterSharedPointer,
211         kEventCounterUniquePointer,
212         kEventCounterWeakPointer,
213         kEventCounterSP,
214         kEventCounterWP,
215     };
216     constexpr static type mask = ~Flags(0);
flagForandroid::SampleTypeFlagger217     constexpr static type flagFor(void*) { return kEmpty; }
flagForandroid::SampleTypeFlagger218     constexpr static type flagFor(int*) { return kInt; }
flagForandroid::SampleTypeFlagger219     constexpr static type flagFor(const char**) { return kConstCharPtr; }
flagForandroid::SampleTypeFlagger220     constexpr static type flagFor(EventCounter*) { return kEventCounter; }
flagForandroid::SampleTypeFlagger221     constexpr static type flagFor(EventCounter**) { return kEventCounterPointer; }
222     constexpr static
flagForandroid::SampleTypeFlagger223     type flagFor(std::shared_ptr<EventCounter>*) { return kEventCounterSharedPointer; }
224     constexpr static
flagForandroid::SampleTypeFlagger225     type flagFor(std::unique_ptr<EventCounter>*) { return kEventCounterUniquePointer; }
flagForandroid::SampleTypeFlagger226     constexpr static type flagFor(std::weak_ptr<EventCounter>*) { return kEventCounterWeakPointer; }
flagForandroid::SampleTypeFlagger227     constexpr static type flagFor(sp<EventCounter>*) { return kEventCounterSP; }
flagForandroid::SampleTypeFlagger228     constexpr static type flagFor(wp<EventCounter>*) { return kEventCounterWP; }
canDeleteAsandroid::SampleTypeFlagger229     constexpr static bool canDeleteAs(type object, type del) { return del == object; }
230     template <typename T> struct store { typedef T as_type; };
231 };
232 
TEST_F(ADataTest,AData_SimpleTest)233 TEST_F(ADataTest, AData_SimpleTest) {
234     int _int = 0;
235     const char *_constCharPtr = NULL;
236     AData<int, const char *>::Custom<SampleTypeFlagger> u;
237     EXPECT_FALSE(u.used());
238     EXPECT_FALSE(u.find<int>(&_int));
239     EXPECT_FALSE(u.find<const char *>(&_constCharPtr));
240 
241     EXPECT_TRUE(u.set<int>(4));
242     EXPECT_TRUE(u.used());
243     EXPECT_TRUE(u.find<int>(&_int));
244     EXPECT_EQ(4, _int);
245     EXPECT_FALSE(u.find<const char *>(&_constCharPtr));
246     EXPECT_EQ(NULL, _constCharPtr);
247 
248     EXPECT_TRUE(u.clear());
249     EXPECT_FALSE(u.used());
250     EXPECT_FALSE(u.find<int>(&_int));
251     EXPECT_FALSE(u.find<const char *>(&_constCharPtr));
252 
253     EXPECT_TRUE(u.set<int>(5));
254     EXPECT_TRUE(u.set<int>(6));
255     EXPECT_TRUE(u.find<int>(&_int));
256     EXPECT_EQ(6, _int);
257 
258     EXPECT_TRUE(u.set<const char *>("hello"));
259     EXPECT_TRUE(u.used());
260     EXPECT_FALSE(u.find<int>(&_int));
261     EXPECT_TRUE(u.find<const char *>(&_constCharPtr));
262     EXPECT_STREQ("hello", _constCharPtr);
263 
264     EXPECT_TRUE(u.clear());
265     EXPECT_FALSE(u.used());
266     EXPECT_FALSE(u.find<int>(&_int));
267     EXPECT_FALSE(u.find<const char *>(&_constCharPtr));
268 
269     EXPECT_TRUE(u.set<const char *>("world"));
270     EXPECT_TRUE(u.set<const char *>("!!"));
271     EXPECT_TRUE(u.used());
272     EXPECT_FALSE(u.find<int>(&_int));
273     EXPECT_TRUE(u.find<const char *>(&_constCharPtr));
274     EXPECT_STREQ("!!", _constCharPtr);
275 
276     EXPECT_FALSE(u.find(&_int));
277     EXPECT_TRUE(u.find(&_constCharPtr));
278 }
279 
set(std::unique_ptr<int> & dst,std::unique_ptr<int> && src)280 void set(std::unique_ptr<int> &dst, std::unique_ptr<int> &&src) {
281     dst = std::move(src);
282 }
283 
set(std::unique_ptr<int> & dst,std::unique_ptr<int> & src)284 void set(std::unique_ptr<int> &dst, std::unique_ptr<int> &src) {
285     dst = std::move(src);
286 }
287 
TEST_F(ADataTest,AData_CopyMoveTest)288 TEST_F(ADataTest, AData_CopyMoveTest) {
289     int destructions = 0;
290     int _int = 0;
291     std::shared_ptr<EventCounter> _shared;
292     std::unique_ptr<EventCounter> _unique;
293     std::weak_ptr<EventCounter> _weak;
294     const std::shared_ptr<EventCounter> _constShared(new EventCounter(&destructions));
295     const std::unique_ptr<EventCounter> _constUnique = nullptr;
296 
297     AData<int, std::weak_ptr<EventCounter>, std::shared_ptr<EventCounter>,
298             std::unique_ptr<EventCounter>>::Basic u;
299 
300     // test that data is empty
301     EXPECT_FALSE(u.used());
302     EXPECT_FALSE(u.find(&_int));
303     EXPECT_FALSE(u.find(&_shared));
304     EXPECT_FALSE(u.remove(&_unique));
305     EXPECT_FALSE(u.find(&_weak));
306 
307     // test that integer can be stored and read
308     EXPECT_TRUE(u.set<int>(1));
309     EXPECT_TRUE(u.used());
310     EXPECT_TRUE(u.find(&_int));
311     EXPECT_EQ(1, _int);
312     EXPECT_FALSE(u.find(&_shared));
313     EXPECT_FALSE(u.remove(&_unique));
314     EXPECT_FALSE(u.find(&_weak));
315 
316     // test that movable type (unique_ptr) can be moved in and read out, and it moves
317     _unique = std::unique_ptr<EventCounter>(new EventCounter(&destructions, 123));
318     EXPECT_TRUE(u.set(std::move(_unique)));
319     EXPECT_FALSE((bool)_unique);
320     EXPECT_TRUE(u.used());
321     EXPECT_FALSE(u.find(&_int));
322     EXPECT_FALSE(u.find(&_shared));
323     EXPECT_FALSE(u.find(&_weak));
324     EXPECT_TRUE(u.remove(&_unique));
325     EXPECT_TRUE((bool)_unique);
326     if (_unique) {
327         EXPECT_EQ(123, _unique->magic());
328     }
329 
330     // the unique value should have been removed but still accessible as nullptr
331     EXPECT_TRUE(u.remove(&_unique));
332     EXPECT_FALSE((bool)_unique);
333     EXPECT_EQ(1, destructions);
334 
335     // test that movable-only type (unique_ptr) can be stored without moving (and is still
336     // moved)
337     _unique = std::unique_ptr<EventCounter>(new EventCounter(&destructions, 321));
338     EXPECT_TRUE(u.set(std::move(_unique)));
339     EXPECT_FALSE((bool)_unique);
340     EXPECT_TRUE(u.set(std::unique_ptr<EventCounter>(new EventCounter(&destructions, 1234))));
341     EXPECT_EQ(2, destructions);
342     EXPECT_TRUE(u.remove(&_unique));
343     EXPECT_TRUE((bool)_unique);
344     if (_unique) {
345         EXPECT_EQ(1234, _unique->magic());
346     }
347     EXPECT_TRUE(u.set(std::move(_unique)));
348     EXPECT_EQ(2, destructions);
349     EXPECT_TRUE(u.clear());
350     EXPECT_EQ(3, destructions);
351     EXPECT_FALSE(u.find(&_int));
352     EXPECT_FALSE(u.find(&_shared));
353     EXPECT_FALSE(u.remove(&_unique));
354     EXPECT_FALSE(u.find(&_weak));
355 
356     // u.set(_constUnique);
357 
358     // test that copiable & movable type (shared_ptr) is copied unless explicitly moved.
359     _shared = std::make_shared<EventCounter>(&destructions, 234);
360     EXPECT_EQ(1L, _shared.use_count());
361     EXPECT_TRUE(u.set(_shared));
362     EXPECT_TRUE((bool)_shared);
363     if (_shared) {
364         EXPECT_EQ(234, _shared->magic());
365     }
366 
367     EXPECT_EQ(2L, _shared.use_count());
368     EXPECT_FALSE(u.find(&_int));
369     EXPECT_FALSE(u.remove(&_unique));
370     EXPECT_FALSE(u.find(&_weak));
371     EXPECT_TRUE(u.find(&_shared));
372     EXPECT_EQ(2L, _shared.use_count());
373     EXPECT_TRUE((bool)_shared);
374     if (_shared) {
375         EXPECT_EQ(234, _shared->magic());
376     }
377 
378     // explicitly move in shared_ptr
379     EXPECT_TRUE(u.set(std::move(_shared)));
380     EXPECT_EQ(0, _shared.use_count()); // shared should be nullptr
381     EXPECT_FALSE((bool)_shared);
382     EXPECT_TRUE(u.find(&_shared));
383     EXPECT_EQ(2L, _shared.use_count()); // now both u and _shared contains the object
384     EXPECT_TRUE((bool)_shared);
385     if (_shared) {
386         EXPECT_EQ(234, _shared->magic());
387     }
388     EXPECT_FALSE(u.find(&_int));
389     EXPECT_FALSE(u.remove(&_unique));
390     EXPECT_FALSE(u.find(&_weak));
391     EXPECT_TRUE(u.find(&_shared));
392     EXPECT_EQ(2L, _shared.use_count()); // still both u and _shared contains the object
393 
394     EXPECT_TRUE(u.clear());
395     EXPECT_TRUE(_shared.unique()); // now only _shared contains the object
396 
397     EXPECT_TRUE(u.set(_constShared));
398     EXPECT_EQ(2L, _constShared.use_count()); // even though it is const, we can add a use count
399     EXPECT_TRUE(u.find(&_shared));
400     EXPECT_EQ(3L, _shared.use_count()); // now u, _shared and _constShared contains the const object
401     EXPECT_TRUE((bool)_shared);
402     if (_shared) {
403         EXPECT_EQ(1234, _shared->magic());
404     }
405 
406     // test that weak pointer can be copied in (support for moving is from C++14 only)
407     _weak = _shared;
408     EXPECT_EQ(_weak.use_count(), _shared.use_count());
409     EXPECT_TRUE(u.set(_weak));
410 
411     _weak.reset();
412     EXPECT_EQ(_weak.use_count(), 0);
413 
414     EXPECT_FALSE(u.find(&_int));
415     EXPECT_FALSE(u.remove(&_unique));
416     EXPECT_FALSE(u.find(&_shared));
417     EXPECT_TRUE(u.find(&_weak));
418     EXPECT_EQ(_weak.use_count(), _shared.use_count());
419     EXPECT_EQ(_weak.lock(), _shared);
420 
421     // we can remove a weak pointer multiple times
422     _weak.reset();
423     EXPECT_TRUE(u.find(&_weak));
424     EXPECT_EQ(_weak.use_count(), _shared.use_count());
425     EXPECT_EQ(_weak.lock(), _shared);
426     EXPECT_TRUE(u.clear());
427     EXPECT_FALSE(u.find(&_int));
428     EXPECT_FALSE(u.remove(&_unique));
429     EXPECT_FALSE(u.find(&_shared));
430     EXPECT_FALSE(u.find(&_weak));
431 };
432 
TEST_F(ADataTest,AData_RelaxedCopyMoveTest)433 TEST_F(ADataTest, AData_RelaxedCopyMoveTest) {
434     int destructions = 0;
435     int _int = 0;
436     std::shared_ptr<DerivedCounter> _shared;
437     std::unique_ptr<DerivedCounter> _unique, _unique2;
438     std::weak_ptr<DerivedCounter> _weak;
439     std::shared_ptr<EventCounter> _shared_base;
440     std::unique_ptr<EventCounter> _unique_base;
441     std::weak_ptr<EventCounter> _weak_base;
442     const std::shared_ptr<DerivedCounter> _constShared(new DerivedCounter(&destructions));
443     const std::unique_ptr<DerivedCounter> _constUnique = nullptr;
444 
445     AData<int, std::unique_ptr<EventCounter>, std::shared_ptr<EventCounter>,
446             std::weak_ptr<EventCounter>>::RelaxedBasic u;
447 
448     // test that data is empty
449     EXPECT_FALSE(u.used());
450     EXPECT_FALSE(u.find(&_int));
451     EXPECT_FALSE(u.find(&_shared));
452     EXPECT_FALSE(u.remove(&_unique));
453     EXPECT_FALSE(u.find(&_weak));
454     EXPECT_FALSE(u.find(&_shared_base));
455     EXPECT_FALSE(u.remove(&_unique_base));
456     EXPECT_FALSE(u.find(&_weak_base));
457 
458     // test that integer can be stored and read
459     EXPECT_TRUE(u.set<int>(1));
460     EXPECT_TRUE(u.used());
461     EXPECT_TRUE(u.find(&_int));
462     EXPECT_EQ(1, _int);
463     EXPECT_FALSE(u.find(&_shared));
464     EXPECT_FALSE(u.remove(&_unique));
465     EXPECT_FALSE(u.find(&_weak));
466     EXPECT_FALSE(u.find(&_shared_base));
467     EXPECT_FALSE(u.remove(&_unique_base));
468     EXPECT_FALSE(u.find(&_weak_base));
469 
470     // test that movable type (unique_ptr) can be moved in and read out, and it moves
471     _unique = std::unique_ptr<DerivedCounter>(new DerivedCounter(&destructions, 123));
472     EXPECT_TRUE(u.set(std::move(_unique)));
473     EXPECT_FALSE((bool)_unique);
474     EXPECT_TRUE(u.used());
475     EXPECT_FALSE(u.find(&_int));
476     EXPECT_FALSE(u.find(&_shared));
477     EXPECT_FALSE(u.find(&_weak));
478     EXPECT_TRUE(u.remove(&_unique));
479     EXPECT_TRUE((bool)_unique);
480     if (_unique) {
481         EXPECT_EQ(123, _unique->magic());
482     }
483 
484     // the unique value should have been removed but still accessible as nullptr
485     EXPECT_TRUE(u.remove(&_unique));
486     EXPECT_FALSE((bool)_unique);
487     EXPECT_EQ(1, destructions);
488 
489     EXPECT_FALSE(u.find(&_shared_base));
490     EXPECT_TRUE(u.remove(&_unique_base));
491     EXPECT_FALSE((bool)_unique_base);
492     EXPECT_FALSE(u.find(&_weak_base));
493 
494     // test that movable-only type (unique_ptr) can be stored without moving (and is still
495     // moved)
496     _unique = std::unique_ptr<DerivedCounter>(new DerivedCounter(&destructions, 321));
497     EXPECT_TRUE(u.set(std::move(_unique)));
498     EXPECT_FALSE((bool)_unique);
499     EXPECT_TRUE(u.set(std::unique_ptr<DerivedCounter>(new DerivedCounter(&destructions, 1234))));
500     EXPECT_EQ(2, destructions);
501     EXPECT_TRUE(u.remove(&_unique));
502     EXPECT_TRUE((bool)_unique);
503     if (_unique) {
504         EXPECT_EQ(1234, _unique->magic());
505     }
506     EXPECT_TRUE(u.set(std::move(_unique)));
507     EXPECT_EQ(2, destructions);
508     EXPECT_TRUE(u.clear());
509     EXPECT_EQ(3, destructions);
510     EXPECT_FALSE(u.find(&_int));
511     EXPECT_FALSE(u.find(&_shared));
512     EXPECT_FALSE(u.remove(&_unique));
513     EXPECT_FALSE(u.find(&_weak));
514     EXPECT_FALSE(u.find(&_shared_base));
515     EXPECT_FALSE(u.remove(&_unique_base));
516     EXPECT_FALSE(u.find(&_weak_base));
517 
518     // test that unique pointer can be set and removed as base type (but removed as derived only
519     // if it was set as derived type)
520     _unique = std::unique_ptr<DerivedCounter>(new DerivedCounter(&destructions, 321));
521     EXPECT_TRUE(u.set(std::move(_unique)));
522     EXPECT_FALSE((bool)_unique);
523     EXPECT_TRUE(u.remove(&_unique_base));
524     EXPECT_TRUE((bool)_unique_base);
525     if (_unique_base) {
526         EXPECT_EQ(321, _unique_base->magic());
527     }
528     EXPECT_TRUE(u.remove(&_unique));
529     EXPECT_FALSE((bool)_unique);
530 
531     EXPECT_TRUE(u.set(std::move(_unique_base)));
532     EXPECT_FALSE((bool)_unique_base);
533     EXPECT_FALSE(u.remove(&_unique));
534     EXPECT_FALSE((bool)_unique);
535     EXPECT_TRUE(u.remove(&_unique_base));
536     EXPECT_TRUE((bool)_unique_base);
537     if (_unique_base) {
538         EXPECT_EQ(321, _unique_base->magic());
539     }
540 
541     EXPECT_EQ(3, destructions);
542     EXPECT_TRUE(u.remove(&_unique_base));
543     EXPECT_EQ(4, destructions);
544     EXPECT_FALSE((bool)_unique_base);
545     EXPECT_FALSE(u.find(&_int));
546     EXPECT_FALSE(u.find(&_shared));
547     EXPECT_FALSE(u.find(&_shared_base));
548     EXPECT_FALSE(u.find(&_weak));
549     EXPECT_FALSE(u.find(&_weak_base));
550 
551     // u.set(_constUnique);
552 
553     // test that copiable & movable type (shared_ptr) is copied unless explicitly moved.
554     _shared = std::make_shared<DerivedCounter>(&destructions, 234);
555     EXPECT_EQ(1L, _shared.use_count());
556     EXPECT_TRUE(u.set(_shared));
557     EXPECT_TRUE((bool)_shared);
558     if (_shared) {
559         EXPECT_EQ(234, _shared->magic());
560     }
561 
562     EXPECT_EQ(2L, _shared.use_count());
563     EXPECT_FALSE(u.find(&_int));
564     EXPECT_FALSE(u.remove(&_unique));
565     EXPECT_FALSE(u.find(&_weak));
566     EXPECT_TRUE(u.find(&_shared));
567     EXPECT_FALSE(u.remove(&_unique_base));
568     EXPECT_FALSE(u.find(&_weak_base));
569     EXPECT_EQ(2L, _shared.use_count());
570     EXPECT_TRUE((bool)_shared);
571     if (_shared) {
572         EXPECT_EQ(234, _shared->magic());
573     }
574 
575     // explicitly move in shared_ptr
576     EXPECT_TRUE(u.set(std::move(_shared)));
577     EXPECT_EQ(0, _shared.use_count()); // shared should be nullptr
578     EXPECT_FALSE((bool)_shared);
579     EXPECT_TRUE(u.find(&_shared));
580     EXPECT_EQ(2L, _shared.use_count()); // now both u and _shared contains the object
581     EXPECT_TRUE((bool)_shared);
582     if (_shared) {
583         EXPECT_EQ(234, _shared->magic());
584     }
585     EXPECT_FALSE(u.find(&_int));
586     EXPECT_FALSE(u.remove(&_unique));
587     EXPECT_FALSE(u.find(&_weak));
588     EXPECT_FALSE(u.remove(&_unique_base));
589     EXPECT_FALSE(u.find(&_weak_base));
590     EXPECT_TRUE(u.find(&_shared));
591     EXPECT_EQ(2L, _shared.use_count()); // still both u and _shared contains the object
592 
593     EXPECT_TRUE(u.clear());
594     EXPECT_TRUE(_shared.unique()); // now only _shared contains the object
595 
596     EXPECT_TRUE(u.set(_constShared));
597     EXPECT_EQ(2L, _constShared.use_count()); // even though it is const, we can add a use count
598     EXPECT_TRUE(u.find(&_shared));
599     EXPECT_EQ(3L, _shared.use_count()); // now u, _shared and _constShared contains the const object
600     EXPECT_TRUE((bool)_shared);
601     if (_shared) {
602         EXPECT_EQ(1234, _shared->magic());
603     }
604 
605     // test that shared pointer can be set and removed as base type (but removed as derived only
606     // if it was set as derived type)
607     EXPECT_TRUE(u.find(&_shared_base));
608     EXPECT_TRUE((bool)_shared_base);
609     if (_shared_base) {
610         EXPECT_EQ(1234, _shared_base->magic());
611     }
612     EXPECT_EQ(4L, _shared.use_count()); // now u, _shared, _constShared and _shared_base contains
613                                         // the const object
614     _shared.reset();
615     EXPECT_EQ(3L, _shared_base.use_count()); // now u, _constShared and _shared_base contains it
616     EXPECT_TRUE(u.clear());
617     EXPECT_EQ(2L, _shared_base.use_count()); // now _constShared and _shared_base contains it
618 
619     EXPECT_TRUE(u.set(_shared_base));        // now u_ also contains it as base class
620     EXPECT_EQ(3L, _shared_base.use_count());
621     EXPECT_FALSE(u.find(&_shared)); // cannot get it as derived type
622     EXPECT_FALSE((bool)_shared);
623     _shared_base.reset();
624     EXPECT_TRUE(u.find(&_shared_base)); // can still get it as base type
625     EXPECT_TRUE((bool)_shared_base);
626     if (_shared_base) {
627         EXPECT_EQ(1234, _shared_base->magic());
628     }
629     _shared = std::static_pointer_cast<DerivedCounter>(_shared_base);
630     EXPECT_FALSE(u.find(&_int));
631     EXPECT_FALSE(u.remove(&_unique));
632     EXPECT_FALSE(u.remove(&_unique_base));
633     EXPECT_FALSE(u.find(&_weak));
634     EXPECT_FALSE(u.find(&_weak_base));
635 
636     // test that weak pointer can be copied in (support for moving is from C++14 only)
637     _weak = _shared;
638     EXPECT_EQ(_weak.use_count(), _shared.use_count());
639     EXPECT_TRUE(u.set(_weak));
640 
641     _weak.reset();
642     EXPECT_EQ(_weak.use_count(), 0);
643 
644     EXPECT_FALSE(u.find(&_int));
645     EXPECT_FALSE(u.remove(&_unique));
646     EXPECT_FALSE(u.find(&_shared));
647     EXPECT_FALSE(u.remove(&_unique_base));
648     EXPECT_FALSE(u.find(&_shared_base));
649     EXPECT_TRUE(u.find(&_weak));
650     EXPECT_EQ(_weak.use_count(), _shared.use_count());
651     EXPECT_EQ(_weak.lock(), _shared);
652 
653     // we can remove a weak pointer multiple times
654     _weak.reset();
655     EXPECT_TRUE(u.find(&_weak));
656     EXPECT_EQ(_weak.use_count(), _shared.use_count());
657     EXPECT_EQ(_weak.lock(), _shared);
658     EXPECT_TRUE(u.clear());
659     EXPECT_FALSE(u.find(&_int));
660     EXPECT_FALSE(u.remove(&_unique));
661     EXPECT_FALSE(u.find(&_shared));
662     EXPECT_FALSE(u.find(&_weak));
663     EXPECT_FALSE(u.remove(&_unique_base));
664     EXPECT_FALSE(u.find(&_shared_base));
665     EXPECT_FALSE(u.find(&_weak_base));
666 
667     // test that weak pointer can be set and removed as base type (but removed as derived only
668     // if it was set as derived type)
669     _weak = _shared;
670     EXPECT_TRUE(u.set(_weak));
671     EXPECT_TRUE(u.find(&_weak_base));
672     EXPECT_FALSE(_weak_base.expired());
673     if (!_weak_base.expired()) {
674         EXPECT_EQ(1234, _weak_base.lock()->magic());
675     }
676     // now _shared, _constShared and _shared_base contains the const object
677     EXPECT_EQ(3L, _weak.use_count());
678     _weak.reset();
679     EXPECT_EQ(3L, _weak_base.use_count()); // _weak did not hold a reference
680     _shared.reset();
681     EXPECT_EQ(2L, _weak_base.use_count()); // now u, _constShared and _shared_base contains it
682     EXPECT_TRUE(u.clear());
683     EXPECT_FALSE(u.find(&_int));
684     EXPECT_FALSE(u.remove(&_unique));
685     EXPECT_FALSE(u.find(&_shared));
686     EXPECT_FALSE(u.find(&_weak));
687     EXPECT_FALSE(u.remove(&_unique_base));
688     EXPECT_FALSE(u.find(&_shared_base));
689     EXPECT_FALSE(u.find(&_weak_base));
690 
691     EXPECT_TRUE(u.set(_weak_base)); // now u_ also contains it as base class
692     EXPECT_FALSE(u.find(&_weak));   // cannot get it as derived type
693     EXPECT_TRUE(_weak.expired());
694     _weak_base.reset();
695     EXPECT_TRUE(u.find(&_weak_base)); // can still get it as base type
696     EXPECT_FALSE(_weak_base.expired());
697     if (!_weak_base.expired()) {
698         EXPECT_EQ(1234, _weak_base.lock()->magic());
699     }
700 };
701 
TEST_F(ADataTest,AData_AndroidSpTest)702 TEST_F(ADataTest, AData_AndroidSpTest) {
703     int destructions = 0;
704     int _int = 0;
705     sp<EventCounter> _shared;
706     wp<EventCounter> _weak;
707     const sp<EventCounter> _constShared(new EventCounter(&destructions));
708 
709     AData<int, sp<EventCounter>, wp<EventCounter>>::Strict<uint8_t> u;
710 
711     // test that data is empty
712     EXPECT_FALSE(u.used());
713     EXPECT_FALSE(u.find(&_int));
714     EXPECT_FALSE(u.find(&_shared));
715     EXPECT_FALSE(u.find(&_weak));
716 
717     // test that integer can be stored and read
718     EXPECT_TRUE(u.set<int>(1));
719     EXPECT_TRUE(u.used());
720     EXPECT_TRUE(u.find(&_int));
721     EXPECT_EQ(1, _int);
722     EXPECT_FALSE(u.find(&_shared));
723     EXPECT_FALSE(u.find(&_weak));
724 
725     // test that copiable & movable type (shared_ptr) is copied unless explicitly moved.
726     _shared = new EventCounter(&destructions, 234);
727     _weak = _shared; // used for tracking #234
728 
729     EXPECT_TRUE(u.set(_shared));
730     EXPECT_TRUE((bool)_shared.get());
731     if (_shared.get()) {
732         EXPECT_EQ(234, _shared->magic());
733     }
734 
735     _shared.clear();
736     EXPECT_EQ(NULL, _shared.get());
737     EXPECT_NE(nullptr, _weak.promote().get()); // u still holds object
738 
739     EXPECT_FALSE(u.find(&_int));
740     EXPECT_FALSE(u.find(&_weak));
741     EXPECT_TRUE(u.find(&_shared)); // now u and _shared both hold object
742     EXPECT_TRUE((bool)_shared.get());
743     if (_shared.get()) {
744         EXPECT_EQ(234, _shared->magic());
745     }
746     // verify the find did not move out object
747     _shared.clear();
748     EXPECT_EQ(NULL, _shared.get());
749     EXPECT_NE(nullptr, _weak.promote().get()); // u still holds object
750     EXPECT_TRUE(u.find(&_shared)); // now u and _shared both hold object
751     if (_shared.get()) {
752         EXPECT_EQ(234, _shared->magic());
753     }
754 
755     // verify that we can set object multiple times
756     EXPECT_TRUE(u.set(_shared));
757 
758     // explicitly move in sp
759     EXPECT_TRUE(u.set(std::move(_shared)));
760     EXPECT_FALSE((bool)_shared.get()); // android also clears sp<> on move...
761     EXPECT_TRUE(u.find(&_shared)); // still can get it back
762     EXPECT_TRUE((bool)_shared.get());
763     if (_shared.get()) {
764         EXPECT_EQ(234, _shared->magic());
765     }
766     EXPECT_FALSE(u.find(&_int));
767     EXPECT_FALSE(u.find(&_weak));
768 
769     EXPECT_TRUE(u.used());
770     EXPECT_TRUE(u.clear()); // now only _shared contains the object
771     EXPECT_FALSE(u.used());
772 
773     // we still hold a copy
774     EXPECT_TRUE((bool)_shared.get());
775     EXPECT_FALSE(u.find(&_int));
776     EXPECT_FALSE(u.find(&_shared)); // _shared still contains the object
777 
778     EXPECT_TRUE(u.set(_constShared));
779     EXPECT_TRUE(u.find(&_shared)); // now _shared contains _constShared
780     EXPECT_EQ(NULL, _weak.promote().get()); // original _shared is now lost
781 
782     EXPECT_TRUE((bool)_shared.get());
783     if (_shared.get()) {
784         EXPECT_EQ(1234, _shared->magic());
785     }
786     EXPECT_TRUE(u.clear());
787 
788     // test that wp can be copied in
789     _weak = _shared;
790     EXPECT_TRUE(u.set(_weak));
791 
792     _weak.clear();
793 
794     EXPECT_FALSE(u.find(&_int));
795     EXPECT_FALSE(u.find(&_shared));
796     EXPECT_TRUE(u.find(&_weak));
797     EXPECT_EQ(_weak.promote(), _shared);
798 
799     // we can remove a weak pointer multiple times
800     _weak.clear();
801     EXPECT_TRUE(u.find(&_weak));
802     EXPECT_EQ(_weak.promote(), _shared);
803     EXPECT_TRUE(u.clear());
804     EXPECT_FALSE(u.find(&_int));
805     EXPECT_FALSE(u.find(&_shared));
806     EXPECT_FALSE(u.find(&_weak));
807 };
808 
TEST_F(ADataTest,AData_RelaxedAndroidSpTest)809 TEST_F(ADataTest, AData_RelaxedAndroidSpTest) {
810     int destructions = 0;
811     int _int = 0;
812     sp<EventCounter> _shared;
813     wp<EventCounter> _weak;
814     sp<RefBase> _shared_base;
815     wp<RefBase> _weak_base;
816     const sp<EventCounter> _constShared(new EventCounter(&destructions));
817 
818     AData<int, sp<RefBase>, wp<RefBase>>::Relaxed<uint16_t> u;
819 
820     // test that data is empty
821     EXPECT_FALSE(u.used());
822     EXPECT_FALSE(u.find(&_int));
823     EXPECT_FALSE(u.find(&_shared));
824     EXPECT_FALSE(u.find(&_weak));
825     EXPECT_FALSE(u.find(&_shared_base));
826     EXPECT_FALSE(u.find(&_weak_base));
827 
828     // test that integer can be stored and read
829     EXPECT_TRUE(u.set<int>(1));
830     EXPECT_TRUE(u.used());
831     EXPECT_TRUE(u.find(&_int));
832     EXPECT_EQ(1, _int);
833     EXPECT_FALSE(u.find(&_shared));
834     EXPECT_FALSE(u.find(&_weak));
835     EXPECT_FALSE(u.find(&_shared_base));
836     EXPECT_FALSE(u.find(&_weak_base));
837 
838     // test that copiable & movable type (shared_ptr) is copied unless explicitly moved.
839     _shared = new EventCounter(&destructions, 234);
840     _weak = _shared; // used for tracking #234
841 
842     EXPECT_TRUE(u.set(_shared));
843     EXPECT_TRUE((bool)_shared.get());
844     if (_shared.get()) {
845         EXPECT_EQ(234, _shared->magic());
846     }
847 
848     _shared.clear();
849     EXPECT_EQ(NULL, _shared.get());
850     EXPECT_NE(nullptr, _weak.promote().get()); // u still holds object
851 
852     EXPECT_FALSE(u.find(&_int));
853     EXPECT_TRUE(u.find(&_shared)); // now u and _shared both hold object
854     EXPECT_TRUE((bool)_shared.get());
855     if (_shared.get()) {
856         EXPECT_EQ(234, _shared->magic());
857     }
858     // verify the find did not move out object
859     _shared.clear();
860     EXPECT_EQ(NULL, _shared.get());
861     EXPECT_NE(nullptr, _weak.promote().get()); // u still holds object
862     EXPECT_TRUE(u.find(&_shared)); // now u and _shared both hold object
863     if (_shared.get()) {
864         EXPECT_EQ(234, _shared->magic());
865     }
866 
867     // verify that we can set object multiple times
868     EXPECT_TRUE(u.set(_shared));
869 
870     // explicitly move in sp
871     EXPECT_TRUE(u.set(std::move(_shared)));
872     EXPECT_FALSE((bool)_shared.get()); // android also clears sp<> on move...
873     EXPECT_TRUE(u.find(&_shared)); // still can get it back
874     EXPECT_TRUE((bool)_shared.get());
875     if (_shared.get()) {
876         EXPECT_EQ(234, _shared->magic());
877     }
878     EXPECT_FALSE(u.find(&_int));
879     EXPECT_FALSE(u.find(&_weak));
880     EXPECT_FALSE(u.find(&_weak_base));
881 
882     EXPECT_TRUE(u.used());
883     EXPECT_TRUE(u.clear()); // now only _shared contains the object
884     EXPECT_FALSE(u.used());
885 
886     // we still hold a copy
887     EXPECT_TRUE((bool)_shared.get());
888     EXPECT_FALSE(u.find(&_int));
889     EXPECT_FALSE(u.find(&_shared)); // _shared still contains the object
890 
891     EXPECT_TRUE(u.set(_constShared));
892     EXPECT_TRUE(u.find(&_shared)); // now _shared contains _constShared
893     EXPECT_EQ(NULL, _weak.promote().get()); // original _shared is now lost
894 
895     EXPECT_TRUE((bool)_shared.get());
896     if (_shared.get()) {
897         EXPECT_EQ(1234, _shared->magic());
898     }
899     EXPECT_TRUE(u.clear());
900 
901     // test that shared pointer can be set and removed as base type (but removed as derived only
902     // if it was set as derived type)
903     EXPECT_TRUE(u.set(_constShared));
904     EXPECT_TRUE(u.find(&_shared_base));
905     EXPECT_TRUE((bool)_shared_base.get());
906     if (_shared_base.get()) {
907         EXPECT_EQ(1234, static_cast<EventCounter*>(_shared_base.get())->magic());
908     }
909     _shared.clear();
910     EXPECT_TRUE(u.clear());
911     EXPECT_TRUE((bool)_shared_base.get());
912     if (_shared_base.get()) {
913         EXPECT_EQ(1234, static_cast<EventCounter*>(_shared_base.get())->magic());
914     }
915 
916     EXPECT_TRUE(u.set(_shared_base)); // now u contains it as base class
917     EXPECT_TRUE((bool)_shared_base.get());
918     EXPECT_FALSE(u.find(&_shared)); // cannot get it as derived type
919     EXPECT_FALSE((bool)_shared.get());
920     _shared_base.clear();
921     EXPECT_TRUE(u.find(&_shared_base)); // can still get it as base type
922     EXPECT_TRUE((bool)_shared_base.get());
923     if (_shared_base.get()) {
924         EXPECT_EQ(1234, static_cast<EventCounter*>(_shared_base.get())->magic());
925     }
926     _shared = static_cast<DerivedCounter*>(_shared_base.get());
927     EXPECT_FALSE(u.find(&_int));
928     EXPECT_FALSE(u.find(&_weak));
929     EXPECT_FALSE(u.find(&_weak_base));
930 
931     // test that wp can be copied in
932     _weak = _shared;
933     EXPECT_TRUE(u.set(_weak));
934 
935     _weak.clear();
936 
937     EXPECT_FALSE(u.find(&_int));
938     EXPECT_FALSE(u.find(&_shared));
939     EXPECT_FALSE(u.find(&_shared_base));
940     EXPECT_TRUE(u.find(&_weak));
941     EXPECT_EQ(_weak.promote(), _shared);
942 
943     // we can remove a weak pointer multiple times
944     _weak.clear();
945     EXPECT_TRUE(u.find(&_weak));
946     EXPECT_EQ(_weak.promote(), _shared);
947     EXPECT_TRUE(u.clear());
948     EXPECT_FALSE(u.find(&_int));
949     EXPECT_FALSE(u.find(&_shared));
950     EXPECT_FALSE(u.find(&_weak));
951     EXPECT_FALSE(u.find(&_shared_base));
952     EXPECT_FALSE(u.find(&_weak_base));
953 
954     // test that weak pointer can be set and removed as base type (but removed as derived only
955     // if it was set as derived type)
956     _weak = _shared;
957     EXPECT_TRUE(u.set(_weak));
958     EXPECT_TRUE(u.find(&_weak_base));
959     EXPECT_TRUE(_weak_base.promote().get() == _shared.get());
960 
961     _weak.clear();
962     _shared.clear();
963     EXPECT_TRUE(u.clear());
964     EXPECT_FALSE(u.find(&_int));
965     EXPECT_FALSE(u.find(&_shared));
966     EXPECT_FALSE(u.find(&_weak));
967     EXPECT_FALSE(u.find(&_shared_base));
968     EXPECT_FALSE(u.find(&_weak_base));
969 
970     EXPECT_TRUE(u.set(_weak_base)); // now u_ also contains it as base class
971     EXPECT_FALSE(u.find(&_weak));   // cannot get it as derived type
972     EXPECT_FALSE(_weak.promote().get());
973     _weak_base.clear();
974     EXPECT_TRUE(u.find(&_weak_base)); // can still get it as base type
975     EXPECT_TRUE(_weak_base.promote().get());
976     if (_weak_base.promote().get()) {
977         EXPECT_EQ(1234, static_cast<EventCounter*>(_weak_base.promote().get())->magic());
978     }
979 };
980 
TEST_F(ADataTest,AData_AssignmentTest)981 TEST_F(ADataTest, AData_AssignmentTest) {
982     typedef AData<sp<ABuffer>, int32_t>::Basic Data;
983 
984     sp<ABuffer> buf1 = new ABuffer((void *)"hello", 6);
985     wp<ABuffer> buf1w = buf1;
986 
987     Data obj1;
988     obj1.set(buf1);
989     EXPECT_NE(buf1w.promote(), nullptr);
990     buf1.clear();
991     EXPECT_NE(buf1w.promote(), nullptr);
992     obj1.clear();
993     EXPECT_EQ(buf1w.promote(), nullptr);
994 
995     buf1 = new ABuffer((void *)"again", 6);
996     buf1w = buf1;
997 
998     obj1.set(buf1);
999     EXPECT_TRUE(obj1.used());
1000     Data obj2 = obj1;
1001 
1002     sp<ABuffer> buf2;
1003     EXPECT_TRUE(obj2.find(&buf2));
1004     EXPECT_EQ(buf2, buf1);
1005     buf1.clear();
1006     buf2.clear();
1007     EXPECT_NE(buf1w.promote(), nullptr);
1008     obj1.clear();
1009     EXPECT_NE(buf1w.promote(), nullptr);
1010     obj2.clear();
1011     EXPECT_EQ(buf1w.promote(), nullptr);
1012 
1013     buf1 = new ABuffer((void *)"still", 6);
1014     buf1w = buf1;
1015 
1016     obj1.set(buf1);
1017     EXPECT_TRUE(obj1.used());
1018     obj2 = std::move(obj1);
1019     EXPECT_FALSE(obj1.used());
1020 
1021     EXPECT_TRUE(obj2.find(&buf2));
1022     EXPECT_EQ(buf2, buf1);
1023     buf1.clear();
1024     buf2.clear();
1025     EXPECT_NE(buf1w.promote(), nullptr);
1026     obj2.clear();
1027     EXPECT_EQ(buf1w.promote(), nullptr);
1028 
1029     typedef AData<sp<ABuffer>, std::unique_ptr<int32_t>>::Basic Data2;
1030     Data2 obj3, obj4;
1031 
1032     buf1 = new ABuffer((void *)"hence", 6);
1033     obj3.set(buf1);
1034     obj4 = std::move(obj3);
1035     EXPECT_FALSE(obj3.used());
1036     EXPECT_TRUE(obj4.find(&buf2));
1037     EXPECT_EQ(buf2, buf1);
1038 }
1039 
1040 } // namespace android
1041