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 #include "accessible_ability_client_stub.h"
18 #include "accessible_ability_channel_proxy.h"
19 #include "mock_accessible_ability_client_stub_impl.h"
20 #include "mock_accessible_ability_channel_stub.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24 using namespace std;
25
26 namespace OHOS {
27 namespace Accessibility {
28 class AccessibleAbilityClientStubUnitTest : public ::testing::Test {
29 public:
AccessibleAbilityClientStubUnitTest()30 AccessibleAbilityClientStubUnitTest() {}
~AccessibleAbilityClientStubUnitTest()31 ~AccessibleAbilityClientStubUnitTest() {}
32
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp() override;
36 void TearDown() override;
37
38 void WriteInterfaceToken(MessageParcel &data) const;
39 sptr<AccessibleAbilityClientStubImplMock> stub_ = nullptr;
40 };
41
SetUpTestCase()42 void AccessibleAbilityClientStubUnitTest::SetUpTestCase()
43 {
44 GTEST_LOG_(INFO) << "###################### AccessibleAbilityClientStubUnitTest Start ######################";
45 }
46
TearDownTestCase()47 void AccessibleAbilityClientStubUnitTest::TearDownTestCase()
48 {
49 GTEST_LOG_(INFO) << "###################### AccessibleAbilityClientStubUnitTest End ######################";
50 }
51
SetUp()52 void AccessibleAbilityClientStubUnitTest::SetUp()
53 {
54 GTEST_LOG_(INFO) << "SetUp";
55 stub_ = new AccessibleAbilityClientStubImplMock();
56 }
57
TearDown()58 void AccessibleAbilityClientStubUnitTest::TearDown()
59 {
60 GTEST_LOG_(INFO) << "TearDown";
61 stub_ = nullptr;
62 }
63
WriteInterfaceToken(MessageParcel & data) const64 void AccessibleAbilityClientStubUnitTest::WriteInterfaceToken(MessageParcel &data) const
65 {
66 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest WriteInterfaceToken";
67 data.WriteInterfaceToken(AccessibleAbilityClientStub::GetDescriptor());
68 }
69
70 /**
71 * @tc.number: AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_001
72 * @tc.name: OnRemoteRequest
73 * @tc.desc: Test function HandleInit
74 */
75 HWTEST_F(AccessibleAbilityClientStubUnitTest,
76 AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_001, TestSize.Level1)
77 {
78 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_001 start";
79
80 MessageParcel data;
81 MessageParcel reply;
82 MessageOption option;
83 sptr<AccessibleAbilityChannelStubMock> stub = new AccessibleAbilityChannelStubMock();
84 sptr<IAccessibleAbilityChannel> channel = new AccessibleAbilityChannelProxy(stub->AsObject());
85 int channelId = 0;
86
87 WriteInterfaceToken(data);
88 data.WriteRemoteObject(channel->AsObject());
89 data.WriteInt32(channelId);
90
91 int res = stub_->OnRemoteRequest(
92 static_cast<uint32_t>(IAccessibleAbilityClient::Message::INIT), data, reply, option);
93 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
94
95 stub = nullptr;
96 channel = nullptr;
97
98 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_001 end";
99 }
100
101 /**
102 * @tc.number: AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_002
103 * @tc.name: OnRemoteRequest
104 * @tc.desc: Test function HandleOnAccessibilityEvent
105 */
106 HWTEST_F(AccessibleAbilityClientStubUnitTest,
107 AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_002, TestSize.Level1)
108 {
109 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_002 start";
110
111 MessageParcel data;
112 MessageParcel reply;
113 MessageOption option;
114 AccessibilityEventInfo eventInfo {};
115
116 WriteInterfaceToken(data);
117 data.WriteParcelable(&eventInfo);
118
119 int res = stub_->OnRemoteRequest(
120 static_cast<uint32_t>(IAccessibleAbilityClient::Message::ON_ACCESSIBILITY_EVENT), data, reply, option);
121 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
122
123 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_002 end";
124 }
125
126 /**
127 * @tc.number: AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_003
128 * @tc.name: OnRemoteRequest
129 * @tc.desc: Test function HandleOnKeyPressEvent
130 */
131 HWTEST_F(AccessibleAbilityClientStubUnitTest,
132 AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_003, TestSize.Level1)
133 {
134 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_003 start";
135
136 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_003 end";
137 }
138
139 /**
140 * @tc.number: AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_004
141 * @tc.name: OnRemoteRequest
142 * @tc.desc: Test function HandleOnDisplayResized
143 */
144 HWTEST_F(AccessibleAbilityClientStubUnitTest,
145 AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_004, TestSize.Level1)
146 {
147 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_004 start";
148
149 MessageParcel data;
150 MessageParcel reply;
151 MessageOption option;
152
153 int displayId = 1;
154 Rect rect {};
155 float scale = 1;
156 float centerX = 1;
157 float centerY = 1;
158
159 WriteInterfaceToken(data);
160 data.WriteInt32(displayId);
161 data.WriteParcelable(&rect);
162 data.WriteFloat(scale);
163 data.WriteFloat(centerX);
164 data.WriteFloat(centerY);
165
166 int res = stub_->OnRemoteRequest(
167 static_cast<uint32_t>(IAccessibleAbilityClient::Message::ON_DISPALYRESIZE_CHANGED), data, reply, option);
168 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
169
170 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_004 end";
171 }
172
173 /**
174 * @tc.number: AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_005
175 * @tc.name: OnRemoteRequest
176 * @tc.desc: Test function HandleOnGestureSimulateResult
177 */
178 HWTEST_F(AccessibleAbilityClientStubUnitTest,
179 AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_005, TestSize.Level1)
180 {
181 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_005 start";
182
183 MessageParcel data;
184 MessageParcel reply;
185 MessageOption option;
186 int sequence = 1;
187 bool completedSuccessfully = true;
188
189 WriteInterfaceToken(data);
190 data.WriteInt32(sequence);
191 data.WriteBool(completedSuccessfully);
192
193 int res = stub_->OnRemoteRequest(
194 static_cast<uint32_t>(IAccessibleAbilityClient::Message::ON_GESTURE_SIMULATE_RESULT), data, reply, option);
195 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
196
197 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_005 end";
198 }
199
200 /**
201 * @tc.number: AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_006
202 * @tc.name: OnRemoteRequest
203 * @tc.desc: Test function OnRemoteRequest when code is error.
204 */
205 HWTEST_F(AccessibleAbilityClientStubUnitTest,
206 AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_006, TestSize.Level1)
207 {
208 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_006 start";
209
210 MessageParcel data;
211 MessageParcel reply;
212 MessageOption option;
213 uint32_t errorCode = 0xFFFFFFFF;
214
215 WriteInterfaceToken(data);
216
217 int res = stub_->OnRemoteRequest(errorCode, data, reply, option);
218 EXPECT_NE(res, OHOS::Accessibility::NO_ERROR);
219
220 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_006 end";
221 }
222
223 /**
224 * @tc.number: AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_007
225 * @tc.name: OnRemoteRequest
226 * @tc.desc: Test function HandleDisconnect.
227 */
228 HWTEST_F(AccessibleAbilityClientStubUnitTest,
229 AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_007, TestSize.Level1)
230 {
231 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_007 start";
232
233 MessageParcel data;
234 MessageParcel reply;
235 MessageOption option;
236 int channelId = 0;
237
238 WriteInterfaceToken(data);
239 data.WriteInt32(channelId);
240
241 int res = stub_->OnRemoteRequest(
242 static_cast<uint32_t>(IAccessibleAbilityClient::Message::DISCONNECT), data, reply, option);
243 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
244
245 GTEST_LOG_(INFO) << "AccessibleAbilityClientStubUnitTest_Unittest_OnRemoteRequest_007 end";
246 }
247 } // namespace Accessibility
248 } // namespace OHOS
249