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 <gtest/gtest.h>
17
18 #include "securec.h"
19 #include "want.h"
20 #include "want_params.h"
21 #include "want/include/want.h"
22 #include "want_manager.h"
23 #include "bool_wrapper.h"
24 #include "double_wrapper.h"
25 #include "int_wrapper.h"
26 #include "string_wrapper.h"
27
28 using namespace testing::ext;
29 using namespace OHOS::AAFwk;
30
31
32 class CWantTest : public testing::Test {
33 public:
SetUpTestCase()34 static void SetUpTestCase(){};
35
TearDownTestCase()36 static void TearDownTestCase(){};
37
SetUp()38 void SetUp(){};
39
TearDown()40 void TearDown(){};
41 };
42
initElementWithDynamicMemory(AbilityBase_Element & element)43 void initElementWithDynamicMemory(AbilityBase_Element& element)
44 {
45 const char bundle[] = "testBundleName";
46 const char module[] = "testModuleName";
47 const char ability[] = "testAbilityName";
48
49 element.bundleName = new char[strlen(bundle) + 1];
50 element.moduleName = new char[strlen(module) + 1];
51 element.abilityName = new char[strlen(ability) + 1];
52
53 strcpy_s(element.bundleName, strlen(bundle) + 1, bundle);
54 strcpy_s(element.moduleName, strlen(module) + 1, module);
55 strcpy_s(element.abilityName, strlen(ability) + 1, ability);
56 }
57
ReleaseElementMemory(AbilityBase_Element & element)58 void ReleaseElementMemory(AbilityBase_Element& element)
59 {
60 delete[] element.bundleName;
61 delete[] element.moduleName;
62 delete[] element.abilityName;
63 }
64
65 /**
66 * @tc.number:OH_AbilityBase_TransformToWant_001
67 * @tc.desc: Function test OH_AbilityBase_TransformToWant_001
68 * @tc.type: FUNC
69 */
70 HWTEST_F(CWantTest, OH_AbilityBase_TransformToWant_001, TestSize.Level0)
71 {
72 AbilityBase_Element element;
73 initElementWithDynamicMemory(element);
74
75 AbilityBase_Want* want = OH_AbilityBase_CreateWant(element);
76 const char * intKey = "intKey";
77 int32_t intvalue = 10;
78 AbilityBase_ErrorCode errCode = OH_AbilityBase_SetWantInt32Param(want, intKey, intvalue);
79 ASSERT_EQ(errCode, ABILITY_BASE_ERROR_CODE_NO_ERROR);
80
81 const char * doubleKey = "doubleKey";
82 double doublevalue = 3.14f;
83 errCode = OH_AbilityBase_SetWantDoubleParam(want, doubleKey, doublevalue);
84 ASSERT_EQ(errCode, ABILITY_BASE_ERROR_CODE_NO_ERROR);
85
86 const char * boolKey = "boolKey";
87 bool boolvalue = true;
88 errCode = OH_AbilityBase_SetWantBoolParam(want, boolKey, boolvalue);
89 ASSERT_EQ(errCode, ABILITY_BASE_ERROR_CODE_NO_ERROR);
90
91 const char * strKey = "strKey";
92 const char * strValue = "strValue";
93 errCode = OH_AbilityBase_SetWantCharParam(want, strKey, strValue);
94 ASSERT_EQ(errCode, ABILITY_BASE_ERROR_CODE_NO_ERROR);
95
96 const char * fdKey = "fdKey";
97 int32_t fd = 1;
98 errCode = OH_AbilityBase_AddWantFd(want, fdKey, fd);
99 ASSERT_EQ(errCode, ABILITY_BASE_ERROR_CODE_NO_ERROR);
100
101 OHOS::AAFwk::Want *want2 = new (std::nothrow) OHOS::AAFwk::Want();
102 errCode = OHOS::AAFwk::CWantManager::TransformToWant(*want, true, *want2);
103 ASSERT_EQ(errCode, ABILITY_BASE_ERROR_CODE_NO_ERROR);
104 ReleaseElementMemory(element);
105 }
106
107 /**
108 * @tc.number:OH_AbilityBase_TransformToWant_002
109 * @tc.desc: Function test OH_AbilityBase_TransformToWant_002
110 * @tc.type: FUNC
111 */
112 HWTEST_F(CWantTest, OH_AbilityBase_TransformToWant_002, TestSize.Level0)
113 {
114 AbilityBase_Element element;
115 initElementWithDynamicMemory(element);
116
117 AbilityBase_Want* want = OH_AbilityBase_CreateWant(element);
118 OHOS::AAFwk::Want *want2 = new (std::nothrow) OHOS::AAFwk::Want();
119 OHOS::AAFwk::WantParams wantParams;
120 std::string keyStr1 = "12345667";
121 bool valueBool = true;
122 wantParams.SetParam(keyStr1, OHOS::AAFwk::Boolean::Box(valueBool));
123
124 std::string keyStr2 = "1234566";
125 std::string valueString = "123";
126 wantParams.SetParam(keyStr2, OHOS::AAFwk::String::Box(valueString));
127
128 std::string keyStr3 = "123456";
129 int valueInt = 111;
130 wantParams.SetParam(keyStr3, OHOS::AAFwk::Integer::Box(valueInt));
131
132 std::string keyStr4 = "12345";
133 double valueDouble = 3.14f;
134 wantParams.SetParam(keyStr4, OHOS::AAFwk::Double::Box(valueDouble));
135
136 AbilityBase_ErrorCode errCode = OHOS::AAFwk::CWantManager::TransformToCWantWithoutElement(*want2, false, *want);
137 ASSERT_EQ(errCode, ABILITY_BASE_ERROR_CODE_NO_ERROR);
138 ReleaseElementMemory(element);
139 }
140
141 HWTEST_F(CWantTest, ShouldTransformEmptyWant, TestSize.Level0)
142 {
143 OHOS::AAFwk::Want want;
144 AbilityBase_Want cwant;
145 auto result = OHOS::AAFwk::CWantManager::TransformToCWantWithoutElement(want, false, cwant);
146
147 EXPECT_EQ(result, ABILITY_BASE_ERROR_CODE_NO_ERROR);
148 EXPECT_TRUE(cwant.uri.empty());
149 EXPECT_TRUE(cwant.params.empty());
150 EXPECT_TRUE(cwant.intParams.empty());
151 EXPECT_TRUE(cwant.boolParams.empty());
152 EXPECT_TRUE(cwant.doubleParams.empty());
153 EXPECT_TRUE(cwant.fds.empty());
154 }
155
156 HWTEST_F(CWantTest, ShouldTransformUriCorrectly, TestSize.Level0)
157 {
158 OHOS::AAFwk::Want want;
159 want.SetUri("test_uri");
160 AbilityBase_Want cwant;
161 auto result = OHOS::AAFwk::CWantManager::TransformToCWantWithoutElement(want, false, cwant);
162
163 EXPECT_EQ(result, ABILITY_BASE_ERROR_CODE_NO_ERROR);
164 EXPECT_EQ(cwant.uri, "test_uri");
165 }
166
167 HWTEST_F(CWantTest, ShouldTransformStringParams, TestSize.Level0)
168 {
169 OHOS::AAFwk::Want want;
170 OHOS::AAFwk::WantParams params;
171 params.SetParam("str_key", String::Box("str_value"));
172 want.SetParams(params);
173
174 AbilityBase_Want cwant;
175 auto result = OHOS::AAFwk::CWantManager::TransformToCWantWithoutElement(want, false, cwant);
176
177 EXPECT_EQ(result, ABILITY_BASE_ERROR_CODE_NO_ERROR);
178 ASSERT_EQ(cwant.params.size(), 1);
179 EXPECT_EQ(cwant.params["str_key"], "str_value");
180 }
181
182 HWTEST_F(CWantTest, ShouldTransformIntParams, TestSize.Level0)
183 {
184 OHOS::AAFwk::Want want;
185 OHOS::AAFwk::WantParams params;
186 params.SetParam("int_key", Integer::Box(123));
187 want.SetParams(params);
188
189 AbilityBase_Want cwant;
190 auto result = OHOS::AAFwk::CWantManager::TransformToCWantWithoutElement(want, false, cwant);
191
192 EXPECT_EQ(result, ABILITY_BASE_ERROR_CODE_NO_ERROR);
193 ASSERT_EQ(cwant.intParams.size(), 1);
194 EXPECT_EQ(cwant.intParams["int_key"], 123);
195 }
196
197 HWTEST_F(CWantTest, ShouldTransformBoolParams, TestSize.Level0)
198 {
199 OHOS::AAFwk::Want want;
200 OHOS::AAFwk::WantParams params;
201 params.SetParam("bool_key", Boolean::Box(true));
202 want.SetParams(params);
203
204 AbilityBase_Want cwant;
205 auto result = OHOS::AAFwk::CWantManager::TransformToCWantWithoutElement(want, false, cwant);
206
207 EXPECT_EQ(result, ABILITY_BASE_ERROR_CODE_NO_ERROR);
208 ASSERT_EQ(cwant.boolParams.size(), 1);
209 EXPECT_EQ(cwant.boolParams["bool_key"], true);
210 }
211
212 HWTEST_F(CWantTest, ShouldTransformDoubleParams, TestSize.Level0)
213 {
214 OHOS::AAFwk::Want want;
215 OHOS::AAFwk::WantParams params;
216 params.SetParam("double_key", Double::Box(3.14));
217 want.SetParams(params);
218
219 AbilityBase_Want cwant;
220 auto result = OHOS::AAFwk::CWantManager::TransformToCWantWithoutElement(want, false, cwant);
221
222 EXPECT_EQ(result, ABILITY_BASE_ERROR_CODE_NO_ERROR);
223 ASSERT_EQ(cwant.doubleParams.size(), 1);
224 EXPECT_DOUBLE_EQ(cwant.doubleParams["double_key"], 3.14);
225 }
226
227 HWTEST_F(CWantTest, ShouldTransformMultipleParams, TestSize.Level0)
228 {
229 OHOS::AAFwk::Want want;
230 OHOS::AAFwk::WantParams params;
231 params.SetParam("str_key", String::Box("str_value"));
232 params.SetParam("int_key", Integer::Box(123));
233 params.SetParam("bool_key", Boolean::Box(true));
234 params.SetParam("double_key", Double::Box(3.14));
235 want.SetParams(params);
236
237 AbilityBase_Want cwant;
238 auto result = OHOS::AAFwk::CWantManager::TransformToCWantWithoutElement(want, false, cwant);
239
240 EXPECT_EQ(result, ABILITY_BASE_ERROR_CODE_NO_ERROR);
241 ASSERT_EQ(cwant.params.size(), 1);
242 ASSERT_EQ(cwant.intParams.size(), 1);
243 ASSERT_EQ(cwant.boolParams.size(), 1);
244 ASSERT_EQ(cwant.doubleParams.size(), 1);
245 EXPECT_EQ(cwant.params["str_key"], "str_value");
246 EXPECT_EQ(cwant.intParams["int_key"], 123);
247 EXPECT_EQ(cwant.boolParams["bool_key"], true);
248 EXPECT_DOUBLE_EQ(cwant.doubleParams["double_key"], 3.14);
249 }