1 /*
2 * Copyright (c) 2022-2023 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
SetUpTestCase()29 void AppConnectionStubTest::SetUpTestCase()
30 {
31 DTEST_LOG << "AppConnectionStubTest::SetUpTestCase" << std::endl;
32 }
33
TearDownTestCase()34 void AppConnectionStubTest::TearDownTestCase()
35 {
36 DTEST_LOG << "AppConnectionStubTest::TearDownTestCase" << std::endl;
37 }
38
TearDown()39 void AppConnectionStubTest::TearDown()
40 {
41 DTEST_LOG << "AppConnectionStubTest::TearDown" << std::endl;
42 }
43
SetUp()44 void AppConnectionStubTest::SetUp()
45 {
46 int32_t token = 0;
47 std::shared_ptr<ContinuationExtraParams> continuationExtraParams = std::make_shared<ContinuationExtraParams>();
48 appConnectionStub_ = new AppConnectionStub(token, continuationExtraParams);
49 DTEST_LOG << "AppConnectionStubTest::SetUp" << std::endl;
50 }
51
52 /**
53 * @tc.name: AppConnectionStubTest_001
54 * @tc.desc: invalid descriptor
55 * @tc.type: FUNC
56 */
57 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_001, TestSize.Level3)
58 {
59 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_001 begin" << std::endl;
60 int32_t code = 0;
61 MessageParcel data;
62 MessageParcel reply;
63 MessageOption option;
64
65 data.WriteInterfaceToken(MOCK_INVALID_DESCRIPTOR);
66 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
67 EXPECT_EQ(result, ERR_INVALID_STATE);
68 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_001 end" << std::endl;
69 }
70
71 /**
72 * @tc.name: AppConnectionStubTest_002
73 * @tc.desc: invalid element name
74 * @tc.type: FUNC
75 */
76 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_002, TestSize.Level3)
77 {
78 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_002 begin" << std::endl;
79 int32_t code = 0;
80 MessageParcel data;
81 MessageParcel reply;
82 MessageOption option;
83
84 data.WriteInterfaceToken(AppConnectionStub::GetDescriptor());
85 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
86 EXPECT_EQ(result, ERR_INVALID_VALUE);
87 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_002 end" << std::endl;
88 }
89
90 /**
91 * @tc.name: AppConnectionStubTest_003
92 * @tc.desc: test connect done
93 * @tc.type: FUNC
94 */
95 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_003, TestSize.Level3)
96 {
97 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_003 begin" << std::endl;
98 int32_t code = 0;
99 MessageParcel data;
100 MessageParcel reply;
101 MessageOption option;
102
103 data.WriteInterfaceToken(AppConnectionStub::GetDescriptor());
104 AppExecFwk::ElementName element;
105 data.WriteParcelable(&element);
106 code = AppConnectionStub::ON_ABILITY_CONNECT_DONE;
107 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
108 EXPECT_EQ(result, ERR_INVALID_DATA);
109 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_003 end" << std::endl;
110 }
111
112 /**
113 * @tc.name: AppConnectionStubTest_004
114 * @tc.desc: test disconnect done
115 * @tc.type: FUNC
116 */
117 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_004, TestSize.Level3)
118 {
119 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_004 begin" << std::endl;
120 int32_t code = 0;
121 MessageParcel data;
122 MessageParcel reply;
123 MessageOption option;
124
125 data.WriteInterfaceToken(AppConnectionStub::GetDescriptor());
126 AppExecFwk::ElementName element;
127 data.WriteParcelable(&element);
128 code = AppConnectionStub::ON_ABILITY_DISCONNECT_DONE;
129 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
130 EXPECT_EQ(result, ERR_NONE);
131 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_004 end" << std::endl;
132 }
133
134 /**
135 * @tc.name: AppConnectionStubTest_005
136 * @tc.desc: invalid code
137 * @tc.type: FUNC
138 */
139 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_005, TestSize.Level3)
140 {
141 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_005 begin" << std::endl;
142 int32_t code = 0;
143 MessageParcel data;
144 MessageParcel reply;
145 MessageOption option;
146
147 data.WriteInterfaceToken(AppConnectionStub::GetDescriptor());
148 AppExecFwk::ElementName element;
149 data.WriteParcelable(&element);
150 code = -1;
151 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
152 EXPECT_NE(result, ERR_NONE);
153 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_005 end" << std::endl;
154 }
155
156 /**
157 * @tc.name: AppConnectionStubTest_006
158 * @tc.desc: test connect done
159 * @tc.type: FUNC
160 */
161 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_006, TestSize.Level3)
162 {
163 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_006 begin" << std::endl;
164 int32_t code = 0;
165 MessageParcel data;
166 MessageParcel reply;
167 MessageOption option;
168
169 data.WriteInterfaceToken(AppConnectionStub::GetDescriptor());
170 AppExecFwk::ElementName element;
171 data.WriteParcelable(&element);
172 data.WriteRemoteObject((new MockRemoteStub())->AsObject());
173 code = AppConnectionStub::ON_ABILITY_CONNECT_DONE;
174 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
175 EXPECT_EQ(result, ERR_NONE);
176 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_006 end" << std::endl;
177 }
178
179 /**
180 * @tc.name: AppConnectionStubTest_007
181 * @tc.desc: nullptr
182 * @tc.type: FUNC
183 */
184 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_007, TestSize.Level3)
185 {
186 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_007 begin" << std::endl;
187 int32_t code = 0;
188 MessageParcel data;
189 MessageParcel reply;
190 MessageOption option;
191
192 data.WriteInterfaceToken(AppConnectionStub::GetDescriptor());
193 AppExecFwk::ElementName element;
194 data.WriteParcelable(&element);
195 data.WriteRemoteObject((new MockRemoteStub())->AsObject());
196 code = AppConnectionStub::ON_ABILITY_CONNECT_DONE;
197 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
198 EXPECT_EQ(result, ERR_NONE);
199 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_007 end" << std::endl;
200 }
201
202 /**
203 * @tc.name: AppConnectionStubTest_008
204 * @tc.desc: nullptr
205 * @tc.type: FUNC
206 */
207 HWTEST_F(AppConnectionStubTest, AppConnectionStubTest_008, TestSize.Level3)
208 {
209 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_008 begin" << std::endl;
210 int32_t code = 0;
211 MessageParcel data;
212 MessageParcel reply;
213 MessageOption option;
214
215 data.WriteInterfaceToken(AppConnectionStub::GetDescriptor());
216 AppExecFwk::ElementName element;
217 data.WriteParcelable(&element);
218 code = AppConnectionStub::ON_ABILITY_DISCONNECT_DONE;
219 int32_t result = appConnectionStub_->OnRemoteRequest(code, data, reply, option);
220 EXPECT_EQ(result, ERR_NONE);
221 DTEST_LOG << "AppConnectionStubTest AppConnectionStubTest_008 end" << std::endl;
222 }
223 }
224 }