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 class WptrTest : public RefBase {
740 public:
WptrTest()741 WptrTest()
742 {
743 g_sptrCount++;
744 }
~WptrTest()745 ~WptrTest()
746 {
747 g_sptrCount--;
748 }
749 };
750
751 class WptrTest2 : public RefBase {
752 public:
WptrTest2()753 WptrTest2()
754 {
755 g_sptrCount++;
756 flag_ = 0;
757 }
~WptrTest2()758 ~WptrTest2()
759 {
760 g_sptrCount--;
761 }
762
763 private:
764 int flag_;
765 };
766
767 /*
768 * @tc.name: testWptrefbase001
769 * @tc.desc: Refbase
770 */
771 HWTEST_F(UtilsRefbaseTest, testWptrefbase001, TestSize.Level0)
772 {
773 wptr<WptrTest> testObject1(new WptrTest());
774 EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
775
776 wptr<WptrTest> testObject2 = testObject1;
777 EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
778
779 sptr<WptrTest> testObject3(new WptrTest());
780 wptr<WptrTest> testObject4(testObject3);
781 EXPECT_EQ(testObject3->GetSptrRefCount(), 1);
782 EXPECT_EQ(testObject4->GetWptrRefCount(), 2);
783 }
784
785 /*
786 * @tc.name: testWptrefbase002
787 * @tc.desc: Refbase
788 */
789 HWTEST_F(UtilsRefbaseTest, testWptrefbase002, TestSize.Level0)
790 {
791 wptr<WptrTest> testObject1(new WptrTest());
792 wptr<WptrTest> testObject2(testObject1);
793 EXPECT_EQ(testObject1.GetRefPtr(), testObject2.GetRefPtr());
794
795 wptr<WptrTest> testObject3;
796 EXPECT_EQ(testObject3.GetRefPtr(), nullptr);
797 }
798
799 /*
800 * @tc.name: testWptrefbase003
801 * @tc.desc: Refbase
802 */
803 HWTEST_F(UtilsRefbaseTest, testWptrefbase003, TestSize.Level0)
804 {
805 const wptr<WptrTest> &testObject1(new WptrTest());
806 wptr<WptrTest> testObject2(testObject1);
807 EXPECT_EQ(testObject1.GetRefPtr(), testObject2.GetRefPtr());
808 EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
809 EXPECT_EQ(testObject2->GetWptrRefCount(), 1);
810 EXPECT_EQ(testObject1.GetRefPtr(), testObject2.GetRefPtr());
811 }
812
813 /*
814 * @tc.name: testWptrefbase004
815 * @tc.desc: Refbase
816 */
817 HWTEST_F(UtilsRefbaseTest, testWptrefbase004, TestSize.Level0)
818 {
819 const sptr<WptrTest2> &testObject1(new WptrTest2());
820 EXPECT_NE(testObject1, nullptr);
821 wptr<WptrTest> testObject2 = testObject1;
822 EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
823 }
824
825 /*
826 * @tc.name: testWptrefbase005
827 * @tc.desc: Refbase
828 */
829 HWTEST_F(UtilsRefbaseTest, testWptrefbase005, TestSize.Level0)
830 {
831 wptr<WptrTest2> testObject1 = new WptrTest2();
832 wptr<WptrTest> testObject2(testObject1);
833 EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
834 }
835
836 /*
837 * @tc.name: testWptrefbase006
838 * @tc.desc: Refbase
839 */
840 HWTEST_F(UtilsRefbaseTest, testWptrefbase006, TestSize.Level0)
841 {
842 wptr<WptrTest> testObject1 = new WptrTest();
843 wptr<WptrTest> &testObject2 = testObject1;
844 EXPECT_EQ(testObject2->GetWptrRefCount(), 1);
845 }
846
847 /*
848 * @tc.name: testWptrefbase007
849 * @tc.desc: Refbase
850 */
851 HWTEST_F(UtilsRefbaseTest, testWptrefbase007, TestSize.Level0)
852 {
853 wptr<WptrTest2> testObject1 = new WptrTest2();
854 wptr<WptrTest2> testObject2 = testObject1.GetRefPtr();
855 EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
856 }
857
858 /*
859 * @tc.name: testWptrefbase008
860 * @tc.desc: Refbase
861 */
862 HWTEST_F(UtilsRefbaseTest, testWptrefbase008, TestSize.Level0)
863 {
864 wptr<WptrTest> testObject1 = new WptrTest();
865 wptr<WptrTest2> testObject2;
866 testObject2 = testObject1.GetRefPtr();
867 EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
868 }
869 } // namespace
870 } // namespace OHOS