mirror of
https://github.com/openharmony/utils_native.git
synced 2026-08-27 21:41:00 -04:00
shuchengchao
869 lines
22 KiB
C++
869 lines
22 KiB
C++
/*
|
|
* Copyright (c) 2021 Huawei Device Co., Ltd.
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
#include <gtest/gtest.h>
|
|
#include <algorithm>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <thread>
|
|
#include <map>
|
|
#include <mutex>
|
|
#include "refbase.h"
|
|
#include "singleton.h"
|
|
|
|
#include <future>
|
|
|
|
using namespace testing::ext;
|
|
using namespace OHOS;
|
|
using namespace std;
|
|
|
|
static constexpr int FLAG_OF_CONS = 1;
|
|
static constexpr int FLAG_OF_DEST = 2;
|
|
static int g_sptrCount = 0;
|
|
static int g_wptrCount = 0;
|
|
static int g_refbaseflag = 0;
|
|
static int g_freeFlag = 0;
|
|
|
|
class UtilsRefbaseTest : public testing::Test {
|
|
public:
|
|
static void SetUpTestCase(void);
|
|
};
|
|
|
|
void UtilsRefbaseTest::SetUpTestCase(void)
|
|
{
|
|
g_sptrCount = 0;
|
|
g_wptrCount = 0;
|
|
g_refbaseflag = 0;
|
|
}
|
|
|
|
class RefBaseTest : public RefBase {
|
|
public:
|
|
RefBaseTest()
|
|
{
|
|
g_refbaseflag = FLAG_OF_CONS;
|
|
isgetrefptr_ = false;
|
|
}
|
|
~RefBaseTest()
|
|
{
|
|
g_refbaseflag = FLAG_OF_DEST;
|
|
}
|
|
|
|
void OnLastStrongRef(const void *objectId) override
|
|
{
|
|
g_freeFlag = 1;
|
|
}
|
|
|
|
void SetRefPtr()
|
|
{
|
|
isgetrefptr_ = true;
|
|
}
|
|
bool GetTestRefPtrFlag()
|
|
{
|
|
return isgetrefptr_;
|
|
}
|
|
|
|
private:
|
|
bool isgetrefptr_;
|
|
};
|
|
|
|
class IRemoteObject : public virtual RefBase {
|
|
public:
|
|
IRemoteObject() { ExtendObjectLifetime(); }
|
|
virtual bool IsProxyObject() = 0;
|
|
~IRemoteObject() {}
|
|
};
|
|
|
|
class RefBaseTestTracker : public RefBase {
|
|
public:
|
|
explicit RefBaseTestTracker(int value) : value_(value)
|
|
{
|
|
checkCount_++;
|
|
}
|
|
RefBaseTestTracker() = default;
|
|
~RefBaseTestTracker()
|
|
{
|
|
checkCount_--;
|
|
}
|
|
|
|
RefBaseTestTracker(const RefBaseTestTracker &testTracker)
|
|
{
|
|
checkCount_++;
|
|
value_ = testTracker.value_;
|
|
}
|
|
|
|
RefBaseTestTracker &operator=(const RefBaseTestTracker &testTracker)
|
|
{
|
|
checkCount_++;
|
|
value_ = testTracker.value_;
|
|
return *this;
|
|
}
|
|
|
|
RefBaseTestTracker(RefBaseTestTracker &&testTracker)
|
|
{
|
|
checkCount_++;
|
|
value_ = testTracker.value_;
|
|
}
|
|
|
|
RefBaseTestTracker &operator=(RefBaseTestTracker &&testTracker)
|
|
{
|
|
checkCount_++;
|
|
value_ = testTracker.value_;
|
|
return *this;
|
|
}
|
|
|
|
static RefBaseTestTracker *GetInstance()
|
|
{
|
|
static RefBaseTestTracker instance;
|
|
return &instance;
|
|
}
|
|
|
|
void InitTracker()
|
|
{
|
|
checkCount_ = 0;
|
|
freeCount_ = 0;
|
|
firstRefCount_ = 0;
|
|
lastRefCount_ = 0;
|
|
}
|
|
|
|
void TrackObject(IRemoteObject *object)
|
|
{
|
|
std::lock_guard<std::mutex> lockGuard(objectMutex_);
|
|
trackObjects_.emplace_back(object);
|
|
}
|
|
|
|
void TrackNewObject(IRemoteObject *object)
|
|
{
|
|
std::lock_guard<std::mutex> lockGuard(objectOnfirstMutex_);
|
|
RefBaseTestTracker::firstRefCount_++;
|
|
}
|
|
|
|
void UntrackObject(IRemoteObject *object)
|
|
{
|
|
std::lock_guard<std::mutex> lockGuard(objectMutex_);
|
|
auto iter = find(trackObjects_.begin(), trackObjects_.end(), object);
|
|
if (iter != trackObjects_.end()) {
|
|
trackObjects_.erase(iter);
|
|
}
|
|
}
|
|
|
|
void TrackFreeObject(IRemoteObject *object)
|
|
{
|
|
std::lock_guard<std::mutex> lockGuard(objectOnfreeMutex_);
|
|
RefBaseTestTracker::freeCount_++;
|
|
}
|
|
|
|
void PrintTrackResults()
|
|
{
|
|
std::lock_guard<std::mutex> lockGuard(objectMutex_);
|
|
if (!trackObjects_.empty()) {
|
|
for (auto o : trackObjects_) {
|
|
std::cout << "object: " << o <<"strong: " << o->GetSptrRefCount() << ", weak:" << o->GetWptrRefCount() << std::endl;
|
|
}
|
|
}
|
|
std::cout << "firstRefCount_: " << RefBaseTestTracker::firstRefCount_ << std::endl;
|
|
std::cout << "lastRefCount_: " << RefBaseTestTracker::lastRefCount_ << std::endl;
|
|
std::cout << "freeCount_: " << RefBaseTestTracker::freeCount_ << std::endl;
|
|
}
|
|
|
|
public:
|
|
int checkCount_ = 0;
|
|
int freeCount_ = 0;
|
|
int firstRefCount_ = 0;
|
|
int lastRefCount_ = 0;
|
|
|
|
private:
|
|
|
|
std::vector<IRemoteObject *> trackObjects_;
|
|
std::mutex objectMutex_;
|
|
std::mutex objectOnfirstMutex_;
|
|
std::mutex objectOnfreeMutex_;
|
|
int value_;
|
|
};
|
|
|
|
|
|
class IPCObjectProxy : public IRemoteObject
|
|
{
|
|
public:
|
|
bool IsProxyObject() override { return 0; }
|
|
string descriptor_;
|
|
IPCObjectProxy(const string &descriptor)
|
|
{
|
|
descriptor_ = descriptor;
|
|
RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance();
|
|
tracker->TrackObject(this);
|
|
tracker->TrackNewObject(this);
|
|
};
|
|
~IPCObjectProxy() {}
|
|
void RefPtrCallback() override;
|
|
void OnLastStrongRef(const void *objectId) override;
|
|
void OnFirstStrongRef(const void *objectId) override;
|
|
std::mutex mutexLast_;
|
|
};
|
|
|
|
class IPCProcessSkeleton : public virtual RefBase, public Singleton<IPCProcessSkeleton>
|
|
{
|
|
friend class Singleton<IPCProcessSkeleton>;
|
|
|
|
private:
|
|
IPCProcessSkeleton() = default;
|
|
|
|
public:
|
|
~IPCProcessSkeleton() override = default;
|
|
|
|
std::mutex mutex_;
|
|
std::map<string, wptr<IRemoteObject>> objects1_;
|
|
|
|
void DumpMapObjects()
|
|
{
|
|
if (!objects1_.empty()) {
|
|
for (auto &o : objects1_) {
|
|
std::cout << "strong: " << o.second->GetSptrRefCount() << "weak:" << o.second->GetWptrRefCount() << std::endl;
|
|
}
|
|
}
|
|
}
|
|
IRemoteObject *QueryObjectInner(const string &descriptor)
|
|
{
|
|
auto it = objects1_.find(descriptor);
|
|
if (it != objects1_.end())
|
|
{
|
|
it->second->AttemptAcquire(this);
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
|
return it->second.GetRefPtr();
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
IRemoteObject *FindOrNewObject(int handle)
|
|
{
|
|
std::lock_guard<std::mutex> lockGuard(mutex_);
|
|
IRemoteObject *remoteObject = QueryObjectInner(to_string(handle));
|
|
if (remoteObject != nullptr)
|
|
{
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
|
return remoteObject;
|
|
}
|
|
|
|
remoteObject = new IPCObjectProxy(to_string(handle));
|
|
remoteObject->AttemptAcquire(this);
|
|
objects1_.insert(std::pair<string, wptr<IRemoteObject>>(to_string(handle), remoteObject));
|
|
return remoteObject;
|
|
}
|
|
|
|
bool DetachObject(IRemoteObject *object, string descriptor)
|
|
{
|
|
std::lock_guard<std::mutex> lockGuard(mutex_);
|
|
if (object->GetSptrRefCount())
|
|
{
|
|
return false;
|
|
}
|
|
return (objects1_.erase(descriptor) > 0);
|
|
}
|
|
};
|
|
|
|
void IPCObjectProxy::OnLastStrongRef(const void *objectId)
|
|
{
|
|
std::lock_guard<std::mutex> lock(mutexLast_);
|
|
(void)IPCProcessSkeleton::GetInstance().DetachObject(this, descriptor_);
|
|
RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance();
|
|
tracker->lastRefCount_++;
|
|
std::this_thread::sleep_for(std::chrono::nanoseconds(10));
|
|
}
|
|
|
|
void IPCObjectProxy::OnFirstStrongRef(const void *objectId)
|
|
{
|
|
std::this_thread::sleep_for(std::chrono::nanoseconds(10));
|
|
}
|
|
|
|
void IPCObjectProxy::RefPtrCallback()
|
|
{
|
|
RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance();
|
|
tracker->UntrackObject(this);
|
|
tracker->TrackFreeObject(this);
|
|
RefBase::RefPtrCallback();
|
|
}
|
|
|
|
constexpr int CYCLE_NUM1 = 100;
|
|
constexpr int CYCLE_NUM2 = 100;
|
|
|
|
int RegisterEventThread()
|
|
{
|
|
auto &ipc = IPCProcessSkeleton::GetInstance();
|
|
int handle = 10;
|
|
for (int i = 0; i < CYCLE_NUM2; i++) {
|
|
sptr<IRemoteObject> remote = ipc.FindOrNewObject(handle);
|
|
if (remote) {
|
|
remote->IsProxyObject();
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testRefbaseOperateThreads001
|
|
* @tc.desc: Refbase for threads
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testRefbaseOperateThreads001, TestSize.Level0)
|
|
{
|
|
RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance();
|
|
tracker->InitTracker();
|
|
for (int n = 0; n < 1; n++) {
|
|
std::vector<std::future<int>> threads;
|
|
for (int i = 0; i < CYCLE_NUM1; i++) {
|
|
threads.emplace_back(std::async(RegisterEventThread));
|
|
}
|
|
|
|
for (auto &f : threads) {
|
|
f.get();
|
|
}
|
|
}
|
|
auto &ipc = IPCProcessSkeleton::GetInstance();
|
|
ipc.DumpMapObjects();
|
|
EXPECT_EQ(tracker->firstRefCount_, tracker->freeCount_);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testRefbaseOperateNull001
|
|
* @tc.desc: Refbase for null
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testRefbaseOperateNull001, TestSize.Level0)
|
|
{
|
|
RefBaseTestTracker *tracker = RefBaseTestTracker::GetInstance();
|
|
tracker->InitTracker();
|
|
|
|
auto remoteObject = new IPCObjectProxy("ss");
|
|
remoteObject->AttemptAcquire(this);
|
|
|
|
remoteObject->IncWeakRef(nullptr);
|
|
remoteObject->IncStrongRef(nullptr);
|
|
remoteObject->DecStrongRef(nullptr);
|
|
remoteObject->AttemptAcquire(this);
|
|
|
|
remoteObject->IncStrongRef(nullptr);
|
|
remoteObject->DecStrongRef(nullptr);
|
|
|
|
remoteObject->DecWeakRef(nullptr);
|
|
EXPECT_EQ(tracker->firstRefCount_, tracker->freeCount_);
|
|
}
|
|
|
|
class RefBaseMemTest : public RefBase {
|
|
public:
|
|
explicit RefBaseMemTest(int value): value_(value)
|
|
{
|
|
g_checkCount++;
|
|
}
|
|
|
|
~RefBaseMemTest()
|
|
{
|
|
g_checkCount--;
|
|
}
|
|
|
|
RefBaseMemTest(const RefBaseMemTest &testRefbaseMem)
|
|
{
|
|
g_checkCount++;
|
|
value_ = testRefbaseMem.value_;
|
|
}
|
|
|
|
RefBaseMemTest &operator=(const RefBaseMemTest &testRefbaseMem)
|
|
{
|
|
g_checkCount++;
|
|
value_ = testRefbaseMem.value_;
|
|
return *this;
|
|
}
|
|
|
|
RefBaseMemTest(RefBaseMemTest &&testRefbaseMem)
|
|
{
|
|
g_checkCount++;
|
|
value_ = testRefbaseMem.value_;
|
|
}
|
|
|
|
RefBaseMemTest &operator=(RefBaseMemTest &&testRefbaseMem)
|
|
{
|
|
g_checkCount++;
|
|
value_ = testRefbaseMem.value_;
|
|
return *this;
|
|
}
|
|
|
|
public:
|
|
static inline int g_checkCount = 0;
|
|
|
|
private:
|
|
int value_;
|
|
};
|
|
|
|
/*
|
|
* @tc.name: testRefbaseOperateLeftValue001
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testRefbaseOperateLeftValue001, TestSize.Level0)
|
|
{
|
|
RefBaseMemTest::g_checkCount = 0;
|
|
{
|
|
vector<RefBaseMemTest> refMemTestArray;
|
|
sptr<RefBaseMemTest>refMemTestObj1 = new RefBaseMemTest(1);
|
|
sptr<RefBaseMemTest>refMemTestObj2 = new RefBaseMemTest(2);
|
|
refMemTestArray.push_back(*refMemTestObj1);
|
|
refMemTestArray.push_back(*refMemTestObj2);
|
|
}
|
|
EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
|
|
|
|
{
|
|
vector<RefBaseMemTest> refMemTestArray;
|
|
RefBaseMemTest refMemTestObj1(1);
|
|
RefBaseMemTest refMemTestObj2(2);
|
|
refMemTestArray.push_back(refMemTestObj1);
|
|
refMemTestArray.push_back(refMemTestObj2);
|
|
}
|
|
EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testRefbaseOperateRightValue001
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testRefbaseOperateRightValue001, TestSize.Level0)
|
|
{
|
|
RefBaseMemTest::g_checkCount = 0;
|
|
{
|
|
vector<RefBaseMemTest> refMemTestArray;
|
|
sptr<RefBaseMemTest>refMemTestObj1 = new RefBaseMemTest(1);
|
|
sptr<RefBaseMemTest>refMemTestObj2 = new RefBaseMemTest(2);
|
|
refMemTestArray.emplace_back(*refMemTestObj1);
|
|
refMemTestArray.emplace_back(*refMemTestObj2);
|
|
}
|
|
EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
|
|
|
|
{
|
|
vector<RefBaseMemTest> refMemTestArray;
|
|
RefBaseMemTest refMemTestObj1(1);
|
|
RefBaseMemTest refMemTestObj2(2);
|
|
refMemTestArray.emplace_back(refMemTestObj1);
|
|
refMemTestArray.emplace_back(refMemTestObj2);
|
|
}
|
|
EXPECT_EQ(RefBaseMemTest::g_checkCount, 0);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testRefbaseAcquire001
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testRefbaseAcquire001, TestSize.Level0)
|
|
{
|
|
RefBaseTest* testobject = new RefBaseTest();
|
|
testobject->AttemptAcquire(this);
|
|
|
|
g_freeFlag = 0;
|
|
EXPECT_EQ(testobject->GetSptrRefCount(), 1);
|
|
{
|
|
EXPECT_TRUE(testobject->IsAttemptAcquireSet());
|
|
sptr<RefBaseTest> sptrRef = testobject;
|
|
EXPECT_EQ(sptrRef->GetSptrRefCount(), 1);
|
|
EXPECT_FALSE(testobject->IsAttemptAcquireSet());
|
|
}
|
|
|
|
EXPECT_EQ(g_freeFlag, 1);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testSptrefbase001
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testSptrefbase001, TestSize.Level0)
|
|
{
|
|
sptr<RefBaseTest> testobject = new RefBaseTest();
|
|
testobject->ExtendObjectLifetime();
|
|
EXPECT_TRUE(testobject->IsExtendLifeTimeSet());
|
|
EXPECT_EQ(g_refbaseflag, 1);
|
|
wptr<RefBaseTest> weakObject(testobject);
|
|
int count = testobject->GetWptrRefCount();
|
|
EXPECT_EQ(count, 2);
|
|
testobject = nullptr;
|
|
|
|
sptr<RefBaseTest> strongObject = weakObject.promote();
|
|
EXPECT_EQ(strongObject->GetSptrRefCount(), 1);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testSptrefbaseRealease001
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testSptrefbaseRealease001, TestSize.Level0)
|
|
{
|
|
sptr<RefBaseTest> testObject = new RefBaseTest();
|
|
EXPECT_EQ(g_refbaseflag, 1);
|
|
wptr<RefBaseTest> weakObject(testObject);
|
|
testObject = nullptr;
|
|
EXPECT_EQ(g_refbaseflag, FLAG_OF_DEST);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testSptrefbaseRealease002
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testSptrefbaseRealease002, TestSize.Level0)
|
|
{
|
|
wptr<RefBaseTest> testObject = new RefBaseTest();
|
|
EXPECT_EQ(g_refbaseflag, 1);
|
|
testObject = nullptr;
|
|
EXPECT_EQ(g_refbaseflag, FLAG_OF_DEST);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testSptrefbase002
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testSptrefbase002, TestSize.Level0)
|
|
{
|
|
{
|
|
sptr<RefBaseTest> testObject(new RefBaseTest());
|
|
EXPECT_EQ(g_refbaseflag, 1);
|
|
}
|
|
EXPECT_EQ(g_refbaseflag, 2);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testSptrefbase003
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testSptrefbase003, TestSize.Level0)
|
|
{
|
|
sptr<RefBaseTest> testObject1(new RefBaseTest());
|
|
sptr<RefBaseTest> testObject2 = testObject1.GetRefPtr();
|
|
testObject2->SetRefPtr();
|
|
EXPECT_TRUE(testObject1->GetTestRefPtrFlag());
|
|
|
|
sptr<RefBaseTest> testObject3(testObject1);
|
|
EXPECT_TRUE(testObject3->GetTestRefPtrFlag());
|
|
|
|
sptr<RefBaseTest> testObject4 = testObject1;
|
|
EXPECT_TRUE(testObject3->GetTestRefPtrFlag());
|
|
|
|
bool ret = (testObject3 == testObject4);
|
|
EXPECT_TRUE(ret);
|
|
|
|
int refcount = testObject1->GetSptrRefCount();
|
|
EXPECT_EQ(refcount, 4);
|
|
|
|
sptr<RefBaseTest> testObject5(new RefBaseTest());
|
|
ret = (testObject5 != testObject1);
|
|
EXPECT_TRUE(ret);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testSptrefbase004
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testSptrefbase004, TestSize.Level0)
|
|
{
|
|
sptr<RefBaseTest> testObject1(new RefBaseTest());
|
|
testObject1->SetRefPtr();
|
|
RefBaseTest testObject2 = *testObject1;
|
|
EXPECT_TRUE(testObject2.GetTestRefPtrFlag());
|
|
|
|
auto testObject3 = testObject1;
|
|
testObject1 = nullptr;
|
|
testObject3 = nullptr;
|
|
EXPECT_EQ(g_refbaseflag, 2);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testSptrefbase005
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testSptrefbase005, TestSize.Level0)
|
|
{
|
|
sptr<RefBaseTest> testObject1(new RefBaseTest());
|
|
wptr<RefBaseTest> testObject2 = testObject1;
|
|
EXPECT_EQ(testObject1->GetSptrRefCount(), 1);
|
|
EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testSptrefbase006
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testSptrefbase006, TestSize.Level0)
|
|
{
|
|
sptr<RefBaseTest> testObject1;
|
|
EXPECT_EQ(testObject1.GetRefPtr(), nullptr);
|
|
testObject1 = new RefBaseTest();
|
|
sptr<RefBaseTest> testObject2(testObject1);
|
|
EXPECT_EQ(testObject1->GetSptrRefCount(), 2);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testSptrefbase007
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testSptrefbase007, TestSize.Level0)
|
|
{
|
|
const sptr<RefBaseTest> &testObject1 = new RefBaseTest();
|
|
sptr<RefBaseTest> testObject2(testObject1);
|
|
EXPECT_EQ(testObject1->GetSptrRefCount(), 2);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testSptrefbase008
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testSptrefbase008, TestSize.Level0)
|
|
{
|
|
sptr<RefBaseTest> testObject1;
|
|
sptr<RefBaseTest> testObject2(testObject1);
|
|
EXPECT_EQ(testObject2, nullptr);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testSptrefbase009
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testSptrefbase009, TestSize.Level0)
|
|
{
|
|
sptr<RefBaseTest> testObject0 = new RefBaseTest();
|
|
sptr<RefBaseTest> testObject1 = move(testObject0);
|
|
sptr<RefBaseTest> testObject2(testObject1);
|
|
EXPECT_EQ(testObject0.GetRefPtr(), nullptr);
|
|
EXPECT_EQ(testObject2.GetRefPtr(), testObject1.GetRefPtr());
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testSptrefbase010
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testSptrefbase010, TestSize.Level0)
|
|
{
|
|
sptr<RefBaseTest> testObject1 = new RefBaseTest();
|
|
sptr<RefBaseTest> testObject3(new RefBaseTest());
|
|
sptr<RefBaseTest> &testObject2 = testObject3;
|
|
testObject2 = testObject1;
|
|
EXPECT_EQ(testObject2.GetRefPtr(), testObject1.GetRefPtr());
|
|
|
|
const sptr<RefBaseTest> &testObject4 = new RefBaseTest();
|
|
EXPECT_EQ(testObject1->GetSptrRefCount(), 2);
|
|
testObject2 = testObject4;
|
|
EXPECT_EQ(testObject2.GetRefPtr(), testObject4.GetRefPtr());
|
|
EXPECT_EQ(testObject4->GetSptrRefCount(), 2);
|
|
EXPECT_EQ(testObject1->GetSptrRefCount(), 1);
|
|
}
|
|
|
|
class SptrTest : public RefBase {
|
|
public:
|
|
SptrTest()
|
|
{
|
|
g_sptrCount++;
|
|
}
|
|
~SptrTest()
|
|
{
|
|
g_sptrCount--;
|
|
}
|
|
void CreateSptr()
|
|
{
|
|
test1 = new SptrTest();
|
|
}
|
|
|
|
private:
|
|
sptr<SptrTest> test1;
|
|
};
|
|
|
|
/*
|
|
* @tc.name: testRefbase005
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testRefbase005, TestSize.Level0)
|
|
{
|
|
{
|
|
sptr<SptrTest> testObject1(new SptrTest());
|
|
testObject1->CreateSptr();
|
|
}
|
|
EXPECT_EQ(g_sptrCount, 0);
|
|
}
|
|
|
|
class SptrTest1;
|
|
class SptrTest2;
|
|
class SptrTest2 : public RefBase {
|
|
public:
|
|
SptrTest2()
|
|
{
|
|
g_sptrCount++;
|
|
}
|
|
~SptrTest2()
|
|
{
|
|
g_sptrCount--;
|
|
}
|
|
|
|
private:
|
|
sptr<SptrTest1> test;
|
|
};
|
|
|
|
class SptrTest1 : public RefBase {
|
|
public:
|
|
SptrTest1()
|
|
{
|
|
g_sptrCount++;
|
|
}
|
|
~SptrTest1()
|
|
{
|
|
g_sptrCount--;
|
|
}
|
|
|
|
private:
|
|
sptr<SptrTest2> test;
|
|
};
|
|
|
|
/*
|
|
* @tc.name: testRefbase006
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testRefbase006, TestSize.Level0)
|
|
{
|
|
{
|
|
sptr<SptrTest1> testObject1(new SptrTest1());
|
|
sptr<SptrTest2> testObject2(new SptrTest2());
|
|
EXPECT_EQ(g_sptrCount, 2);
|
|
}
|
|
EXPECT_EQ(g_sptrCount, 0);
|
|
}
|
|
|
|
class WptrTest : public RefBase {
|
|
public:
|
|
WptrTest()
|
|
{
|
|
g_sptrCount++;
|
|
}
|
|
~WptrTest()
|
|
{
|
|
g_sptrCount--;
|
|
}
|
|
};
|
|
|
|
class WptrTest2 : public RefBase {
|
|
public:
|
|
WptrTest2()
|
|
{
|
|
g_sptrCount++;
|
|
flag_ = 0;
|
|
}
|
|
~WptrTest2()
|
|
{
|
|
g_sptrCount--;
|
|
}
|
|
|
|
private:
|
|
int flag_;
|
|
};
|
|
|
|
/*
|
|
* @tc.name: testWptrefbase001
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testWptrefbase001, TestSize.Level0)
|
|
{
|
|
wptr<WptrTest> testObject1(new WptrTest());
|
|
EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
|
|
|
|
wptr<WptrTest> testObject2 = testObject1;
|
|
EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
|
|
|
|
sptr<WptrTest> testObject3(new WptrTest());
|
|
wptr<WptrTest> testObject4(testObject3);
|
|
EXPECT_EQ(testObject3->GetSptrRefCount(), 1);
|
|
EXPECT_EQ(testObject4->GetWptrRefCount(), 2);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testWptrefbase002
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testWptrefbase002, TestSize.Level0)
|
|
{
|
|
wptr<WptrTest> testObject1(new WptrTest());
|
|
wptr<WptrTest> testObject2(testObject1);
|
|
EXPECT_EQ(testObject1.GetRefPtr(), testObject2.GetRefPtr());
|
|
|
|
wptr<WptrTest> testObject3;
|
|
EXPECT_EQ(testObject3.GetRefPtr(), nullptr);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testWptrefbase003
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testWptrefbase003, TestSize.Level0)
|
|
{
|
|
const wptr<WptrTest> &testObject1(new WptrTest());
|
|
wptr<WptrTest> testObject2(testObject1);
|
|
EXPECT_EQ(testObject1.GetRefPtr(), testObject2.GetRefPtr());
|
|
EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
|
|
EXPECT_EQ(testObject2->GetWptrRefCount(), 1);
|
|
EXPECT_EQ(testObject1.GetRefPtr(), testObject2.GetRefPtr());
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testWptrefbase004
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testWptrefbase004, TestSize.Level0)
|
|
{
|
|
const sptr<WptrTest2> &testObject1(new WptrTest2());
|
|
EXPECT_NE(testObject1, nullptr);
|
|
wptr<WptrTest> testObject2 = testObject1;
|
|
EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testWptrefbase005
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testWptrefbase005, TestSize.Level0)
|
|
{
|
|
wptr<WptrTest2> testObject1 = new WptrTest2();
|
|
wptr<WptrTest> testObject2(testObject1);
|
|
EXPECT_EQ(testObject1->GetWptrRefCount(), 1);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testWptrefbase006
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testWptrefbase006, TestSize.Level0)
|
|
{
|
|
wptr<WptrTest> testObject1 = new WptrTest();
|
|
wptr<WptrTest> &testObject2 = testObject1;
|
|
EXPECT_EQ(testObject2->GetWptrRefCount(), 1);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testWptrefbase007
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testWptrefbase007, TestSize.Level0)
|
|
{
|
|
wptr<WptrTest2> testObject1 = new WptrTest2();
|
|
wptr<WptrTest2> testObject2 = testObject1.GetRefPtr();
|
|
EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
|
|
}
|
|
|
|
/*
|
|
* @tc.name: testWptrefbase008
|
|
* @tc.desc: Refbase
|
|
*/
|
|
HWTEST_F(UtilsRefbaseTest, testWptrefbase008, TestSize.Level0)
|
|
{
|
|
wptr<WptrTest> testObject1 = new WptrTest();
|
|
wptr<WptrTest2> testObject2;
|
|
testObject2 = testObject1.GetRefPtr();
|
|
EXPECT_EQ(testObject1->GetWptrRefCount(), 2);
|
|
}
|