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
28 using namespace testing::ext;
29 using namespace OHOS;
30 using namespace std;
31
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 private:
402 int value_;
403 };
404
405 /*
406 * @tc.name: testRefbaseOperateLeftValue001
407 * @tc.desc: Refbase
408 */
409 HWTEST_F(UtilsRefbaseTest, testRefbaseOperateLeftValue001, TestSize.Level0)
410 {
411 RefBaseMemTest::g_checkCount = 0;
412 {
413 vector<RefBaseMemTest> refMemTestArray;
414 sptr<RefBaseMemTest>refMemTestObj1 = new RefBaseMemTest(1);
415 sptr<RefBaseMemTest>refMemTestObj2 = new RefBaseMemTest(2);
416 refMemTestArray.push_back(*refMemTestObj1);
417 refMemTestArray.push_back(*refMemTestObj2);
418 }
419 EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
420
421 {
422 vector<RefBaseMemTest> refMemTestArray;
423 RefBaseMemTest refMemTestObj1(1);
424 RefBaseMemTest refMemTestObj2(2);
425 refMemTestArray.push_back(refMemTestObj1);
426 refMemTestArray.push_back(refMemTestObj2);
427 }
428 EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
429 }
430
431 /*
432 * @tc.name: testRefbaseOperateRightValue001
433 * @tc.desc: Refbase
434 */
435 HWTEST_F(UtilsRefbaseTest, testRefbaseOperateRightValue001, TestSize.Level0)
436 {
437 RefBaseMemTest::g_checkCount = 0;
438 {
439 vector<RefBaseMemTest> refMemTestArray;
440 sptr<RefBaseMemTest>refMemTestObj1 = new RefBaseMemTest(1);
441 sptr<RefBaseMemTest>refMemTestObj2 = new RefBaseMemTest(2);
442 refMemTestArray.emplace_back(*refMemTestObj1);
443 refMemTestArray.emplace_back(*refMemTestObj2);
444 }
445 EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
446
447 {
448 vector<RefBaseMemTest> refMemTestArray;
449 RefBaseMemTest refMemTestObj1(1);
450 RefBaseMemTest refMemTestObj2(2);
451 refMemTestArray.emplace_back(refMemTestObj1);
452 refMemTestArray.emplace_back(refMemTestObj2);
453 }
454 EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
455 }
456
457 /*
458 * @tc.name: testRefbaseAcquire001
459 * @tc.desc: Refbase
460 */
461 HWTEST_F(UtilsRefbaseTest, testRefbaseAcquire001, TestSize.Level0)
462 {
463 RefBaseTest* testobject = new RefBaseTest();
464 testobject->AttemptAcquire(this);
465
466 g_freeFlag = 0;
467 EXPECT_EQ(testobject->GetSptrRefCount(), 1);
468 {
469 EXPECT_TRUE(testobject->IsAttemptAcquireSet());
470 sptr<RefBaseTest> sptrRef = testobject;
471 EXPECT_EQ(sptrRef->GetSptrRefCount(), 1);
472 EXPECT_FALSE(testobject->IsAttemptAcquireSet());
473 }
474
475 EXPECT_EQ(g_freeFlag, 1);
476 }
477
478 /*
479 * @tc.name: testSptrefbase001
480 * @tc.desc: Refbase
481 */
482 HWTEST_F(UtilsRefbaseTest, testSptrefbase001, TestSize.Level0)
483 {
484 sptr<RefBaseTest> testobject = new RefBaseTest();
485 testobject->ExtendObjectLifetime();
486 EXPECT_TRUE(testobject->IsExtendLifeTimeSet());
487 EXPECT_EQ(g_refbaseflag, 1);
488 wptr<RefBaseTest> weakObject(testobject);
489 int count = testobject->GetWptrRefCount();
490 EXPECT_EQ(count, 2);
491 testobject = nullptr;
492
493 sptr<RefBaseTest> strongObject = weakObject.promote();
494 EXPECT_EQ(strongObject->GetSptrRefCount(), 1);
495 }
496
497 /*
498 * @tc.name: testSptrefbaseRealease001
499 * @tc.desc: Refbase
500 */
501 HWTEST_F(UtilsRefbaseTest, testSptrefbaseRealease001, TestSize.Level0)
502 {
503 sptr<RefBaseTest> testObject = new RefBaseTest();
504 EXPECT_EQ(g_refbaseflag, 1);
505 wptr<RefBaseTest> weakObject(testObject);
506 testObject = nullptr;
507 EXPECT_EQ(g_refbaseflag, FLAG_OF_DEST);
508 }
509
510 /*
511 * @tc.name: testSptrefbaseRealease002
512 * @tc.desc: Refbase
513 */
514 HWTEST_F(UtilsRefbaseTest, testSptrefbaseRealease002, TestSize.Level0)
515 {
516 wptr<RefBaseTest> testObject = new RefBaseTest();
517 EXPECT_EQ(g_refbaseflag, 1);
518 testObject = nullptr;
519 EXPECT_EQ(g_refbaseflag, FLAG_OF_DEST);
520 }
521
522 /*
523 * @tc.name: testSptrefbase002
524 * @tc.desc: Refbase
525 */
526 HWTEST_F(UtilsRefbaseTest, testSptrefbase002, TestSize.Level0)
527 {
528 {
529 sptr<RefBaseTest> testObject(new RefBaseTest());
530 EXPECT_EQ(g_refbaseflag, 1);
531 }
532 EXPECT_EQ(g_refbaseflag, 2);
533 }
534
535 /*
536 * @tc.name: testSptrefbase003
537 * @tc.desc: Refbase
538 */
539 HWTEST_F(UtilsRefbaseTest, testSptrefbase003, TestSize.Level0)
540 {
541 sptr<RefBaseTest> testObject1(new RefBaseTest());
542 sptr<RefBaseTest> testObject2 = testObject1.GetRefPtr();
543 testObject2->SetRefPtr();
544 EXPECT_TRUE(testObject1->GetTestRefPtrFlag());
545
546 sptr<RefBaseTest> testObject3(testObject1);
547 EXPECT_TRUE(testObject3->GetTestRefPtrFlag());
548
549 sptr<RefBaseTest> testObject4 = testObject1;
550 EXPECT_TRUE(testObject3->GetTestRefPtrFlag());
551
552 bool ret = (testObject3 == testObject4);
553 EXPECT_TRUE(ret);
554
555 int refcount = testObject1->GetSptrRefCount();
556 EXPECT_EQ(refcount, 4);
557
558 sptr<RefBaseTest> testObject5(new RefBaseTest());
559 ret = (testObject5 != testObject1);
560 EXPECT_TRUE(ret);
561 }
562
563 /*
564 * @tc.name: testSptrefbase004
565 * @tc.desc: Refbase
566 */
567 HWTEST_F(UtilsRefbaseTest, testSptrefbase004, TestSize.Level0)
568 {
569 sptr<RefBaseTest> testObject1(new RefBaseTest());
570 testObject1->SetRefPtr();
571 RefBaseTest testObject2 = *testObject1;
572 EXPECT_TRUE(testObject2.GetTestRefPtrFlag());
573
574 auto testObject3 = testObject1;
575 testObject1 = nullptr;
576 testObject3 = nullptr;
577 EXPECT_EQ(g_refbaseflag, 2);
578 }
579
580 /*
581 * @tc.name: testSptrefbase005
582 * @tc.desc: Refbase
583 */
584 HWTEST_F(UtilsRefbaseTest, testSptrefbase005, TestSize.Level0)
585 {
586 sptr<RefBaseTest> testObject1(new RefBaseTest());
587 wptr<RefBaseTest> testObject2 = testObject1;
588 EXPECT_EQ(testObject1->GetSptrRefCount(), 1);
589 EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
590 }
591
592 /*
593 * @tc.name: testSptrefbase006
594 * @tc.desc: Refbase
595 */
596 HWTEST_F(UtilsRefbaseTest, testSptrefbase006, TestSize.Level0)
597 {
598 sptr<RefBaseTest> testObject1;
599 EXPECT_EQ(testObject1.GetRefPtr(), nullptr);
600 testObject1 = new RefBaseTest();
601 sptr<RefBaseTest> testObject2(testObject1);
602 EXPECT_EQ(testObject1->GetSptrRefCount(), 2);
603 }
604
605 /*
606 * @tc.name: testSptrefbase007
607 * @tc.desc: Refbase
608 */
609 HWTEST_F(UtilsRefbaseTest, testSptrefbase007, TestSize.Level0)
610 {
611 const sptr<RefBaseTest> &testObject1 = new RefBaseTest();
612 sptr<RefBaseTest> testObject2(testObject1);
613 EXPECT_EQ(testObject1->GetSptrRefCount(), 2);
614 }
615
616 /*
617 * @tc.name: testSptrefbase008
618 * @tc.desc: Refbase
619 */
620 HWTEST_F(UtilsRefbaseTest, testSptrefbase008, TestSize.Level0)
621 {
622 sptr<RefBaseTest> testObject1;
623 sptr<RefBaseTest> testObject2(testObject1);
624 EXPECT_EQ(testObject2, nullptr);
625 }
626
627 /*
628 * @tc.name: testSptrefbase009
629 * @tc.desc: Refbase
630 */
631 HWTEST_F(UtilsRefbaseTest, testSptrefbase009, TestSize.Level0)
632 {
633 sptr<RefBaseTest> testObject0 = new RefBaseTest();
634 sptr<RefBaseTest> testObject1 = move(testObject0);
635 sptr<RefBaseTest> testObject2(testObject1);
636 EXPECT_EQ(testObject0.GetRefPtr(), nullptr);
637 EXPECT_EQ(testObject2.GetRefPtr(), testObject1.GetRefPtr());
638 }
639
640 /*
641 * @tc.name: testSptrefbase010
642 * @tc.desc: Refbase
643 */
644 HWTEST_F(UtilsRefbaseTest, testSptrefbase010, TestSize.Level0)
645 {
646 sptr<RefBaseTest> testObject1 = new RefBaseTest();
647 sptr<RefBaseTest> testObject3(new RefBaseTest());
648 sptr<RefBaseTest> &testObject2 = testObject3;
649 testObject2 = testObject1;
650 EXPECT_EQ(testObject2.GetRefPtr(), testObject1.GetRefPtr());
651
652 const sptr<RefBaseTest> &testObject4 = new RefBaseTest();
653 EXPECT_EQ(testObject1->GetSptrRefCount(), 2);
654 testObject2 = testObject4;
655 EXPECT_EQ(testObject2.GetRefPtr(), testObject4.GetRefPtr());
656 EXPECT_EQ(testObject4->GetSptrRefCount(), 2);
657 EXPECT_EQ(testObject1->GetSptrRefCount(), 1);
658 }
659
660 class SptrTest : public RefBase {
661 public:
SptrTest()662 SptrTest()
663 {
664 g_sptrCount++;
665 }
~SptrTest()666 ~SptrTest()
667 {
668 g_sptrCount--;
669 }
CreateSptr()670 void CreateSptr()
671 {
672 test1 = new SptrTest();
673 }
674
675 private:
676 sptr<SptrTest> test1;
677 };
678
679 /*
680 * @tc.name: testRefbase005
681 * @tc.desc: Refbase
682 */
683 HWTEST_F(UtilsRefbaseTest, testRefbase005, TestSize.Level0)
684 {
685 {
686 sptr<SptrTest> testObject1(new SptrTest());
687 testObject1->CreateSptr();
688 }
689 EXPECT_EQ(g_sptrCount, 0);
690 }
691
692 class SptrTest1;
693 class SptrTest2;
694 class SptrTest2 : public RefBase {
695 public:
SptrTest2()696 SptrTest2()
697 {
698 g_sptrCount++;
699 }
~SptrTest2()700 ~SptrTest2()
701 {
702 g_sptrCount--;
703 }
704
705 private:
706 sptr<SptrTest1> test;
707 };
708
709 class SptrTest1 : public RefBase {
710 public:
SptrTest1()711 SptrTest1()
712 {
713 g_sptrCount++;
714 }
~SptrTest1()715 ~SptrTest1()
716 {
717 g_sptrCount--;
718 }
719
720 private:
721 sptr<SptrTest2> test;
722 };
723
724 /*
725 * @tc.name: testRefbase006
726 * @tc.desc: Refbase
727 */
728 HWTEST_F(UtilsRefbaseTest, testRefbase006, TestSize.Level0)
729 {
730 {
731 sptr<SptrTest1> testObject1(new SptrTest1());
732 sptr<SptrTest2> testObject2(new SptrTest2());
733 EXPECT_EQ(g_sptrCount, 2);
734 }
735 EXPECT_EQ(g_sptrCount, 0);
736 }
737
738 class WptrTest : public RefBase {
739 public:
WptrTest()740 WptrTest()
741 {
742 g_sptrCount++;
743 }
~WptrTest()744 ~WptrTest()
745 {
746 g_sptrCount--;
747 }
748 };
749
750 class WptrTest2 : public RefBase {
751 public:
WptrTest2()752 WptrTest2()
753 {
754 g_sptrCount++;
755 flag_ = 0;
756 }
~WptrTest2()757 ~WptrTest2()
758 {
759 g_sptrCount--;
760 }
761
762 private:
763 int flag_;
764 };
765
766 /*
767 * @tc.name: testWptrefbase001
768 * @tc.desc: Refbase
769 */
770 HWTEST_F(UtilsRefbaseTest, testWptrefbase001, TestSize.Level0)
771 {
772 wptr<WptrTest> testObject1(new WptrTest());
773 EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
774
775 wptr<WptrTest> testObject2 = testObject1;
776 EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
777
778 sptr<WptrTest> testObject3(new WptrTest());
779 wptr<WptrTest> testObject4(testObject3);
780 EXPECT_EQ(testObject3->GetSptrRefCount(), 1);
781 EXPECT_EQ(testObject4->GetWptrRefCount(), 2);
782 }
783
784 /*
785 * @tc.name: testWptrefbase002
786 * @tc.desc: Refbase
787 */
788 HWTEST_F(UtilsRefbaseTest, testWptrefbase002, TestSize.Level0)
789 {
790 wptr<WptrTest> testObject1(new WptrTest());
791 wptr<WptrTest> testObject2(testObject1);
792 EXPECT_EQ(testObject1.GetRefPtr(), testObject2.GetRefPtr());
793
794 wptr<WptrTest> testObject3;
795 EXPECT_EQ(testObject3.GetRefPtr(), nullptr);
796 }
797
798 /*
799 * @tc.name: testWptrefbase003
800 * @tc.desc: Refbase
801 */
802 HWTEST_F(UtilsRefbaseTest, testWptrefbase003, TestSize.Level0)
803 {
804 const wptr<WptrTest> &testObject1(new WptrTest());
805 wptr<WptrTest> testObject2(testObject1);
806 EXPECT_EQ(testObject1.GetRefPtr(), testObject2.GetRefPtr());
807 EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
808 EXPECT_EQ(testObject2->GetWptrRefCount(), 1);
809 EXPECT_EQ(testObject1.GetRefPtr(), testObject2.GetRefPtr());
810 }
811
812 /*
813 * @tc.name: testWptrefbase004
814 * @tc.desc: Refbase
815 */
816 HWTEST_F(UtilsRefbaseTest, testWptrefbase004, TestSize.Level0)
817 {
818 const sptr<WptrTest2> &testObject1(new WptrTest2());
819 EXPECT_NE(testObject1, nullptr);
820 wptr<WptrTest> testObject2 = testObject1;
821 EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
822 }
823
824 /*
825 * @tc.name: testWptrefbase005
826 * @tc.desc: Refbase
827 */
828 HWTEST_F(UtilsRefbaseTest, testWptrefbase005, TestSize.Level0)
829 {
830 wptr<WptrTest2> testObject1 = new WptrTest2();
831 wptr<WptrTest> testObject2(testObject1);
832 EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
833 }
834
835 /*
836 * @tc.name: testWptrefbase006
837 * @tc.desc: Refbase
838 */
839 HWTEST_F(UtilsRefbaseTest, testWptrefbase006, TestSize.Level0)
840 {
841 wptr<WptrTest> testObject1 = new WptrTest();
842 wptr<WptrTest> &testObject2 = testObject1;
843 EXPECT_EQ(testObject2->GetWptrRefCount(), 1);
844 }
845
846 /*
847 * @tc.name: testWptrefbase007
848 * @tc.desc: Refbase
849 */
850 HWTEST_F(UtilsRefbaseTest, testWptrefbase007, TestSize.Level0)
851 {
852 wptr<WptrTest2> testObject1 = new WptrTest2();
853 wptr<WptrTest2> testObject2 = testObject1.GetRefPtr();
854 EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
855 }
856
857 /*
858 * @tc.name: testWptrefbase008
859 * @tc.desc: Refbase
860 */
861 HWTEST_F(UtilsRefbaseTest, testWptrefbase008, TestSize.Level0)
862 {
863 wptr<WptrTest> testObject1 = new WptrTest();
864 wptr<WptrTest2> testObject2;
865 testObject2 = testObject1.GetRefPtr();
866 EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
867 }
868