1 /*
2 * Copyright (c) 2022-2024 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 #include "gtest/gtest.h"
16
17 #define private public
18 #define protected public
19 #include "test/mock/core/common/mock_resource_adapter.h"
20 #include "test/mock/core/common/mock_theme_manager.h"
21 #include "test/mock/core/pipeline/mock_pipeline_context.h"
22 #include "test/mock/core/render/mock_render_context.h"
23 #include "test/unittest/core/pattern/test_ng.h"
24
25 #include "base/log/log_wrapper.h"
26 #include "core/components/container_modal/container_modal_constants.h"
27 #include "core/components/theme/theme_constants.h"
28 #include "core/components_ng/base/ui_node.h"
29 #include "core/components_ng/base/view_stack_processor.h"
30 #include "core/components_ng/pattern/button/button_pattern.h"
31 #include "core/components_ng/pattern/container_modal/container_modal_pattern.h"
32 #include "core/components_ng/pattern/container_modal/container_modal_theme.h"
33 #include "core/components_ng/pattern/container_modal/container_modal_view.h"
34 #include "core/components_ng/pattern/image/image_layout_property.h"
35 #include "core/components_ng/pattern/image/image_pattern.h"
36 #include "core/components_ng/pattern/linear_layout/linear_layout_pattern.h"
37 #include "core/components_ng/pattern/pattern.h"
38 #include "core/components_ng/pattern/stack/stack_pattern.h"
39 #include "core/components_ng/pattern/text/text_pattern.h"
40 #include "core/components_ng/pattern/text_picker/textpicker_column_pattern.h"
41 #include "core/pipeline_ng/pipeline_context.h"
42 #include "test/unittest/core/event/focus_core/focus_api_test.h"
43 #include "core/components_ng/pattern/root/root_pattern.h"
44
45 using namespace testing;
46 using namespace testing::ext;
47 namespace OHOS::Ace::NG {
48
49 struct FocusApiTestRequestImmediatelyByIdCase {
50 bool isAFocusable;
51 bool isBFocusable;
52 bool isADependenceSelf;
53 bool isAOnMainTree;
54 std::string inspectorId;
55 std::vector<bool> expectResults;
FocusApiTestRequestImmediatelyByIdCaseOHOS::Ace::NG::FocusApiTestRequestImmediatelyByIdCase56 FocusApiTestRequestImmediatelyByIdCase(
57 bool isAFocusable, bool isBFocusable, bool isADependenceSelf, bool isAOnMainTree,
58 std::string inspectorId, const std::vector<bool>& expectResults) : isAFocusable(isAFocusable),
59 isBFocusable(isBFocusable), isADependenceSelf(isADependenceSelf),
60 isAOnMainTree(isAOnMainTree), inspectorId(inspectorId), expectResults(expectResults) {}
61 };
62
63 const std::vector<FocusApiTestRequestImmediatelyByIdCase>
64 FOCUS_API_TEST_REQUESTIMMEDIATELYBYID_CASES = {
65 // case1
66 FocusApiTestRequestImmediatelyByIdCase(true, true, true, true, "NODEA", {true, false}),
67 // case2
68 FocusApiTestRequestImmediatelyByIdCase(true, true, true, true, "NODEB", {true, true}),
69 // case3
70 FocusApiTestRequestImmediatelyByIdCase(true, true, true, false, "NODEA", {false, false}),
71 // case4
72 FocusApiTestRequestImmediatelyByIdCase(true, true, true, false, "NODEB", {false, false}),
73 // case5
74 FocusApiTestRequestImmediatelyByIdCase(true, true, false, true, "NODEA", {true, true}),
75 // case6
76 FocusApiTestRequestImmediatelyByIdCase(true, true, false, true, "NODEB", {true, true}),
77 // case7
78 FocusApiTestRequestImmediatelyByIdCase(true, true, false, false, "NODEA", {false, false}),
79 // case8
80 FocusApiTestRequestImmediatelyByIdCase(true, true, false, false, "NODEB", {false, false}),
81 // case9
82 FocusApiTestRequestImmediatelyByIdCase(true, true, false, false, "NODEA", {false, false}),
83 // case10
84 FocusApiTestRequestImmediatelyByIdCase(true, true, false, false, "NODEB", {false, false}),
85 };
86
SetUpTestSuite()87 void FocusApiTestNG::SetUpTestSuite()
88 {
89 MockPipelineContext::SetUp();
90 GTEST_LOG_(INFO) << "FocusApiTestNG SetUpTestCase";
91 }
92
TearDownTestSuite()93 void FocusApiTestNG::TearDownTestSuite()
94 {
95 MockPipelineContext::TearDown();
96 GTEST_LOG_(INFO) << "FocusApiTestNG TearDownTestCase";
97 }
98
IsRequestImmediatelyByIdStateEqual(int32_t caseNum,const std::vector<bool> & actualState,const std::vector<bool> & expectState)99 testing::AssertionResult FocusApiTestNG::IsRequestImmediatelyByIdStateEqual(int32_t caseNum,
100 const std::vector<bool>& actualState, const std::vector<bool>& expectState)
101 {
102 auto length = actualState.size();
103 for (int32_t i = 0; i < length; ++i) {
104 if (actualState[i] != expectState[i]) {
105 return testing::AssertionFailure() << "TestCaseNum: " << caseNum << ", NodeId: " <<
106 i << ", actual state: " << actualState[i] << ", expect state: " << expectState[i];
107 }
108 }
109 return testing::AssertionSuccess();
110 }
111
112 /**
113 * @tc.name: FocusApiTestRequestImmediatelyById001
114 * @tc.desc: RequestImmediatelyById
115 * @tc.type: FUNC
116 */
117 HWTEST_F(FocusApiTestNG, FocusApiTestRequestImmediatelyById001, TestSize.Level1)
118 {
119 int32_t caseNum = 1;
120 bool initResult = InitFocusTestBaseNG();
121 EXPECT_TRUE(initResult);
122 for (const auto& testCase : FOCUS_API_TEST_REQUESTIMMEDIATELYBYID_CASES) {
123
124 /**
125 * @tc.steps: step1. Create rootNode and focusHub.
126 * @tc.expected: rootNode and focusHub not null.
127 */
128 auto rootNode = CreateRootNode();
129 EXPECT_NE(rootNode, nullptr);
130 auto rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
131 EXPECT_NE(rootNodeFocusHub, nullptr);
132
133 /**
134 * @tc.steps: step2. Create scope nodeA and focusHub.
135 * @tc.expected: nodeA and focusHub not null.
136 */
137 auto nodeA = CreateNodeWithFocusPattern("nodeA", FocusType::SCOPE, testCase.isAFocusable);
138 EXPECT_NE(nodeA, nullptr);
139 nodeA->UpdateInspectorId("NODEA");
140 auto focusHubA = nodeA->GetOrCreateFocusHub();
141 EXPECT_NE(focusHubA, nullptr);
142
143 /**
144 * @tc.steps: step3. Create node nodeB and focusHub.
145 * @tc.expected: nodeB and focusHub not null.
146 */
147 auto nodeB = CreateNodeWithFocusPattern("nodeB", FocusType::NODE, testCase.isBFocusable);
148 EXPECT_NE(nodeB, nullptr);
149 nodeB->UpdateInspectorId("NODEB");
150 auto focusHubB = nodeB->GetOrCreateFocusHub();
151 EXPECT_NE(focusHubB, nullptr);
152
153 /**
154 * @tc.steps: step4. Add nodeA as child of rootNode, add nodeB as child of nodeA.
155 */
156 rootNode->AddChild(nodeA);
157 nodeA->AddChild(nodeB);
158
159 /**
160 * @tc.steps: step5. Set FocusDependence::SELF to nodeA by input.
161 */
162 if (testCase.isADependenceSelf) {
163 focusHubA->SetFocusDependence(FocusDependence::SELF);
164 }
165
166 /**
167 * @tc.steps: step6. Set isOnMainTree of nodeA and nodeB by input.
168 */
169 nodeA->onMainTree_ = testCase.isAOnMainTree;
170 nodeB->onMainTree_ = testCase.isAOnMainTree;
171
172 /**
173 * @tc.steps: step7. RequestFocusImmediatelyById.
174 * @tc.expected: results are same as expectResults.
175 */
176 rootNodeFocusHub->RequestFocusImmediatelyById(testCase.inspectorId, true);
177 std::vector<bool> results = {focusHubA->IsCurrentFocus(), focusHubB->IsCurrentFocus()};
178 EXPECT_TRUE(IsRequestImmediatelyByIdStateEqual(caseNum, results,
179 testCase.expectResults));
180 ++caseNum;
181 }
182 }
183 } // namespace OHOS::Ace::NG
184