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 "app_connection_stub_test.h"
17 #include "mock_remote_stub.h"
18 #include "test_log.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace DistributedSchedule {
25 namespace {
26 const std::u16string MOCK_INVALID_DESCRIPTOR = u"invalid descriptor";
27 }
28
29 class MockDmsNotifier : public DmsNotifier {
30 public:
31 MockDmsNotifier() = default;
32 ~MockDmsNotifier() = default;
33
34 void DeviceOnlineNotify(const std::string& deviceId) override;
35 void DeviceOfflineNotify(const std::string& deviceId) override;
36 void ProcessNotifierDied(const sptr<IRemoteObject>& notifier) override;
37 void ScheduleStartDeviceManager(const sptr<IRemoteObject>& appProxy, int32_t token,
38 const std::shared_ptr<ContinuationExtraParams>& continuationExtraParams = nullptr) override;
39 int32_t OnDeviceConnect(int32_t token, const std::vector<ContinuationResult>& continuationResults) override;
40 int32_t OnDeviceDisconnect(int32_t token, const std::vector<ContinuationResult>& continuationResults) override;
41 int32_t OnDeviceCancel() override;
42 };
43
DeviceOnlineNotify(const std::string & deviceId)44 void MockDmsNotifier::DeviceOnlineNotify(const std::string& deviceId)
45 {
46 }
47
DeviceOfflineNotify(const std::string & deviceId)48 void MockDmsNotifier::DeviceOfflineNotify(const std::string& deviceId)
49 {
50 }
51
ProcessNotifierDied(const sptr<IRemoteObject> & notifier)52 void MockDmsNotifier::ProcessNotifierDied(const sptr<IRemoteObject>& notifier)
53 {
54 }
55
ScheduleStartDeviceManager(const sptr<IRemoteObject> & appProxy,int32_t token,const std::shared_ptr<ContinuationExtraParams> & continuationExtraParams)56 void MockDmsNotifier::ScheduleStartDeviceManager(const sptr<IRemoteObject>& appProxy, int32_t token,
57 const std::shared_ptr<ContinuationExtraParams>& continuationExtraParams)
58 {
59 }
60
OnDeviceConnect(int32_t token,const std::vector<ContinuationResult> & continuationResults)61 int32_t MockDmsNotifier::OnDeviceConnect(int32_t token, const std::vector<ContinuationResult>& continuationResults)
62 {
63 return 0;
64 }
65
OnDeviceDisconnect(int32_t token,const std::vector<ContinuationResult> & continuationResults)66 int32_t MockDmsNotifier::OnDeviceDisconnect(int32_t token, const std::vector<ContinuationResult>& continuationResults)
67 {
68 return 0;
69 }
70
OnDeviceCancel()71 int32_t MockDmsNotifier::OnDeviceCancel()
72 {
73 return 0;
74 }
75
SetUpTestCase()76 void AppConnectionStubTest::SetUpTestCase()
77 {
78 DTEST_LOG << "AppConnectionStubTest::SetUpTestCase" << std::endl;
79 }
80
TearDownTestCase()81 void AppConnectionStubTest::TearDownTestCase()
82 {
83 DTEST_LOG << "AppConnectionStubTest::TearDownTestCase" << std::endl;
84 }
85
TearDown()86 void AppConnectionStubTest::TearDown()
87 {
88 DTEST_LOG << "AppConnectionStubTest::TearDown" << std::endl;
89 }
90
SetUp()91 void AppConnectionStubTest::SetUp()
92 {
93 sptr<DmsNotifier> dmsNotifier(new MockDmsNotifier());
94 int32_t token = 0;
95 std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
96 appConnectionStub_ = new AppConnectionStub(dmsNotifier, token, continuationExtraParams);
97 DTEST_LOG << "AppConnectionStubTest::SetUp" << std::endl;
98 }
99
100 /**
101 * @tc.name: AppConnectionStubTest_001
102 * @tc.desc: invalid descriptor
103 * @tc.type: FUNC
104 */
105 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_001, TestSize.Level3)
106 {
107 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_001 begin" << std::endl;
108 int32_t code = 0;
109 MessageParcel data;
110 MessageParcel reply;
111 MessageOption option;
112
113 data.WriteInterfaceToken(MOCK_INVALID_DESCRIPTOR);
114 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
115 EXPECT_EQ(result, ERR_INVALID_STATE);
116 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_001 end" << std::endl;
117 }
118
119 /**
120 * @tc.name: AppConnectionStubTest_002
121 * @tc.desc: invalid element name
122 * @tc.type: FUNC
123 */
124 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_002, TestSize.Level3)
125 {
126 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_002 begin" << std::endl;
127 int32_t code = 0;
128 MessageParcel data;
129 MessageParcel reply;
130 MessageOption option;
131
132 data.WriteInterfaceToken(AppConnectionStub::GetDescriptor());
133 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
134 EXPECT_EQ(result, ERR_INVALID_VALUE);
135 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_002 end" << std::endl;
136 }
137
138 /**
139 * @tc.name: AppConnectionStubTest_003
140 * @tc.desc: test connect done
141 * @tc.type: FUNC
142 */
143 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_003, TestSize.Level3)
144 {
145 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_003 begin" << std::endl;
146 int32_t code = 0;
147 MessageParcel data;
148 MessageParcel reply;
149 MessageOption option;
150
151 data.WriteInterfaceToken(AppConnectionStub::GetDescriptor());
152 AppExecFwk::ElementName element;
153 data.WriteParcelable(&element);
154 code = AppConnectionStub::ON_ABILITY_CONNECT_DONE;
155 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
156 EXPECT_EQ(result, ERR_INVALID_DATA);
157 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_003 end" << std::endl;
158 }
159
160 /**
161 * @tc.name: AppConnectionStubTest_004
162 * @tc.desc: test disconnect done
163 * @tc.type: FUNC
164 */
165 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_004, TestSize.Level3)
166 {
167 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_004 begin" << std::endl;
168 int32_t code = 0;
169 MessageParcel data;
170 MessageParcel reply;
171 MessageOption option;
172
173 data.WriteInterfaceToken(AppConnectionStub::GetDescriptor());
174 AppExecFwk::ElementName element;
175 data.WriteParcelable(&element);
176 code = AppConnectionStub::ON_ABILITY_DISCONNECT_DONE;
177 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
178 EXPECT_EQ(result, ERR_NONE);
179 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_004 end" << std::endl;
180 }
181
182 /**
183 * @tc.name: AppConnectionStubTest_005
184 * @tc.desc: invalid code
185 * @tc.type: FUNC
186 */
187 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_005, TestSize.Level3)
188 {
189 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_005 begin" << std::endl;
190 int32_t code = 0;
191 MessageParcel data;
192 MessageParcel reply;
193 MessageOption option;
194
195 data.WriteInterfaceToken(AppConnectionStub::GetDescriptor());
196 AppExecFwk::ElementName element;
197 data.WriteParcelable(&element);
198 code = -1;
199 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
200 EXPECT_NE(result, ERR_NONE);
201 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_005 end" << std::endl;
202 }
203
204 /**
205 * @tc.name: AppConnectionStubTest_006
206 * @tc.desc: test connect done
207 * @tc.type: FUNC
208 */
209 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_006, TestSize.Level3)
210 {
211 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_006 begin" << std::endl;
212 int32_t code = 0;
213 MessageParcel data;
214 MessageParcel reply;
215 MessageOption option;
216
217 data.WriteInterfaceToken(AppConnectionStub::GetDescriptor());
218 AppExecFwk::ElementName element;
219 data.WriteParcelable(&element);
220 data.WriteRemoteObject((new MockRemoteStub())->AsObject());
221 code = AppConnectionStub::ON_ABILITY_CONNECT_DONE;
222 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
223 EXPECT_EQ(result, ERR_NONE);
224 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_006 end" << std::endl;
225 }
226
227 /**
228 * @tc.name: AppConnectionStubTest_007
229 * @tc.desc: nullptr
230 * @tc.type: FUNC
231 */
232 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_007, TestSize.Level3)
233 {
234 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_007 begin" << std::endl;
235 int32_t code = 0;
236 MessageParcel data;
237 MessageParcel reply;
238 MessageOption option;
239
240 data.WriteInterfaceToken(AppConnectionStub::GetDescriptor());
241 AppExecFwk::ElementName element;
242 data.WriteParcelable(&element);
243 data.WriteRemoteObject((new MockRemoteStub())->AsObject());
244 code = AppConnectionStub::ON_ABILITY_CONNECT_DONE;
245 appConnectionStub_->dmsNotifier_ = nullptr;
246 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
247 EXPECT_EQ(result, ERR_NONE);
248 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_007 end" << std::endl;
249 }
250
251 /**
252 * @tc.name: AppConnectionStubTest_008
253 * @tc.desc: nullptr
254 * @tc.type: FUNC
255 */
256 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_008, TestSize.Level3)
257 {
258 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_008 begin" << std::endl;
259 int32_t code = 0;
260 MessageParcel data;
261 MessageParcel reply;
262 MessageOption option;
263
264 data.WriteInterfaceToken(AppConnectionStub::GetDescriptor());
265 AppExecFwk::ElementName element;
266 data.WriteParcelable(&element);
267 code = AppConnectionStub::ON_ABILITY_DISCONNECT_DONE;
268 appConnectionStub_->dmsNotifier_ = nullptr;
269 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
270 EXPECT_EQ(result, ERR_NONE);
271 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_008 end" << std::endl;
272 }
273 }
274 }