!537 IPC分支覆盖率提升

Merge pull request !537 from dengliang/master

ipc/native/test/unittest/common/BUILD.gn

@@ -39,6 +39,7 @@ ohos_unittest("IPCNativeUnitTest") {
     "ipc_object_proxy_unittest.cpp",
     "ipc_object_stub_unittest.cpp",
     "ipc_process_skeleton_unittest.cpp",
+    "ipc_skeleton_unittest.cpp",
     "ipc_thread_pool_unittest.cpp",
     "ipc_thread_skeleton_unittest.cpp",
     "iremote_object_unitest.cpp",

ipc/native/test/unittest/common/binder_invoker_unittest.cpp

@@ -566,3 +566,93 @@ HWTEST_F(BinderInvokerUnitTest, FlattenObjectTest001, TestSize.Level1)
     const IRemoteObject* object = nullptr;
     EXPECT_EQ(binderInvoker.FlattenObject(parcel, object), false);
 }
+
+#ifndef CONFIG_IPC_SINGLE
+/**
+ * @tc.name: TranslateIRemoteObjectTest001
+ * @tc.desc: Override TranslateIRemoteObject branch
+ * @tc.type: FUNC
+ */
+HWTEST_F(BinderInvokerUnitTest, TranslateIRemoteObjectTest001, TestSize.Level1)
+{
+    BinderInvoker binderInvoker;
+    int32_t cmd = 1;
+    sptr<IRemoteObject> testStub = new IPCObjectStub(u"testStub");
+    BinderConnector *binderConnector = BinderConnector::GetInstance();
+    binderConnector->driverFD_ = 1;
+    auto ret = binderInvoker.TranslateIRemoteObject(cmd, testStub);
+    EXPECT_EQ(ret, -IPC_INVOKER_TRANSLATE_ERR);
+}
+
+/**
+ * @tc.name: TranslateIRemoteObjectTest002
+ * @tc.desc: Override TranslateIRemoteObject branch
+ * @tc.type: FUNC
+ */
+HWTEST_F(BinderInvokerUnitTest, TranslateIRemoteObjectTest002, TestSize.Level1)
+{
+    BinderInvoker binderInvoker;
+    int32_t cmd = 1;
+    binderInvoker.binderConnector_ = nullptr;
+    sptr<IRemoteObject> testStub = new IPCObjectStub(u"testStub");
+    auto ret = binderInvoker.TranslateIRemoteObject(cmd, testStub);
+    EXPECT_EQ(ret, -IPC_INVOKER_CONNECT_ERR);
+}
+
+/**
+ * @tc.name: TranslateIRemoteObjectTest003
+ * @tc.desc: Override TranslateIRemoteObject branch
+ * @tc.type: FUNC
+ */
+HWTEST_F(BinderInvokerUnitTest, TranslateIRemoteObjectTest003, TestSize.Level1)
+{
+    BinderInvoker binderInvoker;
+    int32_t cmd = 1;
+    BinderConnector *binderConnector = BinderConnector::GetInstance();
+    binderConnector->driverFD_ = -1;
+    sptr<IRemoteObject> testStub = new IPCObjectStub(u"testStub");
+    auto ret = binderInvoker.TranslateIRemoteObject(cmd, testStub);
+    EXPECT_EQ(ret, -IPC_INVOKER_CONNECT_ERR);
+}
+#endif
+
+/**
+ * @tc.name: GetSelfTokenIDTest002
+ * @tc.desc: Override GetSelfTokenID branch
+ * @tc.type: FUNC
+ */
+HWTEST_F(BinderInvokerUnitTest, GetSelfTokenIDTest002, TestSize.Level1)
+{
+    BinderInvoker binderInvoker;
+    binderInvoker.binderConnector_ = nullptr;
+    auto ret = binderInvoker.GetSelfTokenID();
+    EXPECT_EQ(ret, 0);
+}
+
+/**
+ * @tc.name: GetSelfTokenIDTest003
+ * @tc.desc: Override GetSelfTokenID branch
+ * @tc.type: FUNC
+ */
+HWTEST_F(BinderInvokerUnitTest, GetSelfTokenIDTest003, TestSize.Level1)
+{
+    BinderInvoker binderInvoker;
+    BinderConnector *binderConnector = BinderConnector::GetInstance();
+    binderConnector->driverFD_ = -1;
+    auto ret = binderInvoker.GetSelfTokenID();
+    EXPECT_EQ(ret, 0);
+}
+
+/**
+ * @tc.name: GetCallerTokenIDTest003
+ * @tc.desc: Override GetCallerTokenID branch
+ * @tc.type: FUNC
+ */
+HWTEST_F(BinderInvokerUnitTest, GetCallerTokenIDTest003, TestSize.Level1)
+{
+    BinderInvoker binderInvoker;
+    binderInvoker.callerTokenID_ = 0;
+    binderInvoker.callerUid_ = 1;
+    auto ret = binderInvoker.GetCallerTokenID();
+    EXPECT_EQ(ret, 1);
+}
\ No newline at end of file

ipc/native/test/unittest/common/ipc_connector_unittest.cpp

@@ -73,3 +73,42 @@ HWTEST_F(BinderConnectorTest, ExitCurrentThread001, TestSize.Level1)
     binderConnector->ExitCurrentThread(BINDER_THREAD_EXIT);
     EXPECT_TRUE(binderConnector->driverFD_ > 0);
 }
+
+/**
+ * @tc.name: IsAccessTokenSupported001
+ * @tc.desc: Verify the IsAccessTokenSupported function
+ * @tc.type: FUNC
+ */
+HWTEST_F(BinderConnectorTest, IsAccessTokenSupported001, TestSize.Level1)
+{
+    BinderConnector* binderConnector = BinderConnector::GetInstance();
+    binderConnector->driverFD_ = -1;
+    auto ret = binderConnector->IsAccessTokenSupported();
+    ASSERT_TRUE(!ret);
+}
+
+/**
+ * @tc.name: GetSelfTokenID001
+ * @tc.desc: Verify the GetSelfTokenID function
+ * @tc.type: FUNC
+ */
+HWTEST_F(BinderConnectorTest, GetSelfTokenID001, TestSize.Level1)
+{
+    BinderConnector* binderConnector = BinderConnector::GetInstance();
+    binderConnector->driverFD_ = -1;
+    auto ret = binderConnector->GetSelfTokenID();
+    ASSERT_TRUE(ret == 0);
+}
+
+/**
+ * @tc.name: GetSelfFirstCallerTokenID001
+ * @tc.desc: Verify the GetSelfFirstCallerTokenID function
+ * @tc.type: FUNC
+ */
+HWTEST_F(BinderConnectorTest, GetSelfFirstCallerTokenID001, TestSize.Level1)
+{
+    BinderConnector* binderConnector = BinderConnector::GetInstance();
+    binderConnector->driverFD_ = -1;
+    auto ret = binderConnector->GetSelfFirstCallerTokenID();
+    ASSERT_TRUE(ret == 0);
+}

ipc/native/test/unittest/common/ipc_object_proxy_unittest.cpp

@@ -23,6 +23,7 @@
 #include "ipc_thread_skeleton.h"
 #include "ipc_types.h"
 #include "iremote_object.h"
+#include "mock_iremote_invoker.h"
 #include "mock_iremote_object.h"
 #include "mock_session_impl.h"
 #undef private
@@ -52,6 +53,8 @@ void IPCObjectProxyTest::SetUp()
 
 void IPCObjectProxyTest::TearDown()
 {
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_.clear();
 }
 
 /**
@@ -67,6 +70,53 @@ HWTEST_F(IPCObjectProxyTest, GetSessionNameTest001, TestSize.Level1)
     ASSERT_TRUE(ret.size() != 0);
 }
 
+/**
+ * @tc.name: SendRequestTest001
+ * @tc.desc: Verify the IPCObjectProxy::SendRequest function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCObjectProxyTest, SendRequestTest001, TestSize.Level1)
+{
+    IPCObjectProxy object(1);
+    uint32_t code = MAX_TRANSACTION_ID + 1;
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+
+    auto ret = object.SendRequest(code, data, reply, option);
+    ASSERT_TRUE(ret == IPC_PROXY_INVALID_CODE_ERR);
+}
+
+/**
+ * @tc.name: SendRequestInnerTest001
+ * @tc.desc: Verify the IPCObjectProxy::SendRequestInner function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCObjectProxyTest, SendRequestInnerTest001, TestSize.Level1)
+{
+    IPCObjectProxy object(1);
+    bool isLocal = true;
+    uint32_t code = MAX_TRANSACTION_ID + 1;
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    EXPECT_CALL(*invoker, SendRequest(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillRepeatedly(testing::Return(ERR_DEAD_OBJECT));
+
+    auto ret = object.SendRequestInner(isLocal, code, data, reply, option);
+    ASSERT_TRUE(ret == ERR_DEAD_OBJECT);
+    current->invokers_.clear();
+    delete invoker;
+}
+
 /**
  * @tc.name: GetGrantedSessionNameTest001
  * @tc.desc: Verify the IPCObjectProxy::GetGrantedSessionName function
@@ -93,6 +143,19 @@ HWTEST_F(IPCObjectProxyTest, GetSessionNameForPidUidTest001, TestSize.Level1)
     ASSERT_TRUE(ret.size() == 0);
 }
 
+/**
+ * @tc.name: GetPidUidTest001
+ * @tc.desc: Verify the IPCObjectProxy::GetPidUid function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCObjectProxyTest, GetPidUidTest001, TestSize.Level1)
+{
+    IPCObjectProxy object(1);
+    MessageParcel reply;
+    auto ret = object.GetPidUid(reply);
+    ASSERT_TRUE(ret == 0);
+}
+
 /**
  * @tc.name: GetInterfaceDescriptorTest001
  * @tc.desc: Verify the IPCObjectProxy::GetInterfaceDescriptor function
@@ -158,6 +221,69 @@ HWTEST_F(IPCObjectProxyTest, GetInterfaceDescriptorTest004, TestSize.Level1)
     ASSERT_TRUE(ret.size() != 0);
 }
 
+/**
+ * @tc.name: GetInterfaceDescriptorTest005
+ * @tc.desc: Verify the IPCObjectProxy::GetInterfaceDescriptor function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCObjectProxyTest, GetInterfaceDescriptorTest005, TestSize.Level1)
+{
+    IPCObjectProxy object(1);
+    object.proto_ = IRemoteObject::IF_PROT_BINDER;
+    object.remoteDescriptor_ = u"";
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    EXPECT_CALL(*invoker, SendRequest(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillRepeatedly(testing::Return(ERR_DEAD_OBJECT));
+
+    auto ret = object.GetInterfaceDescriptor();
+    ASSERT_TRUE(ret.size() == 0);
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: GetInterfaceDescriptorTest006
+ * @tc.desc: Verify the IPCObjectProxy::GetInterfaceDescriptor function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCObjectProxyTest, GetInterfaceDescriptorTest006, TestSize.Level1)
+{
+    IPCObjectProxy object(1);
+    object.proto_ = IRemoteObject::IF_PROT_BINDER;
+    object.remoteDescriptor_ = u"";
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    EXPECT_CALL(*invoker, SendRequest(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillRepeatedly(testing::Return(ERR_DEAD_OBJECT));
+
+    auto ret = object.GetInterfaceDescriptor();
+    ASSERT_TRUE(ret.size() == 0);
+    current->invokers_.clear();
+    delete invoker;
+}
+
+int SendRequestMock(int handle, uint32_t code, MessageParcel &data, MessageParcel &reply,
+    MessageOption &option)
+{
+    reply.WriteUint32(IRemoteObject::IF_PROT_DEFAULT);
+    return ERR_NONE;
+}
+
 /**
  * @tc.name: GetSessionNameTest002
  * @tc.desc: Verify the IPCObjectProxy::GetSessionName function
@@ -188,7 +314,7 @@ HWTEST_F(IPCObjectProxyTest, GetGrantedSessionNameTest002, TestSize.Level1)
 
 /**
  * @tc.name: GetSessionNameForPidUidTest002
- * @tc.desc: Verify the IPCObjectProxy::GetSessionNameForPidUidTest function
+ * @tc.desc: Verify the IPCObjectProxy::GetSessionNameForPidUid function
  * @tc.type: FUNC
  */
 HWTEST_F(IPCObjectProxyTest, GetSessionNameForPidUidTest002, TestSize.Level1)
@@ -213,6 +339,110 @@ HWTEST_F(IPCObjectProxyTest, GetSessionNameForPidUidTest003, TestSize.Level1)
     ASSERT_TRUE(ret.size() == 0);
 }
 
+/**
+ * @tc.name: GetGrantedSessionNameTest003
+ * @tc.desc: Verify the IPCObjectProxy::GetGrantedSessionName function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCObjectProxyTest, GetGrantedSessionNameTest003, TestSize.Level1)
+{
+    IPCObjectProxy object(1);
+    object.proto_ = IRemoteObject::IF_PROT_BINDER;
+    object.remoteDescriptor_ = u"";
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    EXPECT_CALL(*invoker, SendRequest(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillRepeatedly(testing::Invoke(SendRequestMock));
+
+    auto ret = object.GetSessionNameForPidUid(1, 1);
+    ASSERT_TRUE(ret.size() == 0);
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: GetSessionNameForPidUidTest004
+ * @tc.desc: Verify the IPCObjectProxy::GetSessionNameForPidUidTest004 function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCObjectProxyTest, GetSessionNameForPidUidTest004, TestSize.Level1)
+{
+    IPCObjectProxy object(1);
+    object.proto_ = IRemoteObject::IF_PROT_BINDER;
+    object.remoteDescriptor_ = u"";
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    EXPECT_CALL(*invoker, SendRequest(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillRepeatedly(testing::Invoke(SendRequestMock));
+
+    auto ret = object.GetSessionNameForPidUid(1, 1);
+    ASSERT_TRUE(ret.size() == 0);
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: GetSessionNameForPidUidTest005
+ * @tc.desc: Verify the IPCObjectProxy::GetSessionNameForPidUid function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCObjectProxyTest, GetSessionNameForPidUidTest005, TestSize.Level1)
+{
+    IPCObjectProxy object(1);
+    object.proto_ = IRemoteObject::IF_PROT_BINDER;
+    object.remoteDescriptor_ = u"";
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    EXPECT_CALL(*invoker, SendRequest(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillRepeatedly(testing::Invoke(SendRequestMock));
+
+    auto ret = object.GetSessionNameForPidUid(1, 1);
+    ASSERT_TRUE(ret.size() == 0);
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: OnFirstStrongRefTest005
+ * @tc.desc: Verify the IPCObjectProxy::OnFirstStrongRef function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCObjectProxyTest, OnFirstStrongRefTest005, TestSize.Level1)
+{
+    IPCObjectProxy object(1);
+    object.proto_ = IRemoteObject::IF_PROT_BINDER;
+    object.remoteDescriptor_ = u"";
+
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = nullptr;
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = nullptr;
+
+    object.OnFirstStrongRef(nullptr);
+    ASSERT_TRUE(object.handle_ == 1);
+    current->invokers_.clear();
+}
+
 /**
  * @tc.name: WaitForInitTest001
  * @tc.desc: Verify the IPCObjectProxy::WaitForInit function
@@ -532,6 +762,42 @@ HWTEST_F(IPCObjectProxyTest, GetProtoInfoTest002, TestSize.Level1)
     EXPECT_EQ(ret, IRemoteObject::IF_PROT_ERROR);
 }
 
+
+int SendRequestPortMock(int handle, uint32_t code, MessageParcel &data, MessageParcel &reply,
+    MessageOption &option)
+{
+    reply.WriteUint32(IRemoteObject::IF_PROT_DATABUS);
+    return ERR_NONE;
+}
+
+/**
+ * @tc.name: GetProtoInfoTest003
+ * @tc.desc: Verify the IPCObjectProxy::GetProtoInfo function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCObjectProxyTest, GetProtoInfoTest003, TestSize.Level1)
+{
+    IPCObjectProxy object(1);
+    object.proto_ = IRemoteObject::IF_PROT_BINDER;
+    object.remoteDescriptor_ = u"test";
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    EXPECT_CALL(*invoker, SendRequest(testing::_, testing::_, testing::_, testing::_, testing::_))
+        .WillRepeatedly(testing::Invoke(SendRequestPortMock));
+
+    auto ret = object.GetProtoInfo();
+    ASSERT_TRUE(ret != IRemoteObject::IF_PROT_DATABUS);
+    current->invokers_.clear();
+    delete invoker;
+}
+
 /**
  * @tc.name: AddDbinderDeathRecipientTest001
  * @tc.desc: Verify the IPCObjectProxy::AddDbinderDeathRecipient function
@@ -932,6 +1198,48 @@ HWTEST_F(IPCObjectProxyTest, UpdateDatabusClientSessionTest008, TestSize.Level1)
     ASSERT_TRUE(ret == false);
 }
 
+/**
+ * @tc.name: UpdateDatabusClientSessionTest009
+ * @tc.desc: Verify the IPCObjectProxy::UpdateDatabusClientSessionTest009 function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCObjectProxyTest, UpdateDatabusClientSessionTest009, TestSize.Level1)
+{
+    sptr<IPCObjectProxy> object = new IPCObjectProxy(
+        1, u"test", IPCProcessSkeleton::DBINDER_HANDLE_BASE);
+    object->isRemoteDead_ = false;
+    object->proto_ = IRemoteObject::IF_PROT_DEFAULT;
+
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_.clear();
+
+    MessageParcel reply;
+    uint64_t stubIndex = 1;
+    reply.ReadUint64(stubIndex);
+    std::string serviceName =  "testserviceName";
+    reply.WriteString(serviceName);
+    std::string peerID =  "testpeerID";
+    reply.WriteString(peerID);
+    std::string localID =  "testlocalID";
+    reply.WriteString(localID);
+    std::string localBusName =  "testlocalBusName";
+    reply.WriteString(localBusName);
+    uint32_t rpcFeatureSet = 1;
+    reply.WriteUint32(rpcFeatureSet);
+
+    IPCProcessSkeleton *processCurrent = IPCProcessSkeleton::GetCurrent();
+    std::shared_ptr<MockSessionImpl> sessionMock = std::make_shared<MockSessionImpl>();
+    auto dbinderSessionObject = std::make_shared<DBinderSessionObject>(
+        sessionMock, serviceName, peerID, 1, object.GetRefPtr(), 1);
+    processCurrent->proxyToSession_[0] = dbinderSessionObject;
+
+    auto ret = object->UpdateDatabusClientSession(1, reply);
+
+    ASSERT_TRUE(ret == false);
+    processCurrent->proxyToSession_.clear();
+    dbinderSessionObject->proxy_ = nullptr;
+}
+
 /**
  * @tc.name: ReleaseDatabusProtoTest001
  * @tc.desc: Verify the IPCObjectProxy::ReleaseDatabusProto function

ipc/native/test/unittest/common/ipc_object_stub_unittest.cpp

@@ -1009,4 +1009,30 @@ HWTEST_F(IPCObjectStubTest, CreateSessionNameTest002, TestSize.Level1)
     auto ret = testStub->CreateSessionName(uid, pid);
     ASSERT_TRUE(ret.size() == 0);
 }
-#endif
\ No newline at end of file
+#endif
+
+/**
+ * @tc.name: GetCallingTokenIDTest001
+ * @tc.desc: Verify the GetCallingTokenID function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCObjectStubTest, GetCallingTokenIDTest001, TestSize.Level1)
+{
+    sptr<IPCObjectStub> testStub = new IPCObjectStub(u"testStub");
+
+    auto ret = testStub->GetCallingTokenID();
+    EXPECT_EQ(ret, 0);
+}
+
+/**
+ * @tc.name: GetCallingFullTokenIDTest001
+ * @tc.desc: Verify the GetCallingFullTokenID function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCObjectStubTest, GetCallingFullTokenIDTest001, TestSize.Level1)
+{
+    sptr<IPCObjectStub> testStub = new IPCObjectStub(u"testStub");
+
+    auto ret = testStub->GetCallingFullTokenID();
+    EXPECT_EQ(ret, 0);
+}
\ No newline at end of file

ipc/native/test/unittest/common/ipc_skeleton_unittest.cpp

+/*
+ * Copyright (C) 2022 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 <gmock/gmock.h>
+
+#define private public
+#define protected public
+#include "comm_auth_info.h"
+#include "databus_session_callback.h"
+#include "dbinder_databus_invoker.h"
+#include "dbinder_session_object.h"
+#include "binder_invoker.h"
+#include "ipc_debug.h"
+#include "ipc_skeleton.h"
+#include "ipc_object_proxy.h"
+#include "ipc_object_stub.h"
+#include "ipc_process_skeleton.h"
+#include "ipc_thread_skeleton.h"
+#include "dbinder_session_object.h"
+#include "message_option.h"
+#include "mock_session_impl.h"
+#include "mock_iremote_invoker.h"
+#undef protected
+#undef private
+
+using namespace testing::ext;
+using namespace OHOS;
+
+class IPCSkeletonTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+};
+
+void IPCSkeletonTest::SetUpTestCase()
+{
+}
+
+void IPCSkeletonTest::TearDownTestCase()
+{
+}
+
+void IPCSkeletonTest::SetUp()
+{
+}
+
+void IPCSkeletonTest::TearDown()
+{
+}
+
+/**
+ * @tc.name: JoinWorkThreadTest001
+ * @tc.desc: Verify the JoinWorkThread function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, JoinWorkThreadTest001, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    skeleton.JoinWorkThread();
+    ASSERT_TRUE(IPCThreadSkeleton::GetCurrent() != nullptr);
+    delete invoker;
+    current->invokers_.clear();
+}
+
+/**
+ * @tc.name: StopWorkThreadTest001
+ * @tc.desc: Verify the StopWorkThread function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, StopWorkThreadTest001, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    skeleton.StopWorkThread();
+    ASSERT_TRUE(IPCThreadSkeleton::GetCurrent() != nullptr);
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: GetCallingTokenIDTest001
+ * @tc.desc: Verify the GetCallingTokenID function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, GetCallingTokenIDTest001, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    EXPECT_CALL(*invoker, GetCallerTokenID())
+        .WillRepeatedly(testing::Return(1));
+
+    auto result = skeleton.GetCallingTokenID();
+    EXPECT_EQ(result, 1);
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: GetCallingFullTokenIDTest001
+ * @tc.desc: Verify the GetCallingFullTokenID function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, GetCallingFullTokenIDTest001, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    EXPECT_CALL(*invoker, GetCallerTokenID())
+        .WillRepeatedly(testing::Return(1));
+    EXPECT_CALL(*invoker, GetSelfTokenID())
+        .WillRepeatedly(testing::Return(1));
+
+    auto result = skeleton.GetCallingFullTokenID();
+    EXPECT_EQ(result, 1);
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: GetFirstTokenIDTest001
+ * @tc.desc: Verify the GetFirstTokenID function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, GetFirstTokenIDTest001, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = nullptr;
+    current->invokers_[IRemoteObject::IF_PROT_DATABUS] = nullptr;
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = nullptr;
+
+    auto result = skeleton.GetFirstTokenID();
+    EXPECT_EQ(result, 0);
+    current->invokers_.clear();
+}
+
+/**
+ * @tc.name: GetFirstFullTokenIDTest001
+ * @tc.desc: Verify the GetFirstFullTokenID function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, GetFirstFullTokenIDTest001, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = nullptr;
+    current->invokers_[IRemoteObject::IF_PROT_DATABUS] = nullptr;
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = nullptr;
+
+    auto result = skeleton.GetFirstFullTokenID();
+    EXPECT_EQ(result, 0);
+    current->invokers_.clear();
+}
+
+/**
+ * @tc.name: GetFirstFullTokenIDTest002
+ * @tc.desc: Verify the GetFirstFullTokenID function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, GetFirstFullTokenIDTest002, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    EXPECT_CALL(*invoker, GetCallerTokenID())
+        .WillRepeatedly(testing::Return(1));
+    EXPECT_CALL(*invoker, GetFirstCallerTokenID())
+        .WillRepeatedly(testing::Return(1));
+
+    auto result = skeleton.GetFirstFullTokenID();
+    EXPECT_EQ(result, 1);
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: GetFirstFullTokenIDTest003
+ * @tc.desc: Verify the GetFirstFullTokenID function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, GetFirstFullTokenIDTest003, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = nullptr;
+    current->invokers_[IRemoteObject::IF_PROT_DATABUS] = nullptr;
+
+    current->invokers_[IRemoteObject::IF_PROT_DEFAULT] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::IDLE_INVOKER));
+
+    EXPECT_CALL(*invoker, GetFirstCallerTokenID())
+        .WillRepeatedly(testing::Return(123));
+
+    EXPECT_CALL(*invoker, GetSelfFirstCallerTokenID())
+        .WillRepeatedly(testing::Return(111));
+
+    auto result = skeleton.GetFirstFullTokenID();
+    EXPECT_EQ(result, 111);
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: GetLocalDeviceIDTest001
+ * @tc.desc: Verify the GetLocalDeviceID function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, GetLocalDeviceIDTest001, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+
+    std::string testID = "testID";
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    EXPECT_CALL(*invoker, GetLocalDeviceID())
+        .WillRepeatedly(testing::Return(testID));
+
+    auto result = skeleton.GetLocalDeviceID();
+    EXPECT_STREQ(result.c_str(), testID.c_str());
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: GetCallingDeviceIDTest001
+ * @tc.desc: Verify the GetCallingDeviceID function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, GetCallingDeviceIDTest001, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+
+    std::string testDeviceID = "testDeviceID";
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    EXPECT_CALL(*invoker, GetCallerDeviceID())
+        .WillRepeatedly(testing::Return(testDeviceID));
+
+    auto result = skeleton.GetCallingDeviceID();
+    EXPECT_STREQ(result.c_str(), testDeviceID.c_str());
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: IsLocalCallingTest001
+ * @tc.desc: Verify the IsLocalCalling function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, IsLocalCallingTest001, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+
+    std::string testDeviceID = "testDeviceID";
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    EXPECT_CALL(*invoker, IsLocalCalling())
+        .WillRepeatedly(testing::Return(false));
+
+    auto result = skeleton.IsLocalCalling();
+    ASSERT_TRUE(!result);
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: FlushCommandsTest001
+ * @tc.desc: Verify the FlushCommands function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, FlushCommandsTest001, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+
+    std::string testDeviceID = "testDeviceID";
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    EXPECT_CALL(*invoker, FlushCommands(testing::_))
+        .WillRepeatedly(testing::Return(111));
+
+    IPCObjectProxy *object = new IPCObjectProxy(
+        1, u"test", IPCProcessSkeleton::DBINDER_HANDLE_BASE);
+    object->proto_ = IRemoteObject::IF_PROT_BINDER;
+
+    auto result = skeleton.FlushCommands(object);
+    EXPECT_EQ(result, 111);
+    current->invokers_.clear();
+    delete invoker;
+    delete object;
+}
+
+/**
+ * @tc.name: ResetCallingIdentityTest001
+ * @tc.desc: Verify the ResetCallingIdentity function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, ResetCallingIdentityTest001, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    std::string testStr = "testStr";
+    EXPECT_CALL(*invoker, ResetCallingIdentity())
+        .WillRepeatedly(testing::Return(testStr));
+
+    auto result = skeleton.ResetCallingIdentity();
+    EXPECT_STREQ(result.c_str(), testStr.c_str());
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: ResetCallingIdentityTest002
+ * @tc.desc: Verify the ResetCallingIdentity function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, ResetCallingIdentityTest002, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::IDLE_INVOKER));
+
+    std::string testStr = "";
+
+    auto result = skeleton.ResetCallingIdentity();
+    EXPECT_STREQ(result.c_str(), testStr.c_str());
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: SetCallingIdentityTest001
+ * @tc.desc: Verify the SetCallingIdentity function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, SetCallingIdentityTest001, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::ACTIVE_INVOKER));
+
+    std::string testStr = "testStr";
+    EXPECT_CALL(*invoker, SetCallingIdentity(testStr))
+        .WillRepeatedly(testing::Return(false));
+
+    auto result = skeleton.SetCallingIdentity(testStr);
+    ASSERT_TRUE(!result);
+    current->invokers_.clear();
+    delete invoker;
+}
+
+/**
+ * @tc.name: SetCallingIdentityTest002
+ * @tc.desc: Verify the SetCallingIdentity function
+ * @tc.type: FUNC
+ */
+HWTEST_F(IPCSkeletonTest, SetCallingIdentityTest002, TestSize.Level1)
+{
+    IPCSkeleton skeleton = IPCSkeleton::GetInstance();
+
+    MockIRemoteInvoker *invoker = new MockIRemoteInvoker();
+    IPCThreadSkeleton *current = IPCThreadSkeleton::GetCurrent();
+    current->invokers_[IRemoteObject::IF_PROT_BINDER] = invoker;
+
+    EXPECT_CALL(*invoker, GetStatus())
+        .WillRepeatedly(testing::Return(IRemoteInvoker::IDLE_INVOKER));
+
+    std::string testStr = "";
+
+    auto result = skeleton.SetCallingIdentity(testStr);
+    ASSERT_TRUE(result);
+    current->invokers_.clear();
+    delete invoker;
+}
\ No newline at end of file