1 /*
2  * Copyright (C) 2023 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 
16 #include <gtest/gtest.h>
17 #include <gmock/gmock.h>
18 
19 #define private public
20 #include "process_skeleton.h"
21 #include "ipc_types.h"
22 #include "iremote_object.h"
23 #include "ipc_object_stub.h"
24 #undef private
25 
26 using namespace testing::ext;
27 using namespace OHOS;
28 
29 class ProcessSkeletonUnitTest : public testing::Test {
30 public:
31     static void SetUpTestCase(void);
32     static void TearDownTestCase(void);
33     void SetUp();
34     void TearDown();
35 };
36 
SetUpTestCase()37 void ProcessSkeletonUnitTest::SetUpTestCase()
38 {
39 }
40 
TearDownTestCase()41 void ProcessSkeletonUnitTest::TearDownTestCase()
42 {
43 }
44 
SetUp()45 void ProcessSkeletonUnitTest::SetUp() {}
46 
TearDown()47 void ProcessSkeletonUnitTest::TearDown() {}
48 
49 /**
50  * @tc.name: IsContainsObjectTest001
51  * @tc.desc: Verify the IsContainsObject function
52  * @tc.type: FUNC
53  */
54 HWTEST_F(ProcessSkeletonUnitTest, IsContainsObjectTest001, TestSize.Level1)
55 {
56     ProcessSkeleton *skeleton = ProcessSkeleton::GetInstance();
57     ASSERT_TRUE(skeleton != nullptr);
58 
59     sptr<IRemoteObject> object = new IPCObjectStub(u"testObject");
60     skeleton->isContainStub_.clear();
61     bool ret = skeleton->IsContainsObject(object.GetRefPtr());
62     EXPECT_EQ(ret, false);
63 }
64 
65 /**
66  * @tc.name: DetachObjectTest001
67  * @tc.desc: Verify the DetachObject function
68  * @tc.type: FUNC
69  */
70 HWTEST_F(ProcessSkeletonUnitTest, DetachObjectTest001, TestSize.Level1)
71 {
72     ProcessSkeleton *skeleton = ProcessSkeleton::GetInstance();
73     ASSERT_TRUE(skeleton != nullptr);
74 
75     sptr<IRemoteObject> object = new IPCObjectStub(u"testObject");
76     ASSERT_TRUE(object != nullptr);
77 
78     skeleton->AttachObject(object.GetRefPtr(), object->GetObjectDescriptor(), true);
79     bool ret = skeleton->DetachObject(object.GetRefPtr(), object->GetObjectDescriptor());
80     EXPECT_EQ(ret, true);
81 }
82 
83 /**
84  * @tc.name: QueryObjectTest001
85  * @tc.desc: Verify the QueryObject function
86  * @tc.type: FUNC
87  */
88 HWTEST_F(ProcessSkeletonUnitTest, QueryObjectTest001, TestSize.Level1)
89 {
90     ProcessSkeleton *skeleton = ProcessSkeleton::GetInstance();
91     ASSERT_TRUE(skeleton != nullptr);
92 
93     sptr<IRemoteObject> object = new IPCObjectStub(u"testObject");
94     ASSERT_TRUE(object != nullptr);
95     skeleton->AttachObject(object.GetRefPtr(), object->GetObjectDescriptor(), true);
96     sptr<IRemoteObject> queriedObject = skeleton->QueryObject(object->GetObjectDescriptor(), true);
97     EXPECT_EQ(queriedObject.GetRefPtr(), object.GetRefPtr());
98 }
99 
100 /**
101  * @tc.name: AttachValidObjectTest001
102  * @tc.desc: Verify the AttachValidObject function
103  * @tc.type: FUNC
104  */
105 HWTEST_F(ProcessSkeletonUnitTest, AttachValidObjectTest001, TestSize.Level1)
106 {
107     ProcessSkeleton *skeleton = ProcessSkeleton::GetInstance();
108     ASSERT_TRUE(skeleton != nullptr);
109 
110     std::u16string str(u"testObject");
111     sptr<IRemoteObject> object = new IPCObjectStub(str);
112     ASSERT_TRUE(object != nullptr);
113     bool ret = skeleton->AttachValidObject(object.GetRefPtr(), str);
114     EXPECT_EQ(ret, false);
115 }
116 
117 /**
118  * @tc.name: DetachValidObjectTest001
119  * @tc.desc: Verify the DetachValidObject function
120  * @tc.type: FUNC
121  */
122 HWTEST_F(ProcessSkeletonUnitTest, DetachValidObjectTest001, TestSize.Level1)
123 {
124     ProcessSkeleton *skeleton = ProcessSkeleton::GetInstance();
125     ASSERT_TRUE(skeleton != nullptr);
126 
127     std::u16string str(u"testObject");
128     sptr<IRemoteObject> object = new IPCObjectStub(str);
129     skeleton->AttachValidObject(object.GetRefPtr(), str);
130     bool ret = skeleton->DetachValidObject(object.GetRefPtr());
131     EXPECT_EQ(ret, true);
132 }
133 
134 /**
135  * @tc.name: IsValidObjectTest001
136  * @tc.desc: Verify the IsValidObject function
137  * @tc.type: FUNC
138  */
139 HWTEST_F(ProcessSkeletonUnitTest, IsValidObjectTest001, TestSize.Level1)
140 {
141     ProcessSkeleton *skeleton = ProcessSkeleton::GetInstance();
142     ASSERT_TRUE(skeleton != nullptr);
143 
144     std::u16string str(u"testObject");
145     sptr<IRemoteObject> object = new IPCObjectStub(str);
146     skeleton->AttachValidObject(object.GetRefPtr(), str);
147     std::u16string desc;
148     bool ret = skeleton->IsValidObject(object.GetRefPtr(), desc);
149     EXPECT_EQ(ret, true);
150 }
151 
152 /**
153  * @tc.name: SetRegistryObjectTest001
154  * @tc.desc: Verify the SetRegistryObject and GetRegistryObject functions
155  * @tc.type: FUNC
156  */
157 HWTEST_F(ProcessSkeletonUnitTest, SetRegistryObjectTest001, TestSize.Level1)
158 {
159     ProcessSkeleton *skeleton = ProcessSkeleton::GetInstance();
160     ASSERT_TRUE(skeleton != nullptr);
161 
162     sptr<IRemoteObject> object = new IPCObjectStub(u"testObject");
163     skeleton->SetRegistryObject(object);
164     sptr<IRemoteObject> registryObject = skeleton->GetRegistryObject();
165     EXPECT_EQ(registryObject.GetRefPtr(), object.GetRefPtr());
166 }
167 
168 /**
169  * @tc.name: LockObjectMutexTest001
170  * @tc.desc: Verify the LockObjectMutex and UnlockObjectMutex functions
171  * @tc.type: FUNC
172  */
173 HWTEST_F(ProcessSkeletonUnitTest, LockObjectMutexTest001, TestSize.Level1)
174 {
175     ProcessSkeleton *skeleton = ProcessSkeleton::GetInstance();
176     ASSERT_TRUE(skeleton != nullptr);
177 
178     bool lockRet = skeleton->LockObjectMutex();
179     EXPECT_EQ(lockRet, true);
180 
181     bool unlockRet = skeleton->UnlockObjectMutex();
182     EXPECT_EQ(unlockRet, true);
183 }
184 
185 /**
186  * @tc.name: SetIPCProxyLimitTest001
187  * @tc.desc: Verify the SetIPCProxyLimit function
188  * @tc.type: FUNC
189  */
190 HWTEST_F(ProcessSkeletonUnitTest, SetIPCProxyLimitTest001, TestSize.Level1)
191 {
192     ProcessSkeleton *skeleton = ProcessSkeleton::GetInstance();
193     ASSERT_TRUE(skeleton != nullptr);
194 
195     uint64_t limit = 1000;
196     bool ret = skeleton->SetIPCProxyLimit(limit, nullptr);
197     EXPECT_EQ(ret, true);
198 }
199 
200 /**
201  * @tc.name: ConvertToSecureDescTest001
202  * @tc.desc: Verify the ConvertToSecureDesc function
203  * @tc.type: FUNC
204  */
205 HWTEST_F(ProcessSkeletonUnitTest, ConvertToSecureDescTest001, TestSize.Level1)
206 {
207     std::string desc = "test.example.com";
208     std::string secureDesc = ProcessSkeleton::ConvertToSecureDesc(desc);
209     EXPECT_EQ(secureDesc, "*.com");
210 }
211 
212 /**
213  * @tc.name: IsPrintTest001
214  * @tc.desc: Verify the IsPrint function
215  * @tc.type: FUNC
216  */
217 HWTEST_F(ProcessSkeletonUnitTest, IsPrintTest001, TestSize.Level1)
218 {
219     std::atomic<int> lastErr = 0;
220     std::atomic<int> lastErrCnt = 0;
221     bool isPrint = ProcessSkeleton::IsPrint(1, lastErr, lastErrCnt);
222     EXPECT_EQ(isPrint, true);
223     EXPECT_EQ(lastErr, 1);
224     EXPECT_EQ(lastErrCnt, 0);
225 }