1 /*
2 * Copyright (c) 2022 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 "base/test/mock/mock_asset_manager.h"
19 #include "core/components/test/unittest/mock/mock_render_common.h"
20 #define private public
21 #define protected public
22 #include "bridge/card_frontend/card_frontend_declarative.h"
23 #undef private
24 #undef protected
25 #include "base/test/mock/mock_task_executor.h"
26 #include "bridge/common/utils/utils.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace OHOS::Ace::Framework {
32 class CardFrontendDeclarativeTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp() override;
37 void TearDown() override;
38 };
39
SetUpTestCase()40 void CardFrontendDeclarativeTest::SetUpTestCase() {}
TearDownTestCase()41 void CardFrontendDeclarativeTest::TearDownTestCase() {}
SetUp()42 void CardFrontendDeclarativeTest::SetUp() {}
TearDown()43 void CardFrontendDeclarativeTest::TearDown() {}
44
45 /**
46 * @tc.name: Initialize001
47 * @tc.desc: Test card frontend declarative Initialize method.
48 * @tc.type: FUNC
49 */
50 HWTEST_F(CardFrontendDeclarativeTest, Initialize001, TestSize.Level1)
51 {
52 auto cardFrontend = AceType::MakeRefPtr<CardFrontendDeclarative>();
53 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
54 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
55 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
56 ASSERT_NE(cardFrontend->delegate_, nullptr);
57 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
58 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
59 }
60
61 /**
62 * @tc.name: GetPageRouterManager001
63 * @tc.desc: Test card frontend declarative GetPageRouterManager method.
64 * @tc.type: FUNC
65 */
66 HWTEST_F(CardFrontendDeclarativeTest, GetPageRouterManager001, TestSize.Level1)
67 {
68 auto cardFrontend = AceType::MakeRefPtr<CardFrontendDeclarative>();
69 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
70 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
71 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
72 ASSERT_NE(cardFrontend->delegate_, nullptr);
73 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
74 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
75 auto manager = cardFrontend->GetPageRouterManager();
76 ASSERT_NE(manager, nullptr);
77 }
78
79 /**
80 * @tc.name: Destroy001
81 * @tc.desc: Test card frontend declarative Destroy method.
82 * @tc.type: FUNC
83 */
84 HWTEST_F(CardFrontendDeclarativeTest, Destroy001, TestSize.Level1)
85 {
86 auto cardFrontend = AceType::MakeRefPtr<CardFrontendDeclarative>();
87 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
88 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
89 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
90 ASSERT_NE(cardFrontend->delegate_, nullptr);
91 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
92 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
93 cardFrontend->Destroy();
94 ASSERT_EQ(cardFrontend->delegate_, nullptr);
95 ASSERT_EQ(cardFrontend->eventHandler_, nullptr);
96 }
97
98 /**
99 * @tc.name: AttachPipelineContext001
100 * @tc.desc: Test card frontend declarative AttachPipelineContext method.
101 * @tc.type: FUNC
102 */
103 HWTEST_F(CardFrontendDeclarativeTest, AttachPipelineContext001, TestSize.Level1)
104 {
105 auto cardFrontend = AceType::MakeRefPtr<CardFrontendDeclarative>();
106 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
107 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
108 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
109 ASSERT_NE(cardFrontend->delegate_, nullptr);
110 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
111 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
112 auto pipeline = MockRenderCommon::GetMockContext();
113 cardFrontend->AttachPipelineContext(pipeline);
114 ASSERT_EQ(cardFrontend->eventHandler_, nullptr);
115 cardFrontend->AttachPipelineContext(nullptr);
116 ASSERT_EQ(cardFrontend->eventHandler_, nullptr);
117 }
118
119 /**
120 * @tc.name: SetAssetManager001
121 * @tc.desc: Test card frontend declarative SetAssetManager method.
122 * @tc.type: FUNC
123 */
124 HWTEST_F(CardFrontendDeclarativeTest, SetAssetManager001, TestSize.Level1)
125 {
126 auto cardFrontend = AceType::MakeRefPtr<CardFrontendDeclarative>();
127 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
128 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
129 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
130 ASSERT_NE(cardFrontend->delegate_, nullptr);
131 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
132 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
133 auto assetManager = Referenced::MakeRefPtr<MockAssetManager>();
134 cardFrontend->SetAssetManager(assetManager);
135 ASSERT_NE(cardFrontend->assetManager_, nullptr);
136 }
137
138 /**
139 * @tc.name: RunPage001
140 * @tc.desc: Test card frontend declarative RunPage method.
141 * @tc.type: FUNC
142 */
143 HWTEST_F(CardFrontendDeclarativeTest, RunPage001, TestSize.Level1)
144 {
145 auto cardFrontend = AceType::MakeRefPtr<CardFrontendDeclarative>();
146 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
147 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
148 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
149 ASSERT_NE(cardFrontend->delegate_, nullptr);
150 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
151 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
152 cardFrontend->RunPage(1, "", "");
153 cardFrontend->RunPage(1, "test", "test");
154 cardFrontend->RunPage(1, "", "test");
155 cardFrontend->RunPage(1, "test", "");
156 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
157 ASSERT_NE(cardFrontend->delegate_, nullptr);
158 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
159 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
160 }
161
162 /**
163 * @tc.name: UpdateData001
164 * @tc.desc: Test card frontend declarative UpdateData method.
165 * @tc.type: FUNC
166 */
167 HWTEST_F(CardFrontendDeclarativeTest, UpdateData001, TestSize.Level1)
168 {
169 auto cardFrontend = AceType::MakeRefPtr<CardFrontendDeclarative>();
170 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
171 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
172 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
173 ASSERT_NE(cardFrontend->delegate_, nullptr);
174 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
175 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
176 cardFrontend->UpdateData("");
177 cardFrontend->UpdateData("test");
178 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
179 ASSERT_NE(cardFrontend->delegate_, nullptr);
180 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
181 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
182 }
183
184 /**
185 * @tc.name: UpdatePageData001
186 * @tc.desc: Test card frontend declarative UpdatePageData method.
187 * @tc.type: FUNC
188 */
189 HWTEST_F(CardFrontendDeclarativeTest, UpdatePageData001, TestSize.Level1)
190 {
191 auto cardFrontend = AceType::MakeRefPtr<CardFrontendDeclarative>();
192 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
193 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
194 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
195 ASSERT_NE(cardFrontend->delegate_, nullptr);
196 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
197 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
198 cardFrontend->UpdatePageData("");
199 cardFrontend->UpdatePageData("test");
200 cardFrontend->delegate_ = nullptr;
201 cardFrontend->parseJsCard_ = nullptr;
202 cardFrontend->UpdatePageData("test");
203 ASSERT_EQ(cardFrontend->delegate_, nullptr);
204 ASSERT_EQ(cardFrontend->parseJsCard_, nullptr);
205 }
206
207 /**
208 * @tc.name: SetColorMode001
209 * @tc.desc: Test card frontend declarative SetColorMode method.
210 * @tc.type: FUNC
211 */
212 HWTEST_F(CardFrontendDeclarativeTest, SetColorMode001, TestSize.Level1)
213 {
214 auto cardFrontend = AceType::MakeRefPtr<CardFrontendDeclarative>();
215 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
216 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
217 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
218 ASSERT_NE(cardFrontend->delegate_, nullptr);
219 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
220 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
221 cardFrontend->SetColorMode(ColorMode::LIGHT);
222 ASSERT_EQ(cardFrontend->colorMode_, ColorMode::LIGHT);
223 }
224
225 /**
226 * @tc.name: OnSurfaceChanged001
227 * @tc.desc: Test card frontend declarative OnSurfaceChanged method.
228 * @tc.type: FUNC
229 */
230 HWTEST_F(CardFrontendDeclarativeTest, OnSurfaceChanged001, TestSize.Level1)
231 {
232 auto cardFrontend = AceType::MakeRefPtr<CardFrontendDeclarative>();
233 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
234 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
235 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
236 ASSERT_NE(cardFrontend->delegate_, nullptr);
237 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
238 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
239 cardFrontend->OnSurfaceChanged(0, 0);
240 cardFrontend->OnSurfaceChanged(100, 100);
241 cardFrontend->OnSurfaceChanged(-100, -100);
242 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
243 ASSERT_NE(cardFrontend->delegate_, nullptr);
244 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
245 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
246 }
247
248 /**
249 * @tc.name: HandleSurfaceChanged001
250 * @tc.desc: Test card frontend declarative HandleSurfaceChanged method.
251 * @tc.type: FUNC
252 */
253 HWTEST_F(CardFrontendDeclarativeTest, HandleSurfaceChanged001, TestSize.Level1)
254 {
255 auto cardFrontend = AceType::MakeRefPtr<CardFrontendDeclarative>();
256 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
257 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
258 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
259 ASSERT_NE(cardFrontend->delegate_, nullptr);
260 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
261 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
262 cardFrontend->HandleSurfaceChanged(0, 0);
263 cardFrontend->HandleSurfaceChanged(100, 100);
264 cardFrontend->HandleSurfaceChanged(-100, -100);
265 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
266 ASSERT_NE(cardFrontend->delegate_, nullptr);
267 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
268 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
269 }
270
271 /**
272 * @tc.name: OnMediaFeatureUpdate001
273 * @tc.desc: Test card frontend declarative OnMediaFeatureUpdate method.
274 * @tc.type: FUNC
275 */
276 HWTEST_F(CardFrontendDeclarativeTest, OnMediaFeatureUpdate001, TestSize.Level1)
277 {
278 auto cardFrontend = AceType::MakeRefPtr<CardFrontendDeclarative>();
279 auto taskExecutor = Referenced::MakeRefPtr<MockTaskExecutor>();
280 cardFrontend->Initialize(FrontendType::JS_CARD, taskExecutor);
281 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
282 ASSERT_NE(cardFrontend->delegate_, nullptr);
283 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
284 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
285 cardFrontend->OnMediaFeatureUpdate();
286 ASSERT_NE(cardFrontend->taskExecutor_, nullptr);
287 ASSERT_NE(cardFrontend->delegate_, nullptr);
288 ASSERT_NE(cardFrontend->manifestParser_, nullptr);
289 ASSERT_EQ(cardFrontend->type_, FrontendType::JS_CARD);
290 }
291 } // namespace OHOS::Ace::Framework