1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <gtest/gtest.h>
16 #include <algorithm>
17 #include <fstream>
18 #include <iostream>
19 #include <vector>
20 #include <thread>
21 #include <map>
22 #include <mutex>
23 #include "refbase.h"
24 #include "singleton.h"
25
26 #include <future>
27 using namespace testing::ext;
28 using namespace std;
29
30 namespace OHOS {
31 namespace {
32 static constexpr int FLAG_OF_CONS = 1;
33 static constexpr int FLAG_OF_DEST = 2;
34 static int g_sptrCount = 0;
35 static int g_wptrCount = 0;
36 static int g_refbaseflag = 0;
37 static int g_freeFlag = 0;
38
39 class UtilsRefbaseTest : public testing::Test {
40 public:
41 static void SetUpTestCase(void);
42 };
43
SetUpTestCase(void)44 void UtilsRefbaseTest::SetUpTestCase(void)
45 {
46 g_sptrCount = 0;
47 g_wptrCount = 0;
48 g_refbaseflag = 0;
49 }
50
51 class RefBaseTest : public RefBase {
52 public:
RefBaseTest()53 RefBaseTest()
54 {
55 g_refbaseflag = FLAG_OF_CONS;
56 isgetrefptr_ = false;
57 }
~RefBaseTest()58 ~RefBaseTest()
59 {
60 g_refbaseflag = FLAG_OF_DEST;
61 }
62
OnLastStrongRef(const void * objectId)63 void OnLastStrongRef(const void *objectId) override
64 {
65 g_freeFlag = 1;
66 }
67
SetRefPtr()68 void SetRefPtr()
69 {
70 isgetrefptr_ = true;
71 }
GetTestRefPtrFlag()72 bool GetTestRefPtrFlag()
73 {
74 return isgetrefptr_;
75 }
76
77 private:
78 bool isgetrefptr_;
79 };
80
81 class IRemoteObject : public virtual RefBase {
82 public:
IRemoteObject()83 IRemoteObject() { ExtendObjectLifetime(); }
84 virtual bool IsProxyObject() = 0;
~IRemoteObject()85 ~IRemoteObject() {}
86 };
87
88 class RefBaseTestTracker : public RefBase {
89 public:
RefBaseTestTracker(int value)90 explicit RefBaseTestTracker(int value) : value_(value)
91 {
92 checkCount_++;
93 }
94 RefBaseTestTracker() = default;
~RefBaseTestTracker()95 ~RefBaseTestTracker()
96 {
97 checkCount_--;
98 }
99
RefBaseTestTracker(const RefBaseTestTracker & testTracker)100 RefBaseTestTracker(const RefBaseTestTracker &testTracker)
101 {
102 checkCount_++;
103 value_ = testTracker.value_;
104 }
105
operator =(const RefBaseTestTracker & testTracker)106 RefBaseTestTracker &operator=(const RefBaseTestTracker &testTracker)
107 {
108 checkCount_++;
109 value_ = testTracker.value_;
110 return *this;
111 }
112
RefBaseTestTracker(RefBaseTestTracker && testTracker)113 RefBaseTestTracker(RefBaseTestTracker &&testTracker)
114 {
115 checkCount_++;
116 value_ = testTracker.value_;
117 }
118
operator =(RefBaseTestTracker && testTracker)119 RefBaseTestTracker &operator=(RefBaseTestTracker &&testTracker)
120 {
121 checkCount_++;
122 value_ = testTracker.value_;
123 return *this;
124 }
125
GetInstance()126 static RefBaseTestTracker *GetInstance()
127 {
128 static RefBaseTestTracker instance;
129 return &instance;
130 }
131
InitTracker()132 void InitTracker()
133 {
134 checkCount_ = 0;
135 freeCount_ = 0;
136 firstRefCount_ = 0;
137 lastRefCount_ = 0;
138 }
139
TrackObject(IRemoteObject * object)140 void TrackObject(IRemoteObject *object)
141 {
142 std::lock_guard<std::mutex> lockGuard(objectMutex_);
143 trackObjects_.emplace_back(object);
144 }
145
TrackNewObject(IRemoteObject * object)146 void TrackNewObject(IRemoteObject *object)
147 {
148 std::lock_guard<std::mutex> lockGuard(objectOnfirstMutex_);
149 RefBaseTestTracker::firstRefCount_++;
150 }
151
UntrackObject(IRemoteObject * object)152 void UntrackObject(IRemoteObject *object)
153 {
154 std::lock_guard<std::mutex> lockGuard(objectMutex_);
155 auto iter = find(trackObjects_.begin(), trackObjects_.end(), object);
156 if (iter != trackObjects_.end()) {
157 trackObjects_.erase(iter);
158 }
159 }
160
TrackFreeObject(IRemoteObject * object)161 void TrackFreeObject(IRemoteObject *object)
162 {
163 std::lock_guard<std::mutex> lockGuard(objectOnfreeMutex_);
164 RefBaseTestTracker::freeCount_++;
165 }
166
PrintTrackResults()167 void PrintTrackResults()
168 {
169 std::lock_guard<std::mutex> lockGuard(objectMutex_);
170 if (!trackObjects_.empty()) {
171 for (auto o : trackObjects_) {
172 std::cout << "object: " << o <<"strong: " << o->GetSptrRefCount() << ", weak:" << o->GetWptrRefCount() << std::endl;
173 }
174 }
175 std::cout << "firstRefCount_: " << RefBaseTestTracker::firstRefCount_ << std::endl;
176 std::cout << "lastRefCount_: " << RefBaseTestTracker::lastRefCount_ << std::endl;
177 std::cout << "freeCount_: " << RefBaseTestTracker::freeCount_ << std::endl;
178 }
179
180 public:
181 int checkCount_ = 0;
182 int freeCount_ = 0;
183 int firstRefCount_ = 0;
184 int lastRefCount_ = 0;
185
186 private:
187
188 std::vector<IRemoteObject *> trackObjects_;
189 std::mutex objectMutex_;
190 std::mutex objectOnfirstMutex_;
191 std::mutex objectOnfreeMutex_;
192 int value_;
193 };
194
195
196 class IPCObjectProxy : public IRemoteObject
197 {
198 public:
IsProxyObject()199 bool IsProxyObject() override { return 0; }
200 string descriptor_;
IPCObjectProxy(const string & descriptor)201 IPCObjectProxy(const string &descriptor)
202 {
203 descriptor_ = descriptor;
204 RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance();
205 tracker->TrackObject(this);
206 tracker->TrackNewObject(this);
207 };
~IPCObjectProxy()208 ~IPCObjectProxy() {}
209 void RefPtrCallback() override;
210 void OnLastStrongRef(const void *objectId) override;
211 void OnFirstStrongRef(const void *objectId) override;
212 std::mutex mutexLast_;
213 };
214
215 class IPCProcessSkeleton : public virtual RefBase, public Singleton<IPCProcessSkeleton>
216 {
217 friend class Singleton<IPCProcessSkeleton>;
218
219 private:
220 IPCProcessSkeleton() = default;
221
222 public:
223 ~IPCProcessSkeleton() override = default;
224
225 std::mutex mutex_;
226 std::map<string, wptr<IRemoteObject>> objects1_;
227
DumpMapObjects()228 void DumpMapObjects()
229 {
230 if (!objects1_.empty()) {
231 for (auto &o : objects1_) {
232 std::cout << "strong: " << o.second->GetSptrRefCount() << "weak:" << o.second->GetWptrRefCount() << std::endl;
233 }
234 }
235 }
QueryObjectInner(const string & descriptor)236 IRemoteObject *QueryObjectInner(const string &descriptor)
237 {
238 auto it = objects1_.find(descriptor);
239 if (it != objects1_.end())
240 {
241 it->second->AttemptAcquire(this);
242 std::this_thread::sleep_for(std::chrono::milliseconds(1));
243 return it->second.GetRefPtr();
244 }
245
246 return nullptr;
247 }
248
FindOrNewObject(int handle)249 IRemoteObject *FindOrNewObject(int handle)
250 {
251 std::lock_guard<std::mutex> lockGuard(mutex_);
252 IRemoteObject *remoteObject = QueryObjectInner(to_string(handle));
253 if (remoteObject != nullptr)
254 {
255 std::this_thread::sleep_for(std::chrono::milliseconds(1));
256 return remoteObject;
257 }
258
259 remoteObject = new IPCObjectProxy(to_string(handle));
260 remoteObject->AttemptAcquire(this);
261 objects1_.insert(std::pair<string, wptr<IRemoteObject>>(to_string(handle), remoteObject));
262 return remoteObject;
263 }
264
DetachObject(IRemoteObject * object,string descriptor)265 bool DetachObject(IRemoteObject *object, string descriptor)
266 {
267 std::lock_guard<std::mutex> lockGuard(mutex_);
268 if (object->GetSptrRefCount())
269 {
270 return false;
271 }
272 return (objects1_.erase(descriptor) > 0);
273 }
274 };
275
OnLastStrongRef(const void * objectId)276 void IPCObjectProxy::OnLastStrongRef(const void *objectId)
277 {
278 std::lock_guard<std::mutex> lock(mutexLast_);
279 (void)IPCProcessSkeleton::GetInstance().DetachObject(this, descriptor_);
280 RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance();
281 tracker->lastRefCount_++;
282 std::this_thread::sleep_for(std::chrono::nanoseconds(10));
283 }
284
OnFirstStrongRef(const void * objectId)285 void IPCObjectProxy::OnFirstStrongRef(const void *objectId)
286 {
287 std::this_thread::sleep_for(std::chrono::nanoseconds(10));
288 }
289
RefPtrCallback()290 void IPCObjectProxy::RefPtrCallback()
291 {
292 RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance();
293 tracker->UntrackObject(this);
294 tracker->TrackFreeObject(this);
295 RefBase::RefPtrCallback();
296 }
297
298 constexpr int CYCLE_NUM1 = 100;
299 constexpr int CYCLE_NUM2 = 100;
300
RegisterEventThread()301 int RegisterEventThread()
302 {
303 auto &ipc = IPCProcessSkeleton::GetInstance();
304 int handle = 10;
305 for (int i = 0; i < CYCLE_NUM2; i++) {
306 sptr<IRemoteObject> remote = ipc.FindOrNewObject(handle);
307 if (remote) {
308 remote->IsProxyObject();
309 }
310 }
311 return 0;
312 }
313
314 /*
315 * @tc.name: testRefbaseOperateThreads001
316 * @tc.desc: Refbase for threads
317 */
318 HWTEST_F(UtilsRefbaseTest, testRefbaseOperateThreads001, TestSize.Level0)
319 {
320 RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance();
321 tracker->InitTracker();
322 for (int n = 0; n < 1; n++) {
323 std::vector<std::future<int>> threads;
324 for (int i = 0; i < CYCLE_NUM1; i++) {
325 threads.emplace_back(std::async(RegisterEventThread));
326 }
327
328 for (auto &f : threads) {
329 f.get();
330 }
331 }
332 auto &ipc = IPCProcessSkeleton::GetInstance();
333 ipc.DumpMapObjects();
334 EXPECT_EQ(tracker->firstRefCount_, tracker->freeCount_);
335 }
336
337 /*
338 * @tc.name: testRefbaseOperateNull001
339 * @tc.desc: Refbase for null
340 */
341 HWTEST_F(UtilsRefbaseTest, testRefbaseOperateNull001, TestSize.Level0)
342 {
343 RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance();
344 tracker->InitTracker();
345
346 auto remoteObject = new IPCObjectProxy("ss");
347 remoteObject->AttemptAcquire(this);
348
349 remoteObject->IncWeakRef(nullptr);
350 remoteObject->IncStrongRef(nullptr);
351 remoteObject->DecStrongRef(nullptr);
352 remoteObject->AttemptAcquire(this);
353
354 remoteObject->IncStrongRef(nullptr);
355 remoteObject->DecStrongRef(nullptr);
356
357 remoteObject->DecWeakRef(nullptr);
358 EXPECT_EQ(tracker->firstRefCount_, tracker->freeCount_);
359 }
360
361 class RefBaseMemTest : public RefBase {
362 public:
RefBaseMemTest(int value)363 explicit RefBaseMemTest(int value): value_(value)
364 {
365 g_checkCount++;
366 }
367
~RefBaseMemTest()368 ~RefBaseMemTest()
369 {
370 g_checkCount--;
371 }
372
RefBaseMemTest(const RefBaseMemTest & testRefbaseMem)373 RefBaseMemTest(const RefBaseMemTest &testRefbaseMem)
374 {
375 g_checkCount++;
376 value_ = testRefbaseMem.value_;
377 }
378
operator =(const RefBaseMemTest & testRefbaseMem)379 RefBaseMemTest &operator=(const RefBaseMemTest &testRefbaseMem)
380 {
381 g_checkCount++;
382 value_ = testRefbaseMem.value_;
383 return *this;
384 }
385
RefBaseMemTest(RefBaseMemTest && testRefbaseMem)386 RefBaseMemTest(RefBaseMemTest &&testRefbaseMem)
387 {
388 g_checkCount++;
389 value_ = testRefbaseMem.value_;
390 }
391
operator =(RefBaseMemTest && testRefbaseMem)392 RefBaseMemTest &operator=(RefBaseMemTest &&testRefbaseMem)
393 {
394 g_checkCount++;
395 value_ = testRefbaseMem.value_;
396 return *this;
397 }
398
399 public:
400 static inline int g_checkCount = 0;
401
402 private:
403 int value_;
404 };
405
406 /*
407 * @tc.name: testRefbaseOperateLeftValue001
408 * @tc.desc: Refbase
409 */
410 HWTEST_F(UtilsRefbaseTest, testRefbaseOperateLeftValue001, TestSize.Level0)
411 {
412 RefBaseMemTest::g_checkCount = 0;
413 {
414 vector<RefBaseMemTest> refMemTestArray;
415 sptr<RefBaseMemTest>refMemTestObj1 = new RefBaseMemTest(1);
416 sptr<RefBaseMemTest>refMemTestObj2 = new RefBaseMemTest(2);
417 refMemTestArray.push_back(*refMemTestObj1);
418 refMemTestArray.push_back(*refMemTestObj2);
419 }
420 EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
421
422 {
423 vector<RefBaseMemTest> refMemTestArray;
424 RefBaseMemTest refMemTestObj1(1);
425 RefBaseMemTest refMemTestObj2(2);
426 refMemTestArray.push_back(refMemTestObj1);
427 refMemTestArray.push_back(refMemTestObj2);
428 }
429 EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
430 }
431
432 /*
433 * @tc.name: testRefbaseOperateRightValue001
434 * @tc.desc: Refbase
435 */
436 HWTEST_F(UtilsRefbaseTest, testRefbaseOperateRightValue001, TestSize.Level0)
437 {
438 RefBaseMemTest::g_checkCount = 0;
439 {
440 vector<RefBaseMemTest> refMemTestArray;
441 sptr<RefBaseMemTest>refMemTestObj1 = new RefBaseMemTest(1);
442 sptr<RefBaseMemTest>refMemTestObj2 = new RefBaseMemTest(2);
443 refMemTestArray.emplace_back(*refMemTestObj1);
444 refMemTestArray.emplace_back(*refMemTestObj2);
445 }
446 EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
447
448 {
449 vector<RefBaseMemTest> refMemTestArray;
450 RefBaseMemTest refMemTestObj1(1);
451 RefBaseMemTest refMemTestObj2(2);
452 refMemTestArray.emplace_back(refMemTestObj1);
453 refMemTestArray.emplace_back(refMemTestObj2);
454 }
455 EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
456 }
457
458 /*
459 * @tc.name: testRefbaseAcquire001
460 * @tc.desc: Refbase
461 */
462 HWTEST_F(UtilsRefbaseTest, testRefbaseAcquire001, TestSize.Level0)
463 {
464 RefBaseTest* testobject = new RefBaseTest();
465 testobject->AttemptAcquire(this);
466
467 g_freeFlag = 0;
468 EXPECT_EQ(testobject->GetSptrRefCount(), 1);
469 {
470 EXPECT_TRUE(testobject->IsAttemptAcquireSet());
471 sptr<RefBaseTest> sptrRef = testobject;
472 EXPECT_EQ(sptrRef->GetSptrRefCount(), 1);
473 EXPECT_FALSE(testobject->IsAttemptAcquireSet());
474 }
475
476 EXPECT_EQ(g_freeFlag, 1);
477 }
478
479 /*
480 * @tc.name: testSptrefbase001
481 * @tc.desc: Refbase
482 */
483 HWTEST_F(UtilsRefbaseTest, testSptrefbase001, TestSize.Level0)
484 {
485 sptr<RefBaseTest> testobject = new RefBaseTest();
486 testobject->ExtendObjectLifetime();
487 EXPECT_TRUE(testobject->IsExtendLifeTimeSet());
488 EXPECT_EQ(g_refbaseflag, 1);
489 wptr<RefBaseTest> weakObject(testobject);
490 int count = testobject->GetWptrRefCount();
491 EXPECT_EQ(count, 2);
492 testobject = nullptr;
493
494 sptr<RefBaseTest> strongObject = weakObject.promote();
495 EXPECT_EQ(strongObject->GetSptrRefCount(), 1);
496 }
497
498 /*
499 * @tc.name: testSptrefbaseRealease001
500 * @tc.desc: Refbase
501 */
502 HWTEST_F(UtilsRefbaseTest, testSptrefbaseRealease001, TestSize.Level0)
503 {
504 sptr<RefBaseTest> testObject = new RefBaseTest();
505 EXPECT_EQ(g_refbaseflag, 1);
506 wptr<RefBaseTest> weakObject(testObject);
507 testObject = nullptr;
508 EXPECT_EQ(g_refbaseflag, FLAG_OF_DEST);
509 }
510
511 /*
512 * @tc.name: testSptrefbaseRealease002
513 * @tc.desc: Refbase
514 */
515 HWTEST_F(UtilsRefbaseTest, testSptrefbaseRealease002, TestSize.Level0)
516 {
517 wptr<RefBaseTest> testObject = new RefBaseTest();
518 EXPECT_EQ(g_refbaseflag, 1);
519 testObject = nullptr;
520 EXPECT_EQ(g_refbaseflag, FLAG_OF_DEST);
521 }
522
523 /*
524 * @tc.name: testSptrefbase002
525 * @tc.desc: Refbase
526 */
527 HWTEST_F(UtilsRefbaseTest, testSptrefbase002, TestSize.Level0)
528 {
529 {
530 sptr<RefBaseTest> testObject(new RefBaseTest());
531 EXPECT_EQ(g_refbaseflag, 1);
532 }
533 EXPECT_EQ(g_refbaseflag, 2);
534 }
535
536 /*
537 * @tc.name: testSptrefbase003
538 * @tc.desc: Refbase
539 */
540 HWTEST_F(UtilsRefbaseTest, testSptrefbase003, TestSize.Level0)
541 {
542 sptr<RefBaseTest> testObject1(new RefBaseTest());
543 sptr<RefBaseTest> testObject2 = testObject1.GetRefPtr();
544 testObject2->SetRefPtr();
545 EXPECT_TRUE(testObject1->GetTestRefPtrFlag());
546
547 sptr<RefBaseTest> testObject3(testObject1);
548 EXPECT_TRUE(testObject3->GetTestRefPtrFlag());
549
550 sptr<RefBaseTest> testObject4 = testObject1;
551 EXPECT_TRUE(testObject3->GetTestRefPtrFlag());
552
553 bool ret = (testObject3 == testObject4);
554 EXPECT_TRUE(ret);
555
556 int refcount = testObject1->GetSptrRefCount();
557 EXPECT_EQ(refcount, 4);
558
559 sptr<RefBaseTest> testObject5(new RefBaseTest());
560 ret = (testObject5 != testObject1);
561 EXPECT_TRUE(ret);
562 }
563
564 /*
565 * @tc.name: testSptrefbase004
566 * @tc.desc: Refbase
567 */
568 HWTEST_F(UtilsRefbaseTest, testSptrefbase004, TestSize.Level0)
569 {
570 sptr<RefBaseTest> testObject1(new RefBaseTest());
571 testObject1->SetRefPtr();
572 RefBaseTest testObject2 = *testObject1;
573 EXPECT_TRUE(testObject2.GetTestRefPtrFlag());
574
575 auto testObject3 = testObject1;
576 testObject1 = nullptr;
577 testObject3 = nullptr;
578 EXPECT_EQ(g_refbaseflag, 2);
579 }
580
581 /*
582 * @tc.name: testSptrefbase005
583 * @tc.desc: Refbase
584 */
585 HWTEST_F(UtilsRefbaseTest, testSptrefbase005, TestSize.Level0)
586 {
587 sptr<RefBaseTest> testObject1(new RefBaseTest());
588 wptr<RefBaseTest> testObject2 = testObject1;
589 EXPECT_EQ(testObject1->GetSptrRefCount(), 1);
590 EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
591 }
592
593 /*
594 * @tc.name: testSptrefbase006
595 * @tc.desc: Refbase
596 */
597 HWTEST_F(UtilsRefbaseTest, testSptrefbase006, TestSize.Level0)
598 {
599 sptr<RefBaseTest> testObject1;
600 EXPECT_EQ(testObject1.GetRefPtr(), nullptr);
601 testObject1 = new RefBaseTest();
602 sptr<RefBaseTest> testObject2(testObject1);
603 EXPECT_EQ(testObject1->GetSptrRefCount(), 2);
604 }
605
606 /*
607 * @tc.name: testSptrefbase007
608 * @tc.desc: Refbase
609 */
610 HWTEST_F(UtilsRefbaseTest, testSptrefbase007, TestSize.Level0)
611 {
612 const sptr<RefBaseTest> &testObject1 = new RefBaseTest();
613 sptr<RefBaseTest> testObject2(testObject1);
614 EXPECT_EQ(testObject1->GetSptrRefCount(), 2);
615 }
616
617 /*
618 * @tc.name: testSptrefbase008
619 * @tc.desc: Refbase
620 */
621 HWTEST_F(UtilsRefbaseTest, testSptrefbase008, TestSize.Level0)
622 {
623 sptr<RefBaseTest> testObject1;
624 sptr<RefBaseTest> testObject2(testObject1);
625 EXPECT_EQ(testObject2, nullptr);
626 }
627
628 /*
629 * @tc.name: testSptrefbase009
630 * @tc.desc: Refbase
631 */
632 HWTEST_F(UtilsRefbaseTest, testSptrefbase009, TestSize.Level0)
633 {
634 sptr<RefBaseTest> testObject0 = new RefBaseTest();
635 sptr<RefBaseTest> testObject1 = move(testObject0);
636 sptr<RefBaseTest> testObject2(testObject1);
637 EXPECT_EQ(testObject0.GetRefPtr(), nullptr);
638 EXPECT_EQ(testObject2.GetRefPtr(), testObject1.GetRefPtr());
639 }
640
641 /*
642 * @tc.name: testSptrefbase010
643 * @tc.desc: Refbase
644 */
645 HWTEST_F(UtilsRefbaseTest, testSptrefbase010, TestSize.Level0)
646 {
647 sptr<RefBaseTest> testObject1 = new RefBaseTest();
648 sptr<RefBaseTest> testObject3(new RefBaseTest());
649 sptr<RefBaseTest> &testObject2 = testObject3;
650 testObject2 = testObject1;
651 EXPECT_EQ(testObject2.GetRefPtr(), testObject1.GetRefPtr());
652
653 const sptr<RefBaseTest> &testObject4 = new RefBaseTest();
654 EXPECT_EQ(testObject1->GetSptrRefCount(), 2);
655 testObject2 = testObject4;
656 EXPECT_EQ(testObject2.GetRefPtr(), testObject4.GetRefPtr());
657 EXPECT_EQ(testObject4->GetSptrRefCount(), 2);
658 EXPECT_EQ(testObject1->GetSptrRefCount(), 1);
659 }
660
661 class SptrTest : public RefBase {
662 public:
SptrTest()663 SptrTest()
664 {
665 g_sptrCount++;
666 }
~SptrTest()667 ~SptrTest()
668 {
669 g_sptrCount--;
670 }
CreateSptr()671 void CreateSptr()
672 {
673 test1 = new SptrTest();
674 }
675
676 private:
677 sptr<SptrTest> test1;
678 };
679
680 /*
681 * @tc.name: testRefbase005
682 * @tc.desc: Refbase
683 */
684 HWTEST_F(UtilsRefbaseTest, testRefbase005, TestSize.Level0)
685 {
686 {
687 sptr<SptrTest> testObject1(new SptrTest());
688 testObject1->CreateSptr();
689 }
690 EXPECT_EQ(g_sptrCount, 0);
691 }
692
693 class SptrTest1;
694 class SptrTest2;
695 class SptrTest2 : public RefBase {
696 public:
SptrTest2()697 SptrTest2()
698 {
699 g_sptrCount++;
700 }
~SptrTest2()701 ~SptrTest2()
702 {
703 g_sptrCount--;
704 }
705
706 private:
707 sptr<SptrTest1> test;
708 };
709
710 class SptrTest1 : public RefBase {
711 public:
SptrTest1()712 SptrTest1()
713 {
714 g_sptrCount++;
715 }
~SptrTest1()716 ~SptrTest1()
717 {
718 g_sptrCount--;
719 }
720
721 private:
722 sptr<SptrTest2> test;
723 };
724
725 /*
726 * @tc.name: testRefbase006
727 * @tc.desc: Refbase
728 */
729 HWTEST_F(UtilsRefbaseTest, testRefbase006, TestSize.Level0)
730 {
731 {
732 sptr<SptrTest1> testObject1(new SptrTest1());
733 sptr<SptrTest2> testObject2(new SptrTest2());
734 EXPECT_EQ(g_sptrCount, 2);
735 }
736 EXPECT_EQ(g_sptrCount, 0);
737 }
738
739 /*
740 * @tc.name: testRefbase007
741 * @tc.desc: test count of refcounter.
742 */
743 HWTEST_F(UtilsRefbaseTest, testRefbase007, TestSize.Level0)
744 {
745 sptr<RefBase> testObject1(new RefBase());
746 EXPECT_EQ(testObject1->GetRefCounter()->GetRefCount(), 1);
747 wptr<RefBase> testObject2(testObject1);
748 EXPECT_EQ(testObject1->GetRefCounter()->GetRefCount(), 2); // 2: Refbase and WeakRefCounter
749 }
750
751 /*
752 * @tc.name: testRefbase008
753 * @tc.desc: test move constructor.
754 */
755 HWTEST_F(UtilsRefbaseTest, testRefbase008, TestSize.Level0)
756 {
757 RefBase baseObject1{};
758 EXPECT_EQ(baseObject1.GetRefCounter()->GetRefCount(), 1);
759
760 RefBase baseObject2{};
761 EXPECT_EQ(baseObject2.GetRefCounter()->GetRefCount(), 1);
762 baseObject2 = std::move(baseObject1);
763 EXPECT_EQ(baseObject2.GetRefCounter()->GetRefCount(), 1);
764 EXPECT_EQ(baseObject1.GetRefCounter(), nullptr);
765 EXPECT_EQ(baseObject1.GetSptrRefCount(), 0);
766 EXPECT_EQ(baseObject1.GetWptrRefCount(), 0);
767
768 RefBase baseObject3{};
769 EXPECT_EQ(baseObject3.GetRefCounter()->GetRefCount(), 1);
770 baseObject3 = std::move(baseObject2);
771 EXPECT_EQ(baseObject3.GetRefCounter()->GetRefCount(), 1);
772 EXPECT_EQ(baseObject2.GetRefCounter(), nullptr);
773 EXPECT_EQ(baseObject2.GetSptrRefCount(), 0);
774 EXPECT_EQ(baseObject2.GetWptrRefCount(), 0);
775
776 baseObject2 = std::move(baseObject1);
777 EXPECT_EQ(baseObject1.GetRefCounter(), baseObject2.GetRefCounter());
778 }
779
780 class WptrTest : public RefBase {
781 public:
WptrTest()782 WptrTest()
783 {
784 g_sptrCount++;
785 }
~WptrTest()786 ~WptrTest()
787 {
788 g_sptrCount--;
789 }
790 };
791
792 class WptrTest2 : public RefBase {
793 public:
WptrTest2()794 WptrTest2()
795 {
796 g_sptrCount++;
797 flag_ = 0;
798 }
~WptrTest2()799 ~WptrTest2()
800 {
801 g_sptrCount--;
802 }
803
804 private:
805 int flag_;
806 };
807
808 /*
809 * @tc.name: testWptrefbase001
810 * @tc.desc: Copy constructor with same managed class type.
811 */
812 HWTEST_F(UtilsRefbaseTest, testWptrefbase001, TestSize.Level0)
813 {
814 // test wptr<T>::wptr(const wptr<T>&)
815 wptr<WptrTest> testOrigWptrObject(new WptrTest());
816 EXPECT_EQ(testOrigWptrObject->GetWptrRefCount(), 1);
817
818 wptr<WptrTest> testTargetWptrObject1(testOrigWptrObject);
819
820 EXPECT_EQ(testOrigWptrObject.GetRefPtr(), testTargetWptrObject1.GetRefPtr());
821 EXPECT_EQ(&(*testOrigWptrObject), &(*testTargetWptrObject1));
822 EXPECT_EQ(testTargetWptrObject1->GetWptrRefCount(), testOrigWptrObject->GetWptrRefCount());
823 EXPECT_EQ(testTargetWptrObject1.GetWeakRefCount(), testOrigWptrObject.GetWeakRefCount());
824
825 EXPECT_EQ(testTargetWptrObject1->GetWptrRefCount(), 1);
826 EXPECT_EQ(testTargetWptrObject1.GetWeakRefCount(), 2);
827
828 // test wptr<T>::operator=(const wptr<T>&)
829 wptr<WptrTest> testTargetWptrObject2(new WptrTest());
830 EXPECT_EQ(testTargetWptrObject2->GetWptrRefCount(), 1);
831
832 testTargetWptrObject2 = testOrigWptrObject;
833
834 EXPECT_EQ(testOrigWptrObject.GetRefPtr(), testTargetWptrObject2.GetRefPtr());
835 EXPECT_EQ(&(*testOrigWptrObject), &(*testTargetWptrObject2));
836 EXPECT_EQ(testTargetWptrObject2->GetWptrRefCount(), testOrigWptrObject->GetWptrRefCount());
837 EXPECT_EQ(testTargetWptrObject2.GetWeakRefCount(), testOrigWptrObject.GetWeakRefCount());
838
839 EXPECT_EQ(testTargetWptrObject2->GetWptrRefCount(), 1);
840 EXPECT_EQ(testTargetWptrObject2.GetWeakRefCount(), 3);
841
842 // test wptr<T>::wptr(const sptr<T>&)
843 sptr<WptrTest> testOrigSptrObject(new WptrTest());
844 EXPECT_EQ(testOrigSptrObject->GetSptrRefCount(), 1);
845
846 wptr<WptrTest> testTargetWptrObject3(testOrigSptrObject);
847
848 EXPECT_EQ(testOrigSptrObject.GetRefPtr(), testTargetWptrObject3.GetRefPtr());
849 EXPECT_EQ(&(*testOrigSptrObject), &(*testTargetWptrObject3));
850 EXPECT_EQ(testTargetWptrObject3->GetSptrRefCount(), testOrigSptrObject->GetSptrRefCount());
851 EXPECT_EQ(testTargetWptrObject3->GetWptrRefCount(), testOrigSptrObject->GetWptrRefCount());
852
853 EXPECT_EQ(testTargetWptrObject3->GetSptrRefCount(), 1);
854 EXPECT_EQ(testTargetWptrObject3->GetWptrRefCount(), 2);
855 EXPECT_EQ(testTargetWptrObject3.GetWeakRefCount(), 1);
856
857 // test wptr<T>::operator=(const sptr<T>&)
858 wptr<WptrTest> testTargetWptrObject4(new WptrTest());
859 EXPECT_EQ(testTargetWptrObject4->GetWptrRefCount(), 1);
860
861 testTargetWptrObject4 = testOrigSptrObject;
862
863 EXPECT_EQ(testOrigSptrObject.GetRefPtr(), testTargetWptrObject4.GetRefPtr());
864 EXPECT_EQ(&(*testOrigSptrObject), &(*testTargetWptrObject4));
865 EXPECT_EQ(testTargetWptrObject4->GetSptrRefCount(), testOrigSptrObject->GetSptrRefCount());
866 EXPECT_EQ(testTargetWptrObject4->GetWptrRefCount(), testOrigSptrObject->GetWptrRefCount());
867
868 EXPECT_EQ(testTargetWptrObject4->GetSptrRefCount(), 1);
869 EXPECT_EQ(testTargetWptrObject4->GetWptrRefCount(), 3);
870 EXPECT_EQ(testTargetWptrObject4.GetWeakRefCount(), 1);
871 }
872
873 /*
874 * @tc.name: testWptrefbase002
875 * @tc.desc: Copy constructor with different managed class type.
876 */
877 HWTEST_F(UtilsRefbaseTest, testWptrefbase002, TestSize.Level0)
878 {
879 // test wptr<T>::wptr(const wptr<O>&)
880 wptr<WptrTest2> testOrigWptrObject(new WptrTest2());
881 EXPECT_EQ(testOrigWptrObject->GetWptrRefCount(), 1);
882
883 wptr<WptrTest> testTargetWptrObject1(testOrigWptrObject);
884
885 EXPECT_EQ(static_cast<void *>(testOrigWptrObject.GetRefPtr()),
886 static_cast<void *>(testTargetWptrObject1.GetRefPtr()));
887 EXPECT_EQ(static_cast<void *>(&(*testOrigWptrObject)),
888 static_cast<void *>(&(*testTargetWptrObject1)));
889 EXPECT_EQ(testTargetWptrObject1->GetWptrRefCount(), testOrigWptrObject->GetWptrRefCount());
890 EXPECT_EQ(testTargetWptrObject1.GetWeakRefCount(), testOrigWptrObject.GetWeakRefCount());
891
892 EXPECT_EQ(testTargetWptrObject1->GetWptrRefCount(), 1);
893 EXPECT_EQ(testTargetWptrObject1.GetWeakRefCount(), 2);
894
895 // test wptr<T>::operator=(const wptr<O>&)
896 wptr<WptrTest> testTargetWptrObject2(new WptrTest());
897 EXPECT_EQ(testTargetWptrObject2->GetWptrRefCount(), 1);
898
899 testTargetWptrObject2 = testOrigWptrObject;
900
901 EXPECT_EQ(static_cast<void *>(testOrigWptrObject.GetRefPtr()),
902 static_cast<void *>(testTargetWptrObject2.GetRefPtr()));
903 EXPECT_EQ(static_cast<void *>(&(*testOrigWptrObject)),
904 static_cast<void *>(&(*testTargetWptrObject2)));
905 EXPECT_EQ(testTargetWptrObject2->GetWptrRefCount(), testOrigWptrObject->GetWptrRefCount());
906 EXPECT_EQ(testTargetWptrObject2.GetWeakRefCount(), testOrigWptrObject.GetWeakRefCount());
907
908 EXPECT_EQ(testTargetWptrObject2->GetWptrRefCount(), 1);
909 EXPECT_EQ(testTargetWptrObject2.GetWeakRefCount(), 3);
910
911 // test wptr<T>::wptr(const sptr<O>&)
912 sptr<WptrTest2> testOrigSptrObject(new WptrTest2());
913 EXPECT_EQ(testOrigSptrObject->GetSptrRefCount(), 1);
914
915 wptr<WptrTest> testTargetWptrObject3(testOrigSptrObject);
916
917 EXPECT_EQ(static_cast<void *>(testOrigSptrObject.GetRefPtr()),
918 static_cast<void *>(testTargetWptrObject3.GetRefPtr()));
919 EXPECT_EQ(static_cast<void *>(&(*testOrigSptrObject)), static_cast<void *>(&(*testTargetWptrObject3)));
920 EXPECT_EQ(testTargetWptrObject3->GetSptrRefCount(), testOrigSptrObject->GetSptrRefCount());
921 EXPECT_EQ(testTargetWptrObject3->GetWptrRefCount(), testOrigSptrObject->GetWptrRefCount());
922
923 EXPECT_EQ(testTargetWptrObject3->GetSptrRefCount(), 1);
924 EXPECT_EQ(testTargetWptrObject3->GetWptrRefCount(), 2);
925 EXPECT_EQ(testTargetWptrObject3.GetWeakRefCount(), 1);
926
927 // test wptr<T>::operator=(const sptr<O>&)
928 wptr<WptrTest> testTargetWptrObject4(new WptrTest());
929 EXPECT_EQ(testTargetWptrObject4->GetWptrRefCount(), 1);
930
931 testTargetWptrObject4 = testOrigSptrObject;
932
933 EXPECT_EQ(static_cast<void *>(testOrigSptrObject.GetRefPtr()),
934 static_cast<void *>(testTargetWptrObject4.GetRefPtr()));
935 EXPECT_EQ(static_cast<void *>(&(*testOrigSptrObject)), static_cast<void *>(&(*testTargetWptrObject4)));
936 EXPECT_EQ(testTargetWptrObject4->GetSptrRefCount(), testOrigSptrObject->GetSptrRefCount());
937 EXPECT_EQ(testTargetWptrObject4->GetWptrRefCount(), testOrigSptrObject->GetWptrRefCount());
938
939 EXPECT_EQ(testTargetWptrObject4->GetSptrRefCount(), 1);
940 EXPECT_EQ(testTargetWptrObject4->GetWptrRefCount(), 3);
941 EXPECT_EQ(testTargetWptrObject4.GetWeakRefCount(), 1);
942 }
943
944 /*
945 * @tc.name: testWptrefbase003
946 * @tc.desc: Refbase
947 */
948 HWTEST_F(UtilsRefbaseTest, testWptrefbase003, TestSize.Level0)
949 {
950 const wptr<WptrTest> &testObject1(new WptrTest());
951 wptr<WptrTest> testObject2(testObject1);
952 EXPECT_EQ(testObject1.GetRefPtr(), testObject2.GetRefPtr());
953 EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
954 EXPECT_EQ(testObject2->GetWptrRefCount(), 1);
955 EXPECT_EQ(testObject1.GetRefPtr(), testObject2.GetRefPtr());
956 }
957
958 /*
959 * @tc.name: testWptrefbase004
960 * @tc.desc: Refbase
961 */
962 HWTEST_F(UtilsRefbaseTest, testWptrefbase004, TestSize.Level0)
963 {
964 const sptr<WptrTest2> &testObject1(new WptrTest2());
965 EXPECT_NE(testObject1, nullptr);
966 wptr<WptrTest> testObject2 = testObject1;
967 EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
968 }
969
970 /*
971 * @tc.name: testWptrefbase005
972 * @tc.desc: wptr without managed object
973 */
974 HWTEST_F(UtilsRefbaseTest, testWptrefbase005, TestSize.Level0)
975 {
976 wptr<WptrTest> testObject3;
977 EXPECT_EQ(testObject3.GetRefPtr(), nullptr);
978 }
979
980 /*
981 * @tc.name: testWptrefbase006
982 * @tc.desc: Refbase
983 */
984 HWTEST_F(UtilsRefbaseTest, testWptrefbase006, TestSize.Level0)
985 {
986 wptr<WptrTest> testObject1 = new WptrTest();
987 wptr<WptrTest> &testObject2 = testObject1;
988 EXPECT_EQ(testObject2->GetWptrRefCount(), 1);
989 }
990
991 /*
992 * @tc.name: testWptrefbase007
993 * @tc.desc: Refbase
994 */
995 HWTEST_F(UtilsRefbaseTest, testWptrefbase007, TestSize.Level0)
996 {
997 wptr<WptrTest2> testObject1 = new WptrTest2();
998 wptr<WptrTest2> testObject2 = testObject1.GetRefPtr();
999 EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
1000 }
1001
1002 /*
1003 * @tc.name: testWptrefbase008
1004 * @tc.desc: Refbase
1005 */
1006 HWTEST_F(UtilsRefbaseTest, testWptrefbase008, TestSize.Level0)
1007 {
1008 wptr<WptrTest> testObject1 = new WptrTest();
1009 wptr<WptrTest2> testObject2;
1010 testObject2 = testObject1.GetRefPtr();
1011 EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
1012 }
1013
1014 /*
1015 * @tc.name: testSptrWptrefbase001
1016 * @tc.desc: test interaction between sptr and wptr.
1017 */
1018 HWTEST_F(UtilsRefbaseTest, testSptrWptrefbase001, TestSize.Level0)
1019 {
1020 wptr<RefBase> testObject1(new RefBase());
1021 EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
1022 {
1023 sptr<RefBase> testObject2{};
1024 testObject2 = testObject1;
1025 EXPECT_EQ(testObject2->GetSptrRefCount(), 1);
1026 EXPECT_EQ(testObject2->GetWptrRefCount(), 2); // 2: sptr and WeakRefCounter
1027
1028 sptr<RefBase> testObject3 = testObject1.promote();
1029 EXPECT_EQ(testObject2->GetSptrRefCount(), 2); // 2: 2 sptrs
1030 EXPECT_EQ(testObject2->GetWptrRefCount(), 3); // 3: 2 sptrs and WeakRefCounter
1031 testObject2->ExtendObjectLifetime();
1032 }
1033 EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
1034 }
1035
1036 /*
1037 * @tc.name: testRefbaseDebug001
1038 * @tc.desc: Test for single thread. Tracker can be enabled after construction
1039 * of sptr.
1040 */
1041 HWTEST_F(UtilsRefbaseTest, testRefbaseDebug001, TestSize.Level1)
1042 {
1043 sptr<RefBase> testObject1(new RefBase());
1044 testObject1->EnableTracker();
1045 sptr<RefBase> testObject2(testObject1);
1046 EXPECT_EQ(testObject2->GetSptrRefCount(), 2);
1047 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1048 wptr<RefBase> testObject3(testObject2);
1049 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1050 wptr<RefBase> testObject4(testObject3);
1051 EXPECT_EQ(testObject4->GetWptrRefCount(), 3);
1052 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1053 }
1054
1055 /*
1056 * @tc.name: testRefbaseDebug002
1057 * @tc.desc: Test for single thread. Tracker can be enabled after construction
1058 * of wptr.
1059 */
1060 HWTEST_F(UtilsRefbaseTest, testRefbaseDebug002, TestSize.Level1)
1061 {
1062 wptr<RefBase> testObject1(new RefBase());
1063 testObject1->EnableTracker();
1064 sptr<RefBase> testObject2 = testObject1.promote();
1065 EXPECT_EQ(testObject2->GetSptrRefCount(), 1);
1066 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1067 wptr<RefBase> testObject3(testObject2);
1068 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1069 wptr<RefBase> testObject4(testObject3);
1070 EXPECT_EQ(testObject4->GetWptrRefCount(), 3);
1071 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1072 }
1073
1074 // This is a class which can be tracked when implemented.
1075 class TestDebug : public RefBase {
1076 public:
TestDebug()1077 TestDebug()
1078 {
1079 EnableTracker();
1080 }
1081 };
1082
1083 /*
1084 * @tc.name: testRefbaseDebug003
1085 * @tc.desc: Test for single thread. Tracker can be enabled with construction
1086 * of sptr.
1087 */
1088 HWTEST_F(UtilsRefbaseTest, testRefbaseDebug003, TestSize.Level1)
1089 {
1090 sptr<TestDebug> testObject1(new TestDebug());
1091 sptr<TestDebug> testObject2(testObject1);
1092 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1093 sptr<TestDebug> testObject3;
1094 EXPECT_EQ(testObject2->GetSptrRefCount(), 2);
1095 testObject3 = testObject2;
1096 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1097 wptr<TestDebug> testObject4(testObject3);
1098 EXPECT_EQ(testObject4->GetWptrRefCount(), 4);
1099 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1100 }
1101
1102 /*
1103 * @tc.name: testRefbaseDebug004
1104 * @tc.desc: Test for mult-thread.
1105 */
1106 HWTEST_F(UtilsRefbaseTest, testRefbaseDebug004, TestSize.Level1)
1107 {
1108 sptr<TestDebug> testObject1(new TestDebug());
__anonf747886f0202() 1109 std::thread subThread {[&testObject1]() {
1110 sptr<TestDebug> subTestObject1(testObject1);
1111 EXPECT_EQ(testObject1->GetSptrRefCount(), 2);
1112 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1113 wptr<TestDebug> subTestObject2(subTestObject1);
1114 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1115 wptr<TestDebug> subTestObject3(subTestObject2);
1116 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1117 }};
1118 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1119 wptr<TestDebug> testObject2(testObject1);
1120 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1121 wptr<TestDebug> testObject3(testObject2);
1122 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1123 subThread.join();
1124 EXPECT_EQ(testObject3->GetWptrRefCount(), 2);
1125 }
1126 } // namespace
1127 } // namespace OHOS
1128