1 /*
2 * Copyright (c) 2025 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 "dslm_test.h"
17
18 #include <chrono>
19 #include <condition_variable>
20 #include <gtest/gtest.h>
21 #include <iostream>
22 #include <mutex>
23 #include <thread>
24
25 #include "file_ex.h"
26 #include "nativetoken_kit.h"
27 #include "securec.h"
28 #include "token_setproc.h"
29
30 #include "device_security_defines.h"
31 #include "device_security_info.h"
32 #include "device_security_level_defines.h"
33 #include "dslm_bigdata.h"
34 #include "dslm_core_defines.h"
35 #include "dslm_core_process.h"
36 #include "dslm_credential.h"
37 #include "dslm_crypto.h"
38 #include "dslm_device_list.h"
39 #include "dslm_fsm_process.h"
40 #include "dslm_hidumper.h"
41 #include "dslm_hievent.h"
42 #include "dslm_inner_process.h"
43 #include "dslm_memory_mock.h"
44 #include "dslm_messenger_wrapper.h"
45 #include "dslm_msg_serialize.h"
46 #include "dslm_msg_utils.h"
47 #include "dslm_ohos_request.h"
48 #include "dslm_ohos_verify.h"
49 #include "dslm_request_callback_mock.h"
50 #include "dslm_rpc_process.h"
51 #include "external_interface_adapter.h"
52 #include "hks_adapter.h"
53 #include "hks_type.h"
54 #include "messenger_device_socket_manager.h"
55 #include "messenger_device_status_manager.h"
56 #include "messenger_impl.h"
57 #include "utils_datetime.h"
58 #include "utils_mem.h"
59 #include "utils_timer.h"
60 #include "utils_tlv.h"
61 #include "utils_work_queue.h"
62
63 using namespace std;
64 using namespace std::chrono;
65 using namespace testing;
66 using namespace testing::ext;
67
68 typedef struct Messenger {
69 uint32_t magicHead;
70 WorkQueue *processQueue;
71 } Messenger;
72
73 #define MESSENGER_MAGIC_HEAD 0x1234abcd
74
75 namespace OHOS {
76 namespace Security {
77 namespace DslmUnitTest {
SetUpTestCase()78 void DslmTest::SetUpTestCase()
79 {
80 }
81
TearDownTestCase()82 void DslmTest::TearDownTestCase()
83 {
84 }
85
SetUp()86 void DslmTest::SetUp()
87 {
88 }
89
TearDown()90 void DslmTest::TearDown()
91 {
92 }
93
94 HWTEST_F(DslmTest, CreateMessengerImpl_case1, TestSize.Level0)
95 {
96 const MessengerConfig config = {};
97
98 Messenger *ret = CreateMessengerImpl(&config);
99 EXPECT_EQ(nullptr, ret);
100
101 ret = CreateMessengerImpl(nullptr);
102 EXPECT_EQ(nullptr, ret);
103 }
104
105 HWTEST_F(DslmTest, IsMessengerReadyImpl_case1, TestSize.Level0)
106 {
107 const Messenger messenger = {MESSENGER_MAGIC_HEAD, nullptr};
108 const Messenger failedMessenger = {0, nullptr};
109
110 bool ret = IsMessengerReadyImpl(&messenger);
111 EXPECT_EQ(true, ret);
112
113 ret = IsMessengerReadyImpl(&failedMessenger);
114 EXPECT_EQ(false, ret);
115
116 ret = IsMessengerReadyImpl(nullptr);
117 EXPECT_EQ(false, ret);
118 }
119
120 HWTEST_F(DslmTest, SendMsgToImpl_case1, TestSize.Level0)
121 {
122 const Messenger messenger = {MESSENGER_MAGIC_HEAD, nullptr};
123 const Messenger failedMessenger = {0, nullptr};
124 uint64_t transNo = 0;
125 const DeviceIdentify devId = {DEVICE_ID_MAX_LEN, {0}};
126 const uint8_t msg[] = {'1', '2'};
127 uint32_t msgLen = 0;
128
129 SendMsgToImpl(&messenger, transNo, &devId, msg, msgLen);
130
131 SendMsgToImpl(nullptr, transNo, &devId, msg, msgLen);
132
133 SendMsgToImpl(&failedMessenger, transNo, &devId, msg, msgLen);
134
135 uint32_t ret = InitService();
136 EXPECT_EQ(ERR_MSG_NOT_INIT, ret);
137 }
138
139 HWTEST_F(DslmTest, GetDeviceOnlineStatusImpl_case1, TestSize.Level0)
140 {
141 const Messenger messenger = {MESSENGER_MAGIC_HEAD, nullptr};
142 const Messenger failedMessenger = {0, nullptr};
143 const DeviceIdentify devId = {DEVICE_ID_MAX_LEN, {0}};
144 int32_t level = 0;
145
146 bool ret = GetDeviceOnlineStatusImpl(&messenger, &devId, &level);
147 EXPECT_EQ(false, ret);
148
149 ret = GetDeviceOnlineStatusImpl(nullptr, &devId, &level);
150 EXPECT_EQ(false, ret);
151
152 ret = GetDeviceOnlineStatusImpl(&messenger, nullptr, &level);
153 EXPECT_EQ(false, ret);
154
155 ret = GetDeviceOnlineStatusImpl(&failedMessenger, &devId, &level);
156 EXPECT_EQ(false, ret);
157 }
158
159 HWTEST_F(DslmTest, GetSelfDeviceIdentifyImpl_case1, TestSize.Level0)
160 {
161 const Messenger messenger = {MESSENGER_MAGIC_HEAD, nullptr};
162 const Messenger failedMessenger = {0, nullptr};
163 DeviceIdentify devId = {DEVICE_ID_MAX_LEN, {0}};
164 int32_t level = 0;
165
166 bool ret = GetSelfDeviceIdentifyImpl(&messenger, &devId, &level);
167 EXPECT_EQ(true, ret);
168
169 ret = GetSelfDeviceIdentifyImpl(nullptr, &devId, &level);
170 EXPECT_EQ(false, ret);
171
172 ret = GetSelfDeviceIdentifyImpl(&messenger, nullptr, &level);
173 EXPECT_EQ(false, ret);
174
175 ret = GetSelfDeviceIdentifyImpl(&failedMessenger, &devId, &level);
176 EXPECT_EQ(false, ret);
177 }
178
179 HWTEST_F(DslmTest, GetDeviceStatisticInfoImpl_case1, TestSize.Level0)
180 {
181 const Messenger messenger = {MESSENGER_MAGIC_HEAD, nullptr};
182 const Messenger failedMessenger = {0, nullptr};
183 DeviceIdentify devId = {DEVICE_ID_MAX_LEN, {0}};
184 const DeviceProcessor processor = nullptr;
185 void *para = nullptr;
186 StatisticInformation info = {};
187
188 ForEachDeviceProcessImpl(&messenger, processor, para);
189
190 ForEachDeviceProcessImpl(nullptr, processor, para);
191
192 ForEachDeviceProcessImpl(&failedMessenger, processor, para);
193
194 bool ret = GetDeviceStatisticInfoImpl(&messenger, &devId, &info);
195 EXPECT_EQ(true, ret);
196
197 ret = GetDeviceStatisticInfoImpl(&failedMessenger, &devId, &info);
198 EXPECT_EQ(false, ret);
199
200 ret = GetDeviceStatisticInfoImpl(nullptr, &devId, &info);
201 EXPECT_EQ(false, ret);
202 }
203 } // namespace DslmUnitTest
204 } // namespace Security
205 } // namespace OHOS