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