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