1 /*
2 * Copyright (c) 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 #define LOG_TAG "DataShareServiceStubTest"
16 
17 #include <gtest/gtest.h>
18 #include <unistd.h>
19 #include "log_print.h"
20 #include "ipc_skeleton.h"
21 #include "data_share_service_impl.h"
22 #include "data_share_service_stub.h"
23 
24 using namespace testing::ext;
25 using namespace OHOS::DataShare;
26 using namespace OHOS::DistributedData;
27 const std::u16string INTERFACE_TOKEN = u"OHOS.DataShare.IDataShareService";
28 constexpr uint32_t CODE_MIN = 0;
29 constexpr size_t TEST_SIZE = 1;
30 constexpr uint8_t TEST_DATA = 1;
31 constexpr uint32_t CODE_MAX = IDataShareService::DATA_SHARE_SERVICE_CMD_MAX + 1;
32 namespace OHOS::Test {
33 class DataShareServiceStubTest : public testing::Test {
34 public:
SetUpTestCase(void)35     static void SetUpTestCase(void){};
TearDownTestCase(void)36     static void TearDownTestCase(void){};
SetUp()37     void SetUp(){};
TearDown()38     void TearDown(){};
39 };
40 std::shared_ptr<DataShareServiceImpl> dataShareServiceImpl = std::make_shared<DataShareServiceImpl>();
41 std::shared_ptr<DataShareServiceStub> dataShareServiceStub = dataShareServiceImpl;
42 
43 /**
44 * @tc.name: OnRemoteRequest001
45 * @tc.desc: test OnRemoteRequest data error scene
46 * @tc.type: FUNC
47 * @tc.require:SQL
48 */
49 HWTEST_F(DataShareServiceStubTest, OnRemoteRequest001, TestSize.Level1)
50 {
51     uint8_t value = TEST_DATA;
52     uint8_t *data = &value;
53     size_t size = TEST_SIZE;
54     uint32_t code = static_cast<uint32_t>(*data) % (CODE_MAX - CODE_MIN + 1) + CODE_MIN;
55     MessageParcel request;
56     request.WriteInterfaceToken(INTERFACE_TOKEN);
57     request.WriteBuffer(data, size);
58     request.RewindRead(0);
59     MessageParcel reply;
60     auto result = dataShareServiceStub->OnRemoteRequest(code, request, reply);
61     EXPECT_NE(result, IDataShareService::DATA_SHARE_ERROR);
62 
63     result = dataShareServiceStub->OnNotifyConnectDone(request, reply);
64     EXPECT_EQ(result, IDataShareService::DATA_SHARE_OK);
65 }
66 
67 /**
68 * @tc.name: OnRemoteRequest002
69 * @tc.desc: test OnRemoteRequest abnormal scene
70 * @tc.type: FUNC
71 * @tc.require:SQL
72 */
73 HWTEST_F(DataShareServiceStubTest, OnRemoteRequest002, TestSize.Level1)
74 {
75     uint8_t value = TEST_DATA;
76     uint8_t *data = &value;
77     uint32_t code = static_cast<uint32_t>(*data) % (CODE_MAX - CODE_MIN + 1) + CODE_MIN;
78     MessageParcel request;
79     MessageParcel reply;
80     auto result = dataShareServiceStub->OnRemoteRequest(code, request, reply);
81     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
82 
83     result = dataShareServiceStub->OnNotifyConnectDone(request, reply);
84     EXPECT_EQ(result, IDataShareService::DATA_SHARE_OK);
85 }
86 
87 /**
88 * @tc.name: OnInsert001
89 * @tc.desc: test Insert Update Query Delete function of abnormal scene
90 * @tc.type: FUNC
91 * @tc.require:SQL
92 */
93 HWTEST_F(DataShareServiceStubTest, OnInsert001, TestSize.Level1)
94 {
95     uint8_t value = TEST_DATA;
96     uint8_t *data = &value;
97     size_t size = TEST_SIZE;
98     MessageParcel request;
99     request.WriteInterfaceToken(INTERFACE_TOKEN);
100     request.WriteBuffer(data, size);
101     request.RewindRead(0);
102     MessageParcel reply;
103     auto result = dataShareServiceStub->OnInsert(request, reply);
104     EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR);
105 
106     result = dataShareServiceStub->OnUpdate(request, reply);
107     EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR);
108 
109     result = dataShareServiceStub->OnQuery(request, reply);
110     EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR);
111 
112     result = dataShareServiceStub->OnDelete(request, reply);
113     EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR);
114 }
115 
116 /**
117 * @tc.name: OnAddTemplate001
118 * @tc.desc: test OnAddTemplate function abnormal scene
119 * @tc.type: FUNC
120 * @tc.require:SQL
121 */
122 HWTEST_F(DataShareServiceStubTest, OnAddTemplate001, TestSize.Level1)
123 {
124     uint8_t value = TEST_DATA;
125     uint8_t *data = &value;
126     size_t size = TEST_SIZE;
127     MessageParcel request;
128     request.WriteInterfaceToken(INTERFACE_TOKEN);
129     request.WriteBuffer(data, size);
130     request.RewindRead(0);
131     MessageParcel reply;
132     auto result = dataShareServiceStub->OnAddTemplate(request, reply);
133     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
134 
135     result = dataShareServiceStub->OnDelTemplate(request, reply);
136     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
137 }
138 
139 /**
140 * @tc.name: OnEnablePubSubs001
141 * @tc.desc: test OnEnablePubSubs function abnormal scene
142 * @tc.type: FUNC
143 * @tc.require:SQL
144 */
145 HWTEST_F(DataShareServiceStubTest, OnEnablePubSubs001, TestSize.Level1)
146 {
147     uint8_t value = TEST_DATA;
148     uint8_t *data = &value;
149     size_t size = TEST_SIZE;
150     MessageParcel request;
151     request.WriteInterfaceToken(INTERFACE_TOKEN);
152     request.WriteBuffer(data, size);
153     request.RewindRead(0);
154     MessageParcel reply;
155     auto result = dataShareServiceStub->OnEnablePubSubs(request, reply);
156     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
157 
158     result = dataShareServiceStub->OnPublish(request, reply);
159     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
160 
161     result = dataShareServiceStub->OnGetData(request, reply);
162     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
163 
164     result = dataShareServiceStub->OnSubscribePublishedData(request, reply);
165     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
166 
167     result = dataShareServiceStub->OnUnsubscribePublishedData(request, reply);
168     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
169 
170     result = dataShareServiceStub->OnDisablePubSubs(request, reply);
171     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
172 }
173 
174 /**
175 * @tc.name: OnEnableRdbSubs001
176 * @tc.desc: test OnEnableRdbSubs function abnormal scene
177 * @tc.type: FUNC
178 * @tc.require:SQL
179 */
180 HWTEST_F(DataShareServiceStubTest, OnEnableRdbSubs001, TestSize.Level1)
181 {
182     uint8_t value = TEST_DATA;
183     uint8_t *data = &value;
184     size_t size = TEST_SIZE;
185     MessageParcel request;
186     request.WriteInterfaceToken(INTERFACE_TOKEN);
187     request.WriteBuffer(data, size);
188     request.RewindRead(0);
189     MessageParcel reply;
190     auto result = dataShareServiceStub->OnEnablePubSubs(request, reply);
191     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
192 
193     result = dataShareServiceStub->OnPublish(request, reply);
194     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
195 
196     result = dataShareServiceStub->OnEnableRdbSubs(request, reply);
197     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
198 
199     result = dataShareServiceStub->OnSubscribeRdbData(request, reply);
200     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
201 
202     result = dataShareServiceStub->OnUnsubscribeRdbData(request, reply);
203     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
204 
205     result = dataShareServiceStub->OnDisableRdbSubs(request, reply);
206     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
207 }
208 
209 /**
210 * @tc.name: OnRegisterObserver001
211 * @tc.desc: test OnRegisterObserver function abnormal scene
212 * @tc.type: FUNC
213 * @tc.require:SQL
214 */
215 HWTEST_F(DataShareServiceStubTest, OnRegisterObserver001, TestSize.Level1)
216 {
217     uint8_t value = TEST_DATA;
218     uint8_t *data = &value;
219     size_t size = TEST_SIZE;
220     MessageParcel request;
221     request.WriteInterfaceToken(INTERFACE_TOKEN);
222     request.WriteBuffer(data, size);
223     request.RewindRead(0);
224     MessageParcel reply;
225     auto result = dataShareServiceStub->OnRegisterObserver(request, reply);
226     EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR);
227 
228     result = dataShareServiceStub->OnNotifyObserver(request, reply);
229     EXPECT_EQ(result, IDataShareService::DATA_SHARE_ERROR);
230 
231     result = dataShareServiceStub->OnSetSilentSwitch(request, reply);
232     EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR);
233 
234     result = dataShareServiceStub->OnGetSilentProxyStatus(request, reply);
235     EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR);
236 
237     result = dataShareServiceStub->OnUnregisterObserver(request, reply);
238     EXPECT_EQ(result, IPC_STUB_INVALID_DATA_ERR);
239 }
240 } // namespace OHOS::Test