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         remote->CheckIsAttemptAcquireSet(remote);
308         if (remote) {
309             remote->IsProxyObject();
310         }
311     }
312     return 0;
313 }
314 
315 /*
316  * @tc.name: testRefbaseOperateThreads001
317  * @tc.desc: Refbase for threads
318  */
319 HWTEST_F(UtilsRefbaseTest, testRefbaseOperateThreads001, TestSize.Level0)
320 {
321     RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance();
322     tracker->InitTracker();
323     for (int n = 0; n < 1; n++) {
324         std::vector<std::future<int>> threads;
325         for (int i = 0; i < CYCLE_NUM1; i++) {
326             threads.emplace_back(std::async(RegisterEventThread));
327         }
328 
329         for (auto &f : threads) {
330             f.get();
331         }
332     }
333     auto &ipc = IPCProcessSkeleton::GetInstance();
334     ipc.DumpMapObjects();
335     EXPECT_EQ(tracker->firstRefCount_, tracker->freeCount_);
336 }
337 
338 /*
339  * @tc.name: testRefbaseOperateNull001
340  * @tc.desc: Refbase for null
341  */
342 HWTEST_F(UtilsRefbaseTest, testRefbaseOperateNull001, TestSize.Level0)
343 {
344     RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance();
345     tracker->InitTracker();
346 
347     auto remoteObject = new IPCObjectProxy("ss");
348     remoteObject->AttemptAcquire(this);
349 
350     remoteObject->IncWeakRef(nullptr);
351     remoteObject->IncStrongRef(nullptr);
352     remoteObject->CheckIsAttemptAcquireSet(nullptr);
353     remoteObject->DecStrongRef(nullptr);
354     remoteObject->AttemptAcquire(this);
355 
356     remoteObject->IncStrongRef(nullptr);
357     remoteObject->CheckIsAttemptAcquireSet(nullptr);
358     remoteObject->DecStrongRef(nullptr);
359 
360     remoteObject->DecWeakRef(nullptr);
361     EXPECT_EQ(tracker->firstRefCount_, tracker->freeCount_);
362 }
363 
364 class RefBaseMemTest : public RefBase {
365 public:
RefBaseMemTest(int value)366     explicit RefBaseMemTest(int value): value_(value)
367     {
368         g_checkCount++;
369     }
370 
~RefBaseMemTest()371     ~RefBaseMemTest()
372     {
373         g_checkCount--;
374     }
375 
RefBaseMemTest(const RefBaseMemTest & testRefbaseMem)376     RefBaseMemTest(const RefBaseMemTest &testRefbaseMem)
377     {
378         g_checkCount++;
379         value_ = testRefbaseMem.value_;
380     }
381 
operator =(const RefBaseMemTest & testRefbaseMem)382     RefBaseMemTest &operator=(const RefBaseMemTest &testRefbaseMem)
383     {
384         g_checkCount++;
385         value_ = testRefbaseMem.value_;
386         return *this;
387     }
388 
RefBaseMemTest(RefBaseMemTest && testRefbaseMem)389     RefBaseMemTest(RefBaseMemTest &&testRefbaseMem)
390     {
391         g_checkCount++;
392         value_ = testRefbaseMem.value_;
393     }
394 
operator =(RefBaseMemTest && testRefbaseMem)395     RefBaseMemTest &operator=(RefBaseMemTest &&testRefbaseMem)
396     {
397         g_checkCount++;
398         value_ = testRefbaseMem.value_;
399         return *this;
400     }
401 
402 public:
403     static inline int g_checkCount = 0;
404 
405 private:
406     int value_;
407 };
408 
409 /*
410  * @tc.name: testRefbaseOperateLeftValue001
411  * @tc.desc: Refbase
412  */
413 HWTEST_F(UtilsRefbaseTest, testRefbaseOperateLeftValue001, TestSize.Level0)
414 {
415     RefBaseMemTest::g_checkCount = 0;
416     {
417         vector<RefBaseMemTest> refMemTestArray;
418         sptr<RefBaseMemTest>refMemTestObj1 = new RefBaseMemTest(1);
419         sptr<RefBaseMemTest>refMemTestObj2 = new RefBaseMemTest(2);
420         refMemTestArray.push_back(*refMemTestObj1);
421         refMemTestArray.push_back(*refMemTestObj2);
422     }
423     EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
424 
425     {
426         vector<RefBaseMemTest> refMemTestArray;
427         RefBaseMemTest refMemTestObj1(1);
428         RefBaseMemTest refMemTestObj2(2);
429         refMemTestArray.push_back(refMemTestObj1);
430         refMemTestArray.push_back(refMemTestObj2);
431     }
432     EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
433 }
434 
435 /*
436  * @tc.name: testRefbaseOperateRightValue001
437  * @tc.desc: Refbase
438  */
439 HWTEST_F(UtilsRefbaseTest, testRefbaseOperateRightValue001, TestSize.Level0)
440 {
441     RefBaseMemTest::g_checkCount = 0;
442     {
443         vector<RefBaseMemTest> refMemTestArray;
444         sptr<RefBaseMemTest>refMemTestObj1 = new RefBaseMemTest(1);
445         sptr<RefBaseMemTest>refMemTestObj2 = new RefBaseMemTest(2);
446         refMemTestArray.emplace_back(*refMemTestObj1);
447         refMemTestArray.emplace_back(*refMemTestObj2);
448     }
449     EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
450 
451     {
452         vector<RefBaseMemTest> refMemTestArray;
453         RefBaseMemTest refMemTestObj1(1);
454         RefBaseMemTest refMemTestObj2(2);
455         refMemTestArray.emplace_back(refMemTestObj1);
456         refMemTestArray.emplace_back(refMemTestObj2);
457     }
458     EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
459 }
460 
461 /*
462  * @tc.name: testRefbaseAcquire001
463  * @tc.desc: Refbase
464  */
465 HWTEST_F(UtilsRefbaseTest, testRefbaseAcquire001, TestSize.Level0)
466 {
467     RefBaseTest* testobject = new RefBaseTest();
468     testobject->AttemptAcquire(this);
469 
470     g_freeFlag = 0;
471     EXPECT_EQ(testobject->GetSptrRefCount(), 1);
472     {
473         EXPECT_TRUE(testobject->IsAttemptAcquireSet());
474         testobject->CheckIsAttemptAcquireSet(this);
475         sptr<RefBaseTest> sptrRef = testobject;
476         EXPECT_EQ(sptrRef->GetSptrRefCount(), 1);
477         EXPECT_FALSE(testobject->IsAttemptAcquireSet());
478     }
479 
480     EXPECT_EQ(g_freeFlag, 1);
481 }
482 
483 /*
484  * @tc.name: testSptrefbase001
485  * @tc.desc: Refbase
486  */
487 HWTEST_F(UtilsRefbaseTest, testSptrefbase001, TestSize.Level0)
488 {
489     sptr<RefBaseTest> testobject = new RefBaseTest();
490     testobject->ExtendObjectLifetime();
491     EXPECT_TRUE(testobject->IsExtendLifeTimeSet());
492     EXPECT_EQ(g_refbaseflag, 1);
493     wptr<RefBaseTest> weakObject(testobject);
494     int count = testobject->GetWptrRefCount();
495     EXPECT_EQ(count, 2);
496     testobject = nullptr;
497 
498     sptr<RefBaseTest> strongObject = weakObject.promote();
499     EXPECT_EQ(strongObject->GetSptrRefCount(), 1);
500 }
501 
502 /*
503  * @tc.name: testSptrefbaseRealease001
504  * @tc.desc: Refbase
505  */
506 HWTEST_F(UtilsRefbaseTest, testSptrefbaseRealease001, TestSize.Level0)
507 {
508     sptr<RefBaseTest> testObject = new RefBaseTest();
509     EXPECT_EQ(g_refbaseflag, 1);
510     wptr<RefBaseTest> weakObject(testObject);
511     testObject = nullptr;
512     EXPECT_EQ(g_refbaseflag, FLAG_OF_DEST);
513 }
514 
515 /*
516  * @tc.name: testSptrefbaseRealease002
517  * @tc.desc: Refbase
518  */
519 HWTEST_F(UtilsRefbaseTest, testSptrefbaseRealease002, TestSize.Level0)
520 {
521     wptr<RefBaseTest> testObject = new RefBaseTest();
522     EXPECT_EQ(g_refbaseflag, 1);
523     testObject = nullptr;
524     EXPECT_EQ(g_refbaseflag, FLAG_OF_DEST);
525 }
526 
527 /*
528  * @tc.name: testSptrefbase002
529  * @tc.desc: Refbase
530  */
531 HWTEST_F(UtilsRefbaseTest, testSptrefbase002, TestSize.Level0)
532 {
533     {
534         sptr<RefBaseTest> testObject(new RefBaseTest());
535         EXPECT_EQ(g_refbaseflag, 1);
536     }
537     EXPECT_EQ(g_refbaseflag, 2);
538 }
539 
540 /*
541  * @tc.name: testSptrefbase003
542  * @tc.desc: Refbase
543  */
544 HWTEST_F(UtilsRefbaseTest, testSptrefbase003, TestSize.Level0)
545 {
546     sptr<RefBaseTest> testObject1(new RefBaseTest());
547     sptr<RefBaseTest> testObject2 = testObject1.GetRefPtr();
548     testObject2->SetRefPtr();
549     EXPECT_TRUE(testObject1->GetTestRefPtrFlag());
550 
551     sptr<RefBaseTest> testObject3(testObject1);
552     EXPECT_TRUE(testObject3->GetTestRefPtrFlag());
553 
554     sptr<RefBaseTest> testObject4 = testObject1;
555     EXPECT_TRUE(testObject3->GetTestRefPtrFlag());
556 
557     bool ret = (testObject3 == testObject4);
558     EXPECT_TRUE(ret);
559 
560     int refcount = testObject1->GetSptrRefCount();
561     EXPECT_EQ(refcount, 4);
562 
563     sptr<RefBaseTest> testObject5(new RefBaseTest());
564     ret = (testObject5 != testObject1);
565     EXPECT_TRUE(ret);
566 }
567 
568 /*
569  * @tc.name: testSptrefbase004
570  * @tc.desc: Refbase
571  */
572 HWTEST_F(UtilsRefbaseTest, testSptrefbase004, TestSize.Level0)
573 {
574     sptr<RefBaseTest> testObject1(new RefBaseTest());
575     testObject1->SetRefPtr();
576     RefBaseTest testObject2 = *testObject1;
577     EXPECT_TRUE(testObject2.GetTestRefPtrFlag());
578 
579     auto testObject3 = testObject1;
580     testObject1 = nullptr;
581     testObject3 = nullptr;
582     EXPECT_EQ(g_refbaseflag, 2);
583 }
584 
585 /*
586  * @tc.name: testSptrefbase005
587  * @tc.desc: Refbase
588  */
589 HWTEST_F(UtilsRefbaseTest, testSptrefbase005, TestSize.Level0)
590 {
591     sptr<RefBaseTest> testObject1(new RefBaseTest());
592     wptr<RefBaseTest> testObject2 = testObject1;
593     EXPECT_EQ(testObject1->GetSptrRefCount(), 1);
594     EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
595 }
596 
597 /*
598  * @tc.name: testSptrefbase006
599  * @tc.desc: Refbase
600  */
601 HWTEST_F(UtilsRefbaseTest, testSptrefbase006, TestSize.Level0)
602 {
603     sptr<RefBaseTest> testObject1;
604     EXPECT_EQ(testObject1.GetRefPtr(), nullptr);
605     testObject1 = new RefBaseTest();
606     sptr<RefBaseTest> testObject2(testObject1);
607     EXPECT_EQ(testObject1->GetSptrRefCount(), 2);
608 }
609 
610 /*
611  * @tc.name: testSptrefbase007
612  * @tc.desc: Refbase
613  */
614 HWTEST_F(UtilsRefbaseTest, testSptrefbase007, TestSize.Level0)
615 {
616     const sptr<RefBaseTest> &testObject1 = new RefBaseTest();
617     sptr<RefBaseTest> testObject2(testObject1);
618     EXPECT_EQ(testObject1->GetSptrRefCount(), 2);
619 }
620 
621 /*
622  * @tc.name: testSptrefbase008
623  * @tc.desc: Refbase
624  */
625 HWTEST_F(UtilsRefbaseTest, testSptrefbase008, TestSize.Level0)
626 {
627     sptr<RefBaseTest> testObject1;
628     sptr<RefBaseTest> testObject2(testObject1);
629     EXPECT_EQ(testObject2, nullptr);
630 }
631 
632 /*
633  * @tc.name: testSptrefbase009
634  * @tc.desc: Refbase
635  */
636 HWTEST_F(UtilsRefbaseTest, testSptrefbase009, TestSize.Level0)
637 {
638     sptr<RefBaseTest> testObject0 = new RefBaseTest();
639     sptr<RefBaseTest> testObject1 = move(testObject0);
640     sptr<RefBaseTest> testObject2(testObject1);
641     EXPECT_EQ(testObject0.GetRefPtr(), nullptr);
642     EXPECT_EQ(testObject2.GetRefPtr(), testObject1.GetRefPtr());
643 }
644 
645 /*
646  * @tc.name: testSptrefbase010
647  * @tc.desc: Refbase
648  */
649 HWTEST_F(UtilsRefbaseTest, testSptrefbase010, TestSize.Level0)
650 {
651     sptr<RefBaseTest> testObject1 = new RefBaseTest();
652     sptr<RefBaseTest> testObject3(new RefBaseTest());
653     sptr<RefBaseTest> &testObject2 = testObject3;
654     testObject2 = testObject1;
655     EXPECT_EQ(testObject2.GetRefPtr(), testObject1.GetRefPtr());
656 
657     const sptr<RefBaseTest> &testObject4 = new RefBaseTest();
658     EXPECT_EQ(testObject1->GetSptrRefCount(), 2);
659     testObject2 = testObject4;
660     EXPECT_EQ(testObject2.GetRefPtr(), testObject4.GetRefPtr());
661     EXPECT_EQ(testObject4->GetSptrRefCount(), 2);
662     EXPECT_EQ(testObject1->GetSptrRefCount(), 1);
663 }
664 
665 /*
666  * @tc.name: testSptrefbase011
667  * @tc.desc: Refbase
668  */
669 HWTEST_F(UtilsRefbaseTest, testSptrefbase011, TestSize.Level0)
670 {
671     sptr<RefBaseTest> testobject = sptr<RefBaseTest>::MakeSptr();
672     testobject->ExtendObjectLifetime();
673     EXPECT_TRUE(testobject->IsExtendLifeTimeSet());
674     EXPECT_EQ(g_refbaseflag, 1);
675     wptr<RefBaseTest> weakObject(testobject);
676     int count = testobject->GetWptrRefCount();
677     EXPECT_EQ(count, 2);
678     testobject = nullptr;
679 
680     sptr<RefBaseTest> strongObject = weakObject.promote();
681     EXPECT_EQ(strongObject->GetSptrRefCount(), 1);
682 }
683 
684 class SptrTest : public RefBase {
685 public:
SptrTest()686     SptrTest()
687     {
688         g_sptrCount++;
689     }
~SptrTest()690     ~SptrTest()
691     {
692         g_sptrCount--;
693     }
CreateSptr()694     void CreateSptr()
695     {
696         test1 = new SptrTest();
697     }
698 
699 private:
700     sptr<SptrTest> test1;
701 };
702 
703 /*
704  * @tc.name: testRefbase005
705  * @tc.desc: Refbase
706  */
707 HWTEST_F(UtilsRefbaseTest, testRefbase005, TestSize.Level0)
708 {
709     {
710         sptr<SptrTest> testObject1(new SptrTest());
711         testObject1->CreateSptr();
712     }
713     EXPECT_EQ(g_sptrCount, 0);
714 }
715 
716 class SptrTest1;
717 class SptrTest2;
718 class SptrTest2 : public RefBase {
719 public:
SptrTest2()720     SptrTest2()
721     {
722         g_sptrCount++;
723     }
~SptrTest2()724     ~SptrTest2()
725     {
726         g_sptrCount--;
727     }
728 
729 private:
730     sptr<SptrTest1> test;
731 };
732 
733 class SptrTest1 : public RefBase {
734 public:
SptrTest1()735     SptrTest1()
736     {
737         g_sptrCount++;
738     }
~SptrTest1()739     ~SptrTest1()
740     {
741         g_sptrCount--;
742     }
743 
744 private:
745     sptr<SptrTest2> test;
746 };
747 
748 /*
749  * @tc.name: testRefbase006
750  * @tc.desc: Refbase
751  */
752 HWTEST_F(UtilsRefbaseTest, testRefbase006, TestSize.Level0)
753 {
754     {
755         sptr<SptrTest1> testObject1(new SptrTest1());
756         sptr<SptrTest2> testObject2(new SptrTest2());
757         EXPECT_EQ(g_sptrCount, 2);
758     }
759     EXPECT_EQ(g_sptrCount, 0);
760 }
761 
762 /*
763  * @tc.name: testRefbase007
764  * @tc.desc: test count of refcounter.
765  */
766 HWTEST_F(UtilsRefbaseTest, testRefbase007, TestSize.Level0)
767 {
768     sptr<RefBase> testObject1(new RefBase());
769     EXPECT_EQ(testObject1->GetRefCounter()->GetRefCount(), 1);
770     wptr<RefBase> testObject2(testObject1);
771     EXPECT_EQ(testObject1->GetRefCounter()->GetRefCount(), 2); // 2: Refbase and WeakRefCounter
772 }
773 
774 /*
775  * @tc.name: testRefbase008
776  * @tc.desc: test move constructor.
777  */
778 HWTEST_F(UtilsRefbaseTest, testRefbase008, TestSize.Level0)
779 {
780     RefBase baseObject1{};
781     EXPECT_EQ(baseObject1.GetRefCounter()->GetRefCount(), 1);
782 
783     RefBase baseObject2{};
784     EXPECT_EQ(baseObject2.GetRefCounter()->GetRefCount(), 1);
785     baseObject2 = std::move(baseObject1);
786     EXPECT_EQ(baseObject2.GetRefCounter()->GetRefCount(), 1);
787     EXPECT_EQ(baseObject1.GetRefCounter(), nullptr);
788     EXPECT_EQ(baseObject1.GetSptrRefCount(), 0);
789     EXPECT_EQ(baseObject1.GetWptrRefCount(), 0);
790 
791     RefBase baseObject3{};
792     EXPECT_EQ(baseObject3.GetRefCounter()->GetRefCount(), 1);
793     baseObject3 = std::move(baseObject2);
794     EXPECT_EQ(baseObject3.GetRefCounter()->GetRefCount(), 1);
795     EXPECT_EQ(baseObject2.GetRefCounter(), nullptr);
796     EXPECT_EQ(baseObject2.GetSptrRefCount(), 0);
797     EXPECT_EQ(baseObject2.GetWptrRefCount(), 0);
798 
799     baseObject2 = std::move(baseObject1);
800     EXPECT_EQ(baseObject1.GetRefCounter(), baseObject2.GetRefCounter());
801 }
802 
803 class WptrTest : public RefBase {
804 public:
WptrTest()805     WptrTest()
806     {
807         g_sptrCount++;
808     }
~WptrTest()809     ~WptrTest()
810     {
811         g_sptrCount--;
812     }
813 };
814 
815 class WptrTest2 : public RefBase {
816 public:
WptrTest2()817     WptrTest2()
818     {
819         g_sptrCount++;
820         flag_ = 0;
821     }
~WptrTest2()822     ~WptrTest2()
823     {
824         g_sptrCount--;
825     }
826 
827 private:
828     int flag_;
829 };
830 
831 /*
832  * @tc.name: testWptrefbase001
833  * @tc.desc: Copy constructor with same managed class type.
834  */
835 HWTEST_F(UtilsRefbaseTest, testWptrefbase001, TestSize.Level0)
836 {
837     // test wptr<T>::wptr(const wptr<T>&)
838     wptr<WptrTest> testOrigWptrObject(new WptrTest());
839     EXPECT_EQ(testOrigWptrObject->GetWptrRefCount(), 1);
840 
841     wptr<WptrTest> testTargetWptrObject1(testOrigWptrObject);
842 
843     EXPECT_EQ(testOrigWptrObject.GetRefPtr(), testTargetWptrObject1.GetRefPtr());
844     EXPECT_EQ(&(*testOrigWptrObject), &(*testTargetWptrObject1));
845     EXPECT_EQ(testTargetWptrObject1->GetWptrRefCount(), testOrigWptrObject->GetWptrRefCount());
846     EXPECT_EQ(testTargetWptrObject1.GetWeakRefCount(), testOrigWptrObject.GetWeakRefCount());
847 
848     EXPECT_EQ(testTargetWptrObject1->GetWptrRefCount(), 1);
849     EXPECT_EQ(testTargetWptrObject1.GetWeakRefCount(), 2);
850 
851     // test wptr<T>::operator=(const wptr<T>&)
852     wptr<WptrTest> testTargetWptrObject2(new WptrTest());
853     EXPECT_EQ(testTargetWptrObject2->GetWptrRefCount(), 1);
854 
855     testTargetWptrObject2 = testOrigWptrObject;
856 
857     EXPECT_EQ(testOrigWptrObject.GetRefPtr(), testTargetWptrObject2.GetRefPtr());
858     EXPECT_EQ(&(*testOrigWptrObject), &(*testTargetWptrObject2));
859     EXPECT_EQ(testTargetWptrObject2->GetWptrRefCount(), testOrigWptrObject->GetWptrRefCount());
860     EXPECT_EQ(testTargetWptrObject2.GetWeakRefCount(), testOrigWptrObject.GetWeakRefCount());
861 
862     EXPECT_EQ(testTargetWptrObject2->GetWptrRefCount(), 1);
863     EXPECT_EQ(testTargetWptrObject2.GetWeakRefCount(), 3);
864 
865     // test wptr<T>::wptr(const sptr<T>&)
866     sptr<WptrTest> testOrigSptrObject(new WptrTest());
867     EXPECT_EQ(testOrigSptrObject->GetSptrRefCount(), 1);
868 
869     wptr<WptrTest> testTargetWptrObject3(testOrigSptrObject);
870 
871     EXPECT_EQ(testOrigSptrObject.GetRefPtr(), testTargetWptrObject3.GetRefPtr());
872     EXPECT_EQ(&(*testOrigSptrObject), &(*testTargetWptrObject3));
873     EXPECT_EQ(testTargetWptrObject3->GetSptrRefCount(), testOrigSptrObject->GetSptrRefCount());
874     EXPECT_EQ(testTargetWptrObject3->GetWptrRefCount(), testOrigSptrObject->GetWptrRefCount());
875 
876     EXPECT_EQ(testTargetWptrObject3->GetSptrRefCount(), 1);
877     EXPECT_EQ(testTargetWptrObject3->GetWptrRefCount(), 2);
878     EXPECT_EQ(testTargetWptrObject3.GetWeakRefCount(), 1);
879 
880     // test wptr<T>::operator=(const sptr<T>&)
881     wptr<WptrTest> testTargetWptrObject4(new WptrTest());
882     EXPECT_EQ(testTargetWptrObject4->GetWptrRefCount(), 1);
883 
884     testTargetWptrObject4 = testOrigSptrObject;
885 
886     EXPECT_EQ(testOrigSptrObject.GetRefPtr(), testTargetWptrObject4.GetRefPtr());
887     EXPECT_EQ(&(*testOrigSptrObject), &(*testTargetWptrObject4));
888     EXPECT_EQ(testTargetWptrObject4->GetSptrRefCount(), testOrigSptrObject->GetSptrRefCount());
889     EXPECT_EQ(testTargetWptrObject4->GetWptrRefCount(), testOrigSptrObject->GetWptrRefCount());
890 
891     EXPECT_EQ(testTargetWptrObject4->GetSptrRefCount(), 1);
892     EXPECT_EQ(testTargetWptrObject4->GetWptrRefCount(), 3);
893     EXPECT_EQ(testTargetWptrObject4.GetWeakRefCount(), 1);
894 }
895 
896 /*
897  * @tc.name: testWptrefbase002
898  * @tc.desc: Copy constructor with different managed class type.
899  */
900 HWTEST_F(UtilsRefbaseTest, testWptrefbase002, TestSize.Level0)
901 {
902     // test wptr<T>::wptr(const wptr<O>&)
903     wptr<WptrTest2> testOrigWptrObject(new WptrTest2());
904     EXPECT_EQ(testOrigWptrObject->GetWptrRefCount(), 1);
905 
906     wptr<WptrTest> testTargetWptrObject1(testOrigWptrObject);
907 
908     EXPECT_EQ(static_cast<void *>(testOrigWptrObject.GetRefPtr()),
909               static_cast<void *>(testTargetWptrObject1.GetRefPtr()));
910     EXPECT_EQ(static_cast<void *>(&(*testOrigWptrObject)),
911               static_cast<void *>(&(*testTargetWptrObject1)));
912     EXPECT_EQ(testTargetWptrObject1->GetWptrRefCount(), testOrigWptrObject->GetWptrRefCount());
913     EXPECT_EQ(testTargetWptrObject1.GetWeakRefCount(), testOrigWptrObject.GetWeakRefCount());
914 
915     EXPECT_EQ(testTargetWptrObject1->GetWptrRefCount(), 1);
916     EXPECT_EQ(testTargetWptrObject1.GetWeakRefCount(), 2);
917 
918     // test wptr<T>::operator=(const wptr<O>&)
919     wptr<WptrTest> testTargetWptrObject2(new WptrTest());
920     EXPECT_EQ(testTargetWptrObject2->GetWptrRefCount(), 1);
921 
922     testTargetWptrObject2 = testOrigWptrObject;
923 
924     EXPECT_EQ(static_cast<void *>(testOrigWptrObject.GetRefPtr()),
925               static_cast<void *>(testTargetWptrObject2.GetRefPtr()));
926     EXPECT_EQ(static_cast<void *>(&(*testOrigWptrObject)),
927               static_cast<void *>(&(*testTargetWptrObject2)));
928     EXPECT_EQ(testTargetWptrObject2->GetWptrRefCount(), testOrigWptrObject->GetWptrRefCount());
929     EXPECT_EQ(testTargetWptrObject2.GetWeakRefCount(), testOrigWptrObject.GetWeakRefCount());
930 
931     EXPECT_EQ(testTargetWptrObject2->GetWptrRefCount(), 1);
932     EXPECT_EQ(testTargetWptrObject2.GetWeakRefCount(), 3);
933 
934     // test wptr<T>::wptr(const sptr<O>&)
935     sptr<WptrTest2> testOrigSptrObject(new WptrTest2());
936     EXPECT_EQ(testOrigSptrObject->GetSptrRefCount(), 1);
937 
938     wptr<WptrTest> testTargetWptrObject3(testOrigSptrObject);
939 
940     EXPECT_EQ(static_cast<void *>(testOrigSptrObject.GetRefPtr()),
941               static_cast<void *>(testTargetWptrObject3.GetRefPtr()));
942     EXPECT_EQ(static_cast<void *>(&(*testOrigSptrObject)), static_cast<void *>(&(*testTargetWptrObject3)));
943     EXPECT_EQ(testTargetWptrObject3->GetSptrRefCount(), testOrigSptrObject->GetSptrRefCount());
944     EXPECT_EQ(testTargetWptrObject3->GetWptrRefCount(), testOrigSptrObject->GetWptrRefCount());
945 
946     EXPECT_EQ(testTargetWptrObject3->GetSptrRefCount(), 1);
947     EXPECT_EQ(testTargetWptrObject3->GetWptrRefCount(), 2);
948     EXPECT_EQ(testTargetWptrObject3.GetWeakRefCount(), 1);
949 
950     // test wptr<T>::operator=(const sptr<O>&)
951     wptr<WptrTest> testTargetWptrObject4(new WptrTest());
952     EXPECT_EQ(testTargetWptrObject4->GetWptrRefCount(), 1);
953 
954     testTargetWptrObject4 = testOrigSptrObject;
955 
956     EXPECT_EQ(static_cast<void *>(testOrigSptrObject.GetRefPtr()),
957               static_cast<void *>(testTargetWptrObject4.GetRefPtr()));
958     EXPECT_EQ(static_cast<void *>(&(*testOrigSptrObject)), static_cast<void *>(&(*testTargetWptrObject4)));
959     EXPECT_EQ(testTargetWptrObject4->GetSptrRefCount(), testOrigSptrObject->GetSptrRefCount());
960     EXPECT_EQ(testTargetWptrObject4->GetWptrRefCount(), testOrigSptrObject->GetWptrRefCount());
961 
962     EXPECT_EQ(testTargetWptrObject4->GetSptrRefCount(), 1);
963     EXPECT_EQ(testTargetWptrObject4->GetWptrRefCount(), 3);
964     EXPECT_EQ(testTargetWptrObject4.GetWeakRefCount(), 1);
965 }
966 
967 /*
968  * @tc.name: testWptrefbase003
969  * @tc.desc: Refbase
970  */
971 HWTEST_F(UtilsRefbaseTest, testWptrefbase003, TestSize.Level0)
972 {
973     const wptr<WptrTest> &testObject1(new WptrTest());
974     wptr<WptrTest> testObject2(testObject1);
975     EXPECT_EQ(testObject1.GetRefPtr(), testObject2.GetRefPtr());
976     EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
977     EXPECT_EQ(testObject2->GetWptrRefCount(), 1);
978     EXPECT_EQ(testObject1.GetRefPtr(), testObject2.GetRefPtr());
979 }
980 
981 /*
982  * @tc.name: testWptrefbase004
983  * @tc.desc: Refbase
984  */
985 HWTEST_F(UtilsRefbaseTest, testWptrefbase004, TestSize.Level0)
986 {
987     const sptr<WptrTest2> &testObject1(new WptrTest2());
988     EXPECT_NE(testObject1, nullptr);
989     wptr<WptrTest> testObject2 = testObject1;
990     EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
991 }
992 
993 /*
994  * @tc.name: testWptrefbase005
995  * @tc.desc: wptr without managed object
996  */
997 HWTEST_F(UtilsRefbaseTest, testWptrefbase005, TestSize.Level0)
998 {
999     wptr<WptrTest> testObject3;
1000     EXPECT_EQ(testObject3.GetRefPtr(), nullptr);
1001 }
1002 
1003 /*
1004  * @tc.name: testWptrefbase006
1005  * @tc.desc: Refbase
1006  */
1007 HWTEST_F(UtilsRefbaseTest, testWptrefbase006, TestSize.Level0)
1008 {
1009     wptr<WptrTest> testObject1 = new WptrTest();
1010     wptr<WptrTest> &testObject2 = testObject1;
1011     EXPECT_EQ(testObject2->GetWptrRefCount(), 1);
1012 }
1013 
1014 /*
1015  * @tc.name: testWptrefbase007
1016  * @tc.desc: Refbase
1017  */
1018 HWTEST_F(UtilsRefbaseTest, testWptrefbase007, TestSize.Level0)
1019 {
1020     wptr<WptrTest2> testObject1 = new WptrTest2();
1021     wptr<WptrTest2> testObject2 = testObject1.GetRefPtr();
1022     EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
1023 }
1024 
1025 /*
1026  * @tc.name: testWptrefbase008
1027  * @tc.desc: Refbase
1028  */
1029 HWTEST_F(UtilsRefbaseTest, testWptrefbase008, TestSize.Level0)
1030 {
1031     wptr<WptrTest> testObject1 = new WptrTest();
1032     wptr<WptrTest2> testObject2;
1033     testObject2 = testObject1.GetRefPtr();
1034     EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
1035 }
1036 
1037 /*
1038  * @tc.name: testSptrWptrefbase001
1039  * @tc.desc: test interaction between sptr and wptr.
1040  */
1041 HWTEST_F(UtilsRefbaseTest, testSptrWptrefbase001, TestSize.Level0)
1042 {
1043     wptr<RefBase> testObject1(new RefBase());
1044     EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
1045     {
1046         sptr<RefBase> testObject2{};
1047         testObject2 = testObject1;
1048         EXPECT_EQ(testObject2->GetSptrRefCount(), 1);
1049         EXPECT_EQ(testObject2->GetWptrRefCount(), 2); // 2: sptr and WeakRefCounter
1050 
1051         sptr<RefBase> testObject3 = testObject1.promote();
1052         EXPECT_EQ(testObject2->GetSptrRefCount(), 2); // 2: 2 sptrs
1053         EXPECT_EQ(testObject2->GetWptrRefCount(), 3); // 3: 2 sptrs and WeakRefCounter
1054         testObject2->ExtendObjectLifetime();
1055     }
1056     EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
1057 }
1058 
1059 /*
1060  * @tc.name: testRefbaseDebug001
1061  * @tc.desc: Test for single thread. Tracker can be enabled after construction
1062  *           of sptr.
1063  */
1064 HWTEST_F(UtilsRefbaseTest, testRefbaseDebug001, TestSize.Level1)
1065 {
1066     sptr<RefBase> testObject1(new RefBase());
1067     testObject1->EnableTracker();
1068     sptr<RefBase> testObject2(testObject1);
1069     EXPECT_EQ(testObject2->GetSptrRefCount(), 2);
1070     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1071     wptr<RefBase> testObject3(testObject2);
1072     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1073     wptr<RefBase> testObject4(testObject3);
1074     EXPECT_EQ(testObject4->GetWptrRefCount(), 3);
1075     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1076 }
1077 
1078 /*
1079  * @tc.name: testRefbaseDebug002
1080  * @tc.desc: Test for single thread. Tracker can be enabled after construction
1081  *           of wptr.
1082  */
1083 HWTEST_F(UtilsRefbaseTest, testRefbaseDebug002, TestSize.Level1)
1084 {
1085     wptr<RefBase> testObject1(new RefBase());
1086     testObject1->EnableTracker();
1087     sptr<RefBase> testObject2 = testObject1.promote();
1088     EXPECT_EQ(testObject2->GetSptrRefCount(), 1);
1089     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1090     wptr<RefBase> testObject3(testObject2);
1091     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1092     wptr<RefBase> testObject4(testObject3);
1093     EXPECT_EQ(testObject4->GetWptrRefCount(), 3);
1094     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1095 }
1096 
1097 // This is a class which can be tracked when implemented.
1098 class TestDebug : public RefBase {
1099 public:
TestDebug()1100     TestDebug()
1101     {
1102         EnableTracker();
1103     }
1104 };
1105 
1106 /*
1107  * @tc.name: testRefbaseDebug003
1108  * @tc.desc: Test for single thread. Tracker can be enabled with construction
1109  *           of sptr.
1110  */
1111 HWTEST_F(UtilsRefbaseTest, testRefbaseDebug003, TestSize.Level1)
1112 {
1113     sptr<TestDebug> testObject1(new TestDebug());
1114     sptr<TestDebug> testObject2(testObject1);
1115     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1116     sptr<TestDebug> testObject3;
1117     EXPECT_EQ(testObject2->GetSptrRefCount(), 2);
1118     testObject3 = testObject2;
1119     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1120     wptr<TestDebug> testObject4(testObject3);
1121     EXPECT_EQ(testObject4->GetWptrRefCount(), 4);
1122     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1123 }
1124 
1125 /*
1126  * @tc.name: testRefbaseDebug004
1127  * @tc.desc: Test for mult-thread.
1128  */
1129 HWTEST_F(UtilsRefbaseTest, testRefbaseDebug004, TestSize.Level1)
1130 {
1131     sptr<TestDebug> testObject1(new TestDebug());
__anonbd15c9080202() 1132     std::thread subThread {[&testObject1]() {
1133         sptr<TestDebug> subTestObject1(testObject1);
1134         EXPECT_EQ(testObject1->GetSptrRefCount(), 2);
1135         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1136         wptr<TestDebug> subTestObject2(subTestObject1);
1137         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1138         wptr<TestDebug> subTestObject3(subTestObject2);
1139         std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1140     }};
1141     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1142     wptr<TestDebug> testObject2(testObject1);
1143     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1144     wptr<TestDebug> testObject3(testObject2);
1145     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1146     subThread.join();
1147     EXPECT_EQ(testObject3->GetWptrRefCount(), 2);
1148 }
1149 }  // namespace
1150 }  // namespace OHOS
1151