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 "UTTest_json_str_handle.h"
17
18 #include <algorithm>
19 #include <thread>
20 #include <unistd.h>
21
22 namespace OHOS {
23 namespace DistributedHardware {
24
25 namespace {
26 const std::string TAG_PEER_BUNDLE_NAME = "peerBundleName";
27 const std::string TAG_PEER_TOKENID = "peerTokenId";
28 const std::string TAG_PROXY = "proxy";
29 } // namespace
30
SetUp()31 void JsonStrHandleTest::SetUp() {}
32
TearDown()33 void JsonStrHandleTest::TearDown() {}
34
SetUpTestCase()35 void JsonStrHandleTest::SetUpTestCase() {}
36
TearDownTestCase()37 void JsonStrHandleTest::TearDownTestCase() {}
38
39 /**
40 * @tc.name: GetPeerAppInfoParseExtra_001
41 * @tc.desc: GetPeerAppInfoParseExtra
42 * @tc.type: FUNC
43 * @tc.require: AR000GHSJK
44 */
45 HWTEST_F(JsonStrHandleTest, GetPeerAppInfoParseExtra_001, testing::ext::TestSize.Level1)
46 {
47 std::string extra = "";
48 uint64_t peerTokenId = 0;
49 std::string peerBundleName = "";
50 JsonStrHandle::GetInstance().GetPeerAppInfoParseExtra(extra, peerTokenId, peerBundleName);
51
52 extra = "extra";
53 peerTokenId = 1;
54 peerBundleName = "peerBundleName";
55 JsonStrHandle::GetInstance().GetPeerAppInfoParseExtra(extra, peerTokenId, peerBundleName);
56 std::string extraInfo = "extraInfo";
57 std::vector<int64_t> tokenIdVec = JsonStrHandle::GetInstance().GetProxyTokenIdByExtra(extraInfo);
58 EXPECT_EQ(tokenIdVec.empty(), true);
59 }
60
61 /**
62 * @tc.name: GetPeerAppInfoParseExtra_002
63 * @tc.desc: Test GetPeerAppInfoParseExtra
64 * @tc.type: FUNC
65 * @tc.require:
66 */
67 HWTEST_F(JsonStrHandleTest, GetPeerAppInfoParseExtra_002, testing::ext::TestSize.Level1)
68 {
69 std::string extra = "{\"" + TAG_PEER_TOKENID + "\": 12345}";
70 uint64_t peerTokenId = 0;
71 std::string peerBundleName = "";
72 std::shared_ptr<JsonStrHandle> handle = std::make_shared<JsonStrHandle>();
73 handle->GetPeerAppInfoParseExtra(extra, peerTokenId, peerBundleName);
74 EXPECT_EQ(peerBundleName, "");
75 }
76
77 /**
78 * @tc.name: GetPeerAppInfoParseExtra_003
79 * @tc.desc: Test GetPeerAppInfoParseExtra
80 * @tc.type: FUNC
81 * @tc.require:
82 */
83 HWTEST_F(JsonStrHandleTest, GetPeerAppInfoParseExtra_003, testing::ext::TestSize.Level1)
84 {
85 std::string extra = "{\"" + TAG_PEER_BUNDLE_NAME + "\": \"testBundle\"}";
86 uint64_t peerTokenId = 0;
87 std::string peerBundleName = "";
88 std::shared_ptr<JsonStrHandle> handle = std::make_shared<JsonStrHandle>();
89 handle->GetPeerAppInfoParseExtra(extra, peerTokenId, peerBundleName);
90 EXPECT_EQ(peerTokenId, 0);
91 }
92
93 /**
94 * @tc.name: GetPeerAppInfoParseExtra_004
95 * @tc.desc: Test GetPeerAppInfoParseExtra
96 * @tc.type: FUNC
97 * @tc.require:
98 */
99 HWTEST_F(JsonStrHandleTest, GetPeerAppInfoParseExtra_004, testing::ext::TestSize.Level1)
100 {
101 std::string extra = "{\"" + TAG_PEER_BUNDLE_NAME + "\": 123, \"" + TAG_PEER_TOKENID + "\": 456}";
102 uint64_t peerTokenId = 0;
103 std::string peerBundleName = "";
104 std::shared_ptr<JsonStrHandle> handle = std::make_shared<JsonStrHandle>();
105 handle->GetPeerAppInfoParseExtra(extra, peerTokenId, peerBundleName);
106 EXPECT_EQ(peerBundleName, "");
107 }
108
109 /**
110 * @tc.name: GetPeerAppInfoParseExtra_005
111 * @tc.desc: Test GetPeerAppInfoParseExtra
112 * @tc.type: FUNC
113 * @tc.require:
114 */
115 HWTEST_F(JsonStrHandleTest, GetPeerAppInfoParseExtra_005, testing::ext::TestSize.Level1)
116 {
117 std::string extra = "{\"" + TAG_PEER_BUNDLE_NAME + "\": \"testBundle\", \"" + TAG_PEER_TOKENID + "\": \"123\"}";
118 uint64_t peerTokenId = 0;
119 std::string peerBundleName = "";
120 std::shared_ptr<JsonStrHandle> handle = std::make_shared<JsonStrHandle>();
121 handle->GetPeerAppInfoParseExtra(extra, peerTokenId, peerBundleName);
122 EXPECT_EQ(peerTokenId, 0);
123 }
124
125 /**
126 * @tc.name: GetPeerAppInfoParseExtra_006
127 * @tc.desc: Test GetPeerAppInfoParseExtra
128 * @tc.type: FUNC
129 * @tc.require:
130 */
131 HWTEST_F(JsonStrHandleTest, GetPeerAppInfoParseExtra_006, testing::ext::TestSize.Level1)
132 {
133 std::string extra = "{\"" + TAG_PEER_BUNDLE_NAME + "\": \"testBundle\", \"" + TAG_PEER_TOKENID + "\": 12345}";
134 uint64_t peerTokenId = 0;
135 std::string peerBundleName = "";
136 std::shared_ptr<JsonStrHandle> handle = std::make_shared<JsonStrHandle>();
137 handle->GetPeerAppInfoParseExtra(extra, peerTokenId, peerBundleName);
138 EXPECT_EQ(peerTokenId, 12345);
139 EXPECT_EQ(peerBundleName, "testBundle");
140 }
141
142 /**
143 * @tc.name: GetProxyTokenIdByExtra_001
144 * @tc.desc: Test GetProxyTokenIdByExtra with empty extraInfo
145 * @tc.type: FUNC
146 * @tc.require: AR00000000
147 */
148 HWTEST_F(JsonStrHandleTest, GetProxyTokenIdByExtra_001, testing::ext::TestSize.Level1)
149 {
150 std::shared_ptr<JsonStrHandle> handle = std::make_shared<JsonStrHandle>();
151 std::string emptyExtra;
152 std::vector<int64_t> result = handle->GetProxyTokenIdByExtra(emptyExtra);
153 EXPECT_TRUE(result.empty());
154 }
155
156 /**
157 * @tc.name: GetProxyTokenIdByExtra_002
158 * @tc.desc: Test GetProxyTokenIdByExtra with invalid JSON string
159 * @tc.type: FUNC
160 * @tc.require: AR00000000
161 */
162 HWTEST_F(JsonStrHandleTest, GetProxyTokenIdByExtra_002, testing::ext::TestSize.Level1)
163 {
164 std::shared_ptr<JsonStrHandle> handle = std::make_shared<JsonStrHandle>();
165 std::string invalidJson = "{invalid}";
166 std::vector<int64_t> result = handle->GetProxyTokenIdByExtra(invalidJson);
167 EXPECT_TRUE(result.empty());
168 }
169
170 /**
171 * @tc.name: GetProxyTokenIdByExtra_003
172 * @tc.desc: Test GetProxyTokenIdByExtra with JSON missing proxy tag
173 * @tc.type: FUNC
174 * @tc.require: AR00000000
175 */
176 HWTEST_F(JsonStrHandleTest, GetProxyTokenIdByExtra_003, testing::ext::TestSize.Level1)
177 {
178 std::shared_ptr<JsonStrHandle> handle = std::make_shared<JsonStrHandle>();
179 std::string noProxyTag = "{\"other\": \"value\"}";
180 std::vector<int64_t> result = handle->GetProxyTokenIdByExtra(noProxyTag);
181 EXPECT_TRUE(result.empty());
182 }
183
184 /**
185 * @tc.name: GetProxyTokenIdByExtra_004
186 * @tc.desc: Test GetProxyTokenIdByExtra with invalid proxy list string
187 * @tc.type: FUNC
188 * @tc.require: AR00000000
189 */
190 HWTEST_F(JsonStrHandleTest, GetProxyTokenIdByExtra_004, testing::ext::TestSize.Level1)
191 {
192 std::shared_ptr<JsonStrHandle> handle = std::make_shared<JsonStrHandle>();
193 std::string invalidProxyList = "{\"" + TAG_PROXY + "\": \"not_a_valid_json_array\"}";
194 std::vector<int64_t> result = handle->GetProxyTokenIdByExtra(invalidProxyList);
195 EXPECT_TRUE(result.empty());
196 }
197
198 /**
199 * @tc.name: GetProxyTokenIdByExtra_005
200 * @tc.desc: Test GetProxyTokenIdByExtra with empty proxy list
201 * @tc.type: FUNC
202 * @tc.require: AR00000000
203 */
204 HWTEST_F(JsonStrHandleTest, GetProxyTokenIdByExtra_005, testing::ext::TestSize.Level1)
205 {
206 std::shared_ptr<JsonStrHandle> handle = std::make_shared<JsonStrHandle>();
207 std::string emptyProxyList = "{\"" + TAG_PROXY + "\": \"[]\"}";
208 std::vector<int64_t> result = handle->GetProxyTokenIdByExtra(emptyProxyList);
209 EXPECT_TRUE(result.empty());
210 }
211
212 /**
213 * @tc.name: GetProxyTokenIdByExtra_006
214 * @tc.desc: Test GetProxyTokenIdByExtra with valid number list
215 * @tc.type: FUNC
216 * @tc.require: AR00000000
217 */
218 HWTEST_F(JsonStrHandleTest, GetProxyTokenIdByExtra_006, testing::ext::TestSize.Level1)
219 {
220 std::shared_ptr<JsonStrHandle> handle = std::make_shared<JsonStrHandle>();
221 std::string validProxyList = "{\"" + TAG_PROXY + "\": \"[123, 456, 789]\"}";
222 std::vector<int64_t> result = handle->GetProxyTokenIdByExtra(validProxyList);
223
224 ASSERT_EQ(result.size(), 3);
225 EXPECT_EQ(result[0], 123);
226 EXPECT_EQ(result[1], 456);
227 EXPECT_EQ(result[2], 789);
228 }
229
230 /**
231 * @tc.name: GetProxyTokenIdByExtra_007
232 * @tc.desc: Test GetProxyTokenIdByExtra with mixed type list
233 * @tc.type: FUNC
234 * @tc.require: AR00000000
235 */
236 HWTEST_F(JsonStrHandleTest, GetProxyTokenIdByExtra_007, testing::ext::TestSize.Level1)
237 {
238 std::shared_ptr<JsonStrHandle> handle = std::make_shared<JsonStrHandle>();
239 std::string mixedProxyList = "{\"" + TAG_PROXY + "\": \"[123, 456, null, 789]\"}";
240 std::vector<int64_t> result = handle->GetProxyTokenIdByExtra(mixedProxyList);
241
242 ASSERT_EQ(result.size(), 3);
243 EXPECT_EQ(result[0], 123);
244 EXPECT_EQ(result[1], 456);
245 EXPECT_EQ(result[2], 789);
246 }
247 } // namespace DistributedHardware
248 } // namespace OHOS
249